博客

/**

* 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<Cat> {


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();

}

}

调用Collections.sort(List<T> 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

/**

* 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 + ‘\” +

‘}’;

}

}

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<Person> {


/**

* 排序接口算法实现

*

* @param o1

* @param o2

* @return 比较结果的大小

*/



public


int

compare(Person o1, Person o2) {


return

o1.getAge() – o2.getAge();

}

}

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框架利用这个算法实现了不同集合类型对象排序方式的统一.<br>

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

*/



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<Person> listPerson =

new

ArrayList<Person>();

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<Person> 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<Person> 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());

}

}

排序后集合为:

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