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;
}
}
}