java類排序

⑴ java各種排序

package orderTest;
import java.util.*;
public class IntegerOrderTest {
public static void main(String args[]){
List<Integer> arr=new ArrayList<Integer>();
arr.add(new Integer(2));
arr.add(new Integer(7));
arr.add(new Integer(4));
System.out.println("Before order.....");
for(Integer i:arr){
System.out.println(i);
}
System.out.println("After order.....");
Collections.sort(arr);
for(Integer i:arr){
System.out.println(i);
}

}
}

輸出結果：
Before order.....
2
7
4
After order.....
2
4
7
從所到的結果中，我們可以看到存放在arr的Integer類的對象按初始化的int類型
進行了從小到大的排序。
根據上面的結論我們就可以把各種同一類的對象按我們規定的一個排序，例如我
們要把一個Student類按屬性age的大小排序後輸出。
package orderTest;
public class Student implements Comparable{
private String name; //學生姓名
private int age; //學生年齡
//構造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//私有成員變數的外部訪問方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//重寫compareTo方法，規定我們想排序的順序
public int compareTo(Object o) {
return this.age-((Student)o).age;
}
//重寫toString方法，便於輸出
public String toString(){
return name+" "+age;
}

}

package orderTest;
import java.util.*;
public class StudentOrderTest {
public static void main(String[] args) {
//用一個數組來存放所要排序的對象
List<Student>students=new ArrayList<Student>();
//把各個對象加到數組中去
students.add(new Student("Jack",20));
students.add(new Student("Rose",18));
students.add(new Student("Bill",22));
students.add(new Student("Tick",10));
//輸出排序前數組中的各個對象
for(Student s:students){
System.out.println(s.toString());
}
//利用Collections類的靜態方法sort進行排序
Collections.sort(students);
//輸出排序後數組中的各個對象
System.out.println("**************");
for(Student s:students){
System.out.println(s.toString());
}
}
}

輸出結果：
Jack 20
Rose 18
Bill 22
Tick 10
**************
Tick 10
Rose 18
Jack 20
Bill 22
對於解決根據某一類對象進行排序的問題，我們就可以很方便的解決了，而不需
要像我們平常一樣用到各種排序演算法，而對於私有成員（如：Student中的age）
更不好在其它類中對其實現排序了。

⑵ 如何對JAVA的類進行一個排序 就像C的結構體差不多的。

實現compare介面，復寫方法compareTo方法就可以，然後調用java集合的sort方法就可以

⑶ java中類數組怎麼排序

用for嵌套循環，再寫一個temp變數，跟數組屬性一樣，存儲中間值，用冒泡法個人覺得最簡單的，
先用第一個值來挨個和下面的值進行比較，第一次
循環會找出最小的那個整形值，然後把最小所以的數組存儲在temp中，將外循環的數組存儲到這個數組中，然後將temp的值放到外循環的數組中，然後第二個值再與從第三個-------到最後一個值進行比較找到次小的，交換方法與前面的一樣，
最後循環完了就排好序了，
如：數組下標是10，則外循環是從0-8
內循環是1-9

⑷ Java排序一共有幾種

日常操作中，常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。

各類排序方法代碼如圖：

⑸ java怎樣對實體類進行排序操作

可以重寫類裡面的compareto 方法 ，利用類中的某個屬性的排列大小的規則來定義整個類的排序規則
親，懂了木有？
沒懂繼續問我喲~

⑹ Java中怎麼給一個對象排序

Comparable 是一個自身以前支持自比擬的（如String ,Integer) 的介面 Comparator 可以說是一個 自用的比擬器 當對象自身 不支持自排序和自比擬函數的時辰 咱們可以議決完成Compartor 來比擬兩對象的大小 Comparable 是一個比擬通用的介面 用戶可以議決他完成 排序功用 而Comparator 可以看作一種演算法 一種設計方式 （可以看作是一個戰略方式 就是不改動對象自身，而用一個戰略對象改動對象行為） Comparable 相比擬較固定 與詳細類綁定 ， Comparator 比擬靈敏 可以與任何須要完成功用的類 綁定 Comparable 可以說是 靜態綁定 Comparator 可以說是靜態綁定 Comparable 此介面強行對完成它的每個類的對象執行全體排序。此排序被稱為該類的自然排序，類的 compareTo 方法被稱為它的自然比擬方法。 完成此介面的對象列表（和數組）可以議決 Collections.sort（和 Arrays.sort）執行自動排序。完成此介面的對象可以用作有序映射表中的鍵或有序集合中的元素，無需指定比擬器。 關於類 C 的每一個 e1 和 e2 來說，當且僅當 (e1.compareTo((Object)e2) == 0) 與 e1.equals((Object)e2) 具有類似的布爾值時，類 C 的自然排序才叫做與 equals 一致。留意，null 不是任何類的實例，即便 e.equals(null) 前往 false，e.compareTo(null) 也會拋出 NullPointerException。 劇烈推薦（雖然不是必需的）使自然排序與 equals 一致。這是由於在運用其自然排序與 equals 不一致的元素（或鍵）時，沒有顯式比擬器的有序集合（和有序映射表）行為表現「怪異」。尤其是，這樣的有序集合（或有序映射表）違犯了依據 equals 方法定義的集合（或映射表）的慣例協議。 而Comparator 比擬函數強行對某些對象 collection 執行全體排序。可以將 Comparator 傳遞給 sort 方法（如 Collections.sort），從而准許在排序順序上完成精確控制。還可以運用 Comparator 來控制某些數據結構（如 TreeSet 或 TreeMap）的順序。

⑺ java程序排序

自己寫的三種傳統排序法。快排法主要是自己也沒怎麼搞明白……
（你可以建數組來存數據，就不寫完整的了。）

public void insert(int[] a3) {//插入排序法
// TODO Auto-generated method stub
System.out.println("插入法");
int temper=0;
for(int i=1;i<a3.length;i++){
for(int j=i;j>0;j--){
if(a3[j]<a3[j-1]){
temper=a3[j];
a3[j]=a3[j-1];
a3[j-1]=temper;
}else break;
}
}
}
//插入排序法完

//選擇排序法
public void select(int[] a2) {
// TODO Auto-generated method stub
System.out.println("選擇排序法");
int temper=0;
for (int i = 0; i < a2.length-1; i++) {
int min = a2[i];
int minFoot = i;
for (int j = i + 1; j < a2.length; j++) {
if (min > a2[j]) {
min=a2[j];
minFoot=j;
}
}
temper=a2[i];
a2[i]=min;
a2[minFoot]=temper;
}
}
//選擇排序法完

//冒泡排序法
public void Bubbling(int[] a1) {
System.out.println("冒泡排序法");
int temper = 0;
for (int i = 0; i < a1.length - 1; i++) {
for (int j = 0; j < a1.length - 1 - i; j++) {
if (this.a1[j] > this.a1[j + 1]) {
temper = a1[j];
a1[j] = a1[j + 1];
a1[j + 1] = temper;
}
}
}
}

//冒泡排序法完

⑻ Java的排序演算法有哪些

java的排序大的分類可以分為兩種：內排序和外排序。在排序過程中，全部記錄存放在內存，則稱為內排序，如果排序過程中需要使用外存，則稱為外排序。下面講的排序都是屬於內排序。
1.插入排序：直接插入排序、二分法插入排序、希爾排序。
2.選擇排序：簡單選擇排序、堆排序。
3.交換排序：冒泡排序、快速排序。
4.歸並排序
5.基數排序

⑼ JAVA中如何根據類的屬性進行排序，然後輸出類的所有信息，求大神解答。

您好，您這樣：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
* 作者： 版本： 要求：設計一個具備比較功能的類（例如 員工類, 需要有姓名, 年齡, 薪水三個成員屬性，需要私有並提供get, set方法,
* 可以通過構造函數進行 初始化，並且按照薪水進行排序）。
*/
public class Employee {
private String name;
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public int getSalary() {
return salary;
}

public void setSalary(int salary) {
this.salary = salary;
}

private int age;
private int salary;

public Employee(String na, int ag, int sa) {
name = na;
age = ag;
salary = sa;
}

@Override
public String toString() {
return this.name + " , " + this.getAge() + " , " + this.salary;
}

public static void main(String args[]) {
Employee e1 = new Employee("霸氣外漏老總", 35, 20000);
Employee e2 = new Employee("瘋牛涕淌小三", 29, 7000);
Employee e3 = new Employee("萬年屌絲基佬", 27, 4700);
List list = new ArrayList();
list.add(e1);
list.add(e2);
list.add(e3);
Comparator comp = new ComparatorImpl();
Collections.sort(list, comp);
for (Employee e : (List<Employee>)list) {
System.out.println(e);
}
}
}

class ComparatorImpl implements Comparator<Employee> {
public int compare(Employee e1, Employee e2) {
int salary1 = e1.getSalary();
int salary2 = e2.getSalary();
if (salary1 > salary2) {
return 1;
} else if (salary1 < salary2) {
return -1;
} else {
return 0;
}
}
}