java集合倒序打印_Java集合对象排序测试

Java集合对象排序测试

Java API针对集合类型排序提供了两种支持：

java.util.Collections.sort(java.util.List)

java.util.Collections.sort(java.util.List, java.util.Comparator)

第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。

第二个方法要求实现一个java.util.Comparator接口。

java.lang.Comparable接口和java.util.Comparator接口是Java对排序最提供最基本支持。这两个接口不但可以用于集合元素排序，还可以用于数组排序。

如果数组或集合元素是String类型，则可以利用Java API实现的Comparator对象String.CASE_INSENSITIVE_ORDER为容器元素排序。

下面给出两个里测试，涵盖集合和数组的排序，并且还演示了数组和集合的相互转换：

例子一：实现Comparable接口排序

package collsort.comparable;

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2008-3-29 22:21:19

* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url])

* 要排序的元素对象

*/

public class Cat implements Comparable {

private int age;

private String name;

public Cat(int age, String name) {

this.age = age;

this.name = name;

}

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;

}

public String toString() {

return "Cat{" +

"age=" + age +

", name='" + name + '\'' +

'}';

}

public int compareTo(Cat o) {

return this.getAge() - o.getAge();

}

}

package collsort.comparable;

import java.util.*;

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2008-3-29 22:24:12

* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url])

* 通过实现Comparable接口实现个性化排序测试

*/

public class TestComparable {

public static String outCollection(Collection coll) {

StringBuffer sb = new StringBuffer();

for (Object obj : coll) {

sb.append(obj + "\n");

}

System.out.println(sb.toString());

return sb.toString();

}

public static void main(String args[]) {

test();

test2();

}

public static void test() {

System.out.println("----------test()---------");

System.out.println("升序排序测试:");

List listCat = new ArrayList();

Cat cat1 = new Cat(34, "hehe");

Cat cat2 = new Cat(12, "haha");

//        Person catx = new Person(12, "lavasoft");

Cat cat3 = new Cat(23, "leizhimin");

Cat cat4 = new Cat(13, "lavasoft");

listCat.add(cat1);

listCat.add(cat2);

listCat.add(cat3);

//        listCat.add(catx);

System.out.println("原集合为:");

outCollection(listCat);

System.out.println("调用Collections.sort(List list)排序：");

Collections.sort(listCat);

outCollection(listCat);

System.out.println("逆序排列元素:");

Collections.sort(listCat, Collections.reverseOrder());

outCollection(listCat);

System.out.println("再次逆序排列元素:");

Collections.reverse(listCat);

outCollection(listCat);

System.out.println("添加一个元素后输出集合：");

listCat.add(cat4);

outCollection(listCat);

System.out.println("排列后输出:");

Collections.sort(listCat);

outCollection(listCat);

}

/**

* 针对数组的排序

*/

public static void test2(){

String[] strArray = new String[] {"z", "a", "C"};

System.out.println("-------------数组转换为列表-------------");

List list = Arrays.asList(strArray);

outCollection(list);

System.out.println("-------------列表转换为数组(1)-------------");

String[] strArrayNew1 = list.toArray(strArray);

for(String str:strArrayNew1){

System.out.println(str);

}

System.out.println("-------------列表转换为数组(2)-------------");

String[] strArrayNew2 = (String[]) list.toArray();

for(String str:strArrayNew2){

System.out.println(str);

}

System.out.println("-------------顺序排序列表-------------");

Collections.sort(list);

outCollection(list);

System.out.println("-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

outCollection(list);

System.out.println("-------------倒序排序列表-------------");

Collections.sort(list, Collections.reverseOrder());

outCollection(list);

System.out.println("-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

outCollection(list);

System.out.println("-----反转列表元素的顺序------");

Collections.reverse(list);

outCollection(list);

}

}

运行结果：

----------test()---------

升序排序测试:

原集合为:

Cat{age=34, name='hehe'}

Cat{age=12, name='haha'}

Cat{age=23, name='leizhimin'}

调用Collections.sort(List list)排序：

Cat{age=12, name='haha'}

Cat{age=23, name='leizhimin'}

Cat{age=34, name='hehe'}

逆序排列元素:

Cat{age=34, name='hehe'}

Cat{age=23, name='leizhimin'}

Cat{age=12, name='haha'}

再次逆序排列元素:

Cat{age=12, name='haha'}

Cat{age=23, name='leizhimin'}

Cat{age=34, name='hehe'}

添加一个元素后输出集合：

Cat{age=12, name='haha'}

Cat{age=23, name='leizhimin'}

Cat{age=34, name='hehe'}

Cat{age=13, name='lavasoft'}

排列后输出:

Cat{age=12, name='haha'}

Cat{age=13, name='lavasoft'}

Cat{age=23, name='leizhimin'}

Cat{age=34, name='hehe'}

-------------数组转换为列表-------------

z

a

C

-------------列表转换为数组(1)-------------

z

a

C

-------------列表转换为数组(2)-------------

z

a

C

-------------顺序排序列表-------------

C

a

z

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----

a

C

z

-------------倒序排序列表-------------

z

a

C

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----

a

C

z

-----反转列表元素的顺序------

z

C

a

Process finished with exit code 0

例子一：实现Comparator接口排序

package collsort.compare;

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2008-3-29 13:28:29

* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url])

* 要排序的元素对象

*/

public class Person {

private int age;

private String name;

public Person(int age, String name) {

this.age = age;

this.name = name;

}

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;

}

public String toString() {

return "Person{" +

"age=" + age +

", name='" + name + '\'' +

'}';

}

}

package collsort.compare;

import java.util.Comparator;

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2008-3-29 13:29:35

* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url])

* Person类的排序接口

*/

public class PersonComparator implements Comparator {

/**

* 排序接口算法实现

*

* @param o1

* @param o2

* @return 比较结果的大小

*/

public int compare(Person o1, Person o2) {

return o1.getAge() - o2.getAge();

}

}

package collsort.compare;

import collsort.compare.Person;

import java.util.*;

/**

* Created by IntelliJ IDEA.

* User: leizhimin

* Date: 2008-3-29 13:30:49

* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url])

* 通过Comparator接口实现个性化排序测试

* 结论:Comparator接口是一个为集合对象排序的基本算法,其中的compare方法是比较两个元素对象的比较方式.Java Collection框架利用这个算法实现了不同集合类型对象排序方式的统一.

* 排序针对的是确切的集合对象,当集合对象的元素发生变化时,集合内的元素不会自动重新排序.

*/

public class TestComparator {

public static String outCollection(Collection coll) {

StringBuffer sb = new StringBuffer();

for (Object obj : coll) {

sb.append(obj + "\n");

}

System.out.println(sb.toString());

return sb.toString();

}

public static void main(String args[]) {

test1();

}

public static void test1() {

System.out.println("----------test1()---------");

System.out.println("升序排序测试:");

List listPerson = new ArrayList();

Person person1 = new Person(34, "lavasoft");

Person person2 = new Person(12, "lavasoft");

//        Person personx = new Person(12, "lavasoft");

Person person3 = new Person(23, "leizhimin");

Person person4 = new Person(13, "sdg");

listPerson.add(person1);

listPerson.add(person2);

listPerson.add(person3);

//        listPerson.add(personx);

Comparator ascComparator = new PersonComparator();

System.out.println("原集合为:");

outCollection(listPerson);

System.out.println("排序后集合为:");

//利用Collections类静态工具方法对集合List进行排序

Collections.sort(listPerson, ascComparator);

outCollection(listPerson);

System.out.println("在继续添加一个Person对象,集合为:");

listPerson.add(person4);

outCollection(listPerson);

System.out.println("添加一个对象后,重新排序输出:");

Collections.sort(listPerson, ascComparator);

outCollection(listPerson);

System.out.println("\n降序排序测试:");

//从升序排序对象产生一个反转(降序)的排序对象

Comparator descComparator = Collections.reverseOrder(ascComparator);

System.out.println("利用反转后的排序接口对象对集合List排序并输出:");

Collections.sort(listPerson, descComparator);

outCollection(listPerson);

System.out.println("\n求最大最小元素测试:");

Person p_max = Collections.max(listPerson, ascComparator);

Person p_min = Collections.min(listPerson, ascComparator);

System.out.println("最大元素为:" + p_max.toString());

System.out.println("最小元素为:" + p_min.toString());

}

}

运行结果：

----------test1()---------

升序排序测试:

原集合为:

Person{age=34, name='lavasoft'}

Person{age=12, name='lavasoft'}

Person{age=23, name='leizhimin'}

排序后集合为:

Person{age=12, name='lavasoft'}

Person{age=23, name='leizhimin'}

Person{age=34, name='lavasoft'}

在继续添加一个Person对象,集合为:

Person{age=12, name='lavasoft'}

Person{age=23, name='leizhimin'}

Person{age=34, name='lavasoft'}

Person{age=13, name='sdg'}

添加一个对象后,重新排序输出:

Person{age=12, name='lavasoft'}

Person{age=13, name='sdg'}

Person{age=23, name='leizhimin'}

Person{age=34, name='lavasoft'}

降序排序测试:

利用反转后的排序接口对象对集合List排序并输出:

Person{age=34, name='lavasoft'}

Person{age=23, name='leizhimin'}

Person{age=13, name='sdg'}

Person{age=12, name='lavasoft'}

求最大最小元素测试:

最大元素为:Person{age=34, name='lavasoft'}

最小元素为:Person{age=12, name='lavasoft'}

Process finished with exit code 0

最后说明一下，Java如何通过所实现接口的方法进行排序是API内部的事情，Java这样处理排序目的就是对容器元素排序有一个统一的方式，以简化编程。

当然也可以自己通过别的算法进行元素排序，在此不做讨论。