- 浏览: 471355 次
- 性别:
- 来自: 广州
文章分类
- 全部博客 (190)
- ExtJS (40)
- JavaScript (16)
- Java设计模式 (13)
- Html (10)
- Tomcat (9)
- myeclipse (5)
- JSP (5)
- CSS (10)
- JS/CSS (1)
- windows (12)
- Navicat For MySQL (1)
- struts2 (6)
- Spring2.0 (1)
- Java反射机制 (5)
- hibernate (9)
- java (17)
- B/SWeb完美打印方案 (1)
- 数据库相关 (4)
- java web报表 (1)
- 报表打印 (2)
- java泛型 (1)
- Servlet (2)
- SVN (7)
- Log4j (0)
- android (3)
最新评论
-
kation733:
斯蒂芬斯蒂芬多萨法阿凡达是否阿萨德
同时开启两个Tomcat -
BlueBing:
一路的夏天 写道楼主的代码会报错吧!在前面的时候String ...
使用Java反射机制遍历实体类的属性和类型 -
ying890:
非常感谢!
Ext JS中文乱码解决方案 -
zhylandroid:
谢谢了,对我很有帮助
DatabaseMetaData开发实务(上) -
wendy.wujing:
maxHttpHeaderSize="8192&qu ...
查看Tomcat配置的端口
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>对象String.CASE_INSENSITIVE_ORDER为容器元素排序。
下面给出两个里测试,涵盖集合和数组的排序,并且还演示了数组和集合的相互转换:
例子一:实现Comparable接口排序
package collsort.comparable;
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-3-29 22:21:19
* Company: LavaSoft(http://lavasoft.blog.51cto.com )
* 要排序的元素对象
*/
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();
}
}
package collsort.comparable;
import java.util.*;
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-3-29 22:24:12
* Company: LavaSoft(http://lavasoft.blog.51cto.com )
* 通过实现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<Cat> listCat = new ArrayList<Cat>();
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<T> 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<String> 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<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
例子一:实现Comparator接口排序
package collsort.compare;
/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-3-29 13:28:29
* Company: LavaSoft(http://lavasoft.blog.51cto.com )
* 要排序的元素对象
*/
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(http://lavasoft.blog.51cto.com )
* Person类的排序接口
*/
public class PersonComparator implements Comparator<Person> {
/**
* 排序接口算法实现
*
* @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(http://lavasoft.blog.51cto.com )
* 通过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());
}
}
运行结果:
----------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这样处理排序目的就是对容器元素排序有一个统一的方式,以简化编程。
当然也可以自己通过别的算法进行元素排序,在此不做讨论。
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/woshiliukui/archive/2009/07/27/4382866.aspx
发表评论
-
Errors running builder 'JavaScript Validator' on project '......'
2013-02-22 12:14 1007在编译java工程时,如果出现 “Errors occur ... -
list,set,map,数组间的相互转换
2012-09-29 13:53 1046list,set,map,数组间的相互转换 ... -
POI学习笔记(三)
2010-06-29 15:14 426714. 自定义颜色 HSSF: ... -
POI学习笔记(二)
2010-06-29 15:12 50367. 设置单元格的边框 Java代码 ... -
POI学习笔记(一)
2010-06-29 15:10 7392项目中经常要解析和生成Excel文件,最常用的开源组件有poi ... -
web.xml 配置详解
2010-05-27 11:07 1118在项目中总会遇到一些关于加载的优先级问题,近期也同样遇到过类似 ... -
如何调用hh.exe或者别的命令行的方式,在已经打开了的chm中,定位到指定页面?
2010-05-25 11:55 2156hh.exe mk:@MSITStore:F:\\buyord ... -
如何用一个按钮打开chm的帮助文件
2010-05-25 10:26 2128如果是在windows下运行的话,可以用Runtime的get ... -
java文件或jsp、xml文件注释
2010-01-13 16:29 1824Java用Shift+Ctrl+C(单行注释)没问题,Jsp页 ... -
对Java Serializable(序列化)的理解和总结
2010-01-12 09:05 10601、序列化是干什么的? ... -
基本数据类型转换
2010-01-06 09:42 1043int -> String int i=12345;S ... -
配置JDK
2009-12-18 15:07 1377下载好的JDK是一个可执 ... -
一个java处理JSON格式数据的通用类
2009-12-10 16:50 1234一个java处理JSON格式数据的通用类 进入需要在项目中用 ... -
JAVA注解
2009-12-04 08:33 2690java 注解 可以使用在类,方法,全局变量,局部变量作用: ... -
java中对于复杂对象排序的模型及其实现
2009-11-18 09:41 1153排序是编程中经常要碰到的问题,如果只是一般的数据库数据那么我们 ... -
java中对于复杂对象排序的模型及其实现
2009-10-23 15:26 1436排序是编程中经常要碰到的问题,如果只是一般的数据库数据那么我们 ...
相关推荐
总的来说,Java对象排序是通过实现`Comparable`接口或使用`Comparator`来完成的。理解这两个接口的用法,并熟练掌握`Collections.sort()`和`Arrays.sort()`的使用,是成为熟练Java开发者的必备技能。在实际编程中,...
在Java编程语言中,对象排序是一项关键操作,特别是在处理集合数据结构时。本文将深入探讨如何对ArrayList、HashSet、TreeSet以及数组中的对象进行排序。理解这些排序机制对于编写高效且可维护的代码至关重要。 ...
这里我们探讨的主题是如何根据对象的属性进行排序,结合提供的`Simple.java`和`User.java`文件,我们可以假设这是一个关于自定义对象排序的例子。下面将详细解释相关知识点。 1. **Comparable接口**: Java中的`...
本主题将深入探讨如何使用SortedSet接口来实现Java对象的中文排序,并通过源码分析理解其工作原理。 首先,SortedSet是Java集合框架中的一个接口,它继承自Set接口并添加了排序的特性。SortedSet的主要实现类有...
总的来说,Java中的对象排序是一个核心技能,理解并掌握`Comparator`接口的使用对于提升代码的可读性和可维护性至关重要。通过上述小实例,你应该能掌握在Java中如何对对象数组进行降序排序,为今后的编程实践打下...
Java 对象排序(使用 Comparator) 如果我们需要对一个对象列表中的某个字段(如年龄)进行排序,可以创建一个 `Comparator` 实现。 ```java import java.util.*; import java.text.*; public class ...
commons-beanutils-1.8.3.jar commons-collections-3.2.1.jar commons-logging-1.1.3.jar这三个包都是从apache官网下的,含源码、api文档
总结一下,当需要对Java对象数组按多个属性排序时,我们可以: 1. 实现`Comparator`接口并自定义`compare()`方法。 2. 使用lambda表达式或方法引用来创建`Comparator`实例,使代码更加简洁。 3. 对于数组,使用`...
本文将深入探讨如何在Java的List中对包含多个属性的对象进行排序,并且支持动态设置每个属性的排序方式。这个功能的实现是通过泛型和自定义比较器(Comparator)来完成的,对于复杂的数据排序需求具有很高的灵活性。...
本示例将详细介绍如何对Java对象属性Map进行排序。 首先,了解Map的基本类型。Java提供了HashMap、TreeMap等实现Map接口的类。HashMap是非排序的,而TreeMap是基于红黑树数据结构,会按照键的自然顺序或者自定义...
【面向对象Java排序包】是基于Java编程语言设计的一个专门用于处理排序问题的软件组件。这个包充分体现了面向对象的设计原则,将数据结构、算法和业务逻辑封装在独立的对象中,提高了代码的可读性和可维护性。它不仅...
在Java中,对象排序主要是通过对象实现`Comparable`接口或者使用自定义的`Comparator`来完成的。 1. **对象排序**: 当对象需要进行排序时,它应该实现`Comparable`接口。`Comparable`接口有一个`compareTo()`方法...
对于大型数据集,`Collections.sort()`通常能提供很好的性能,但如果需要对大量不可变对象或已排序的列表进行排序,使用`TreeSet`或`LinkedHashSet`等集合类型可能会更高效,因为它们在底层实现了红黑树结构,插入和...
总的来说,Java中的面向对象思想为实现各种排序算法提供了灵活的结构和强大的功能。通过封装、继承和多态,我们可以构建出易于理解和维护的代码,同时适应不同的排序需求。在开发过程中,理解并熟练运用这些面向对象...
下面我们将深入探讨如何在Java中实现集合的分组与排序。 1. **集合分组**: 集合分组通常涉及到`GroupingBy`操作,这在Java 8引入的流(Stream)API中得到了很好的支持。`Collectors.groupingBy`方法允许我们将...
在Java中实现二叉排序树,我们通常会定义一个`Node`类来表示树的节点,它包含键、值以及左右子节点的引用。例如: ```java class Node { int key; Object value; Node left, right; public Node(int item) { ...
List对象排序通用方法List对象排序通用方法List对象排序通用方法List对象排序通用方法
在JAVA中,实现这两种排序算法可以使用面向对象的特性,创建一个类如`MaopaoKuaisu.java`,在这个类中定义两个方法,分别实现冒泡排序和快速排序。类的结构可能如下: ```java public class MaopaoKuaisu { public...
16.CompareObj.java 对象排序实现 17.SetAndList.java set的简单操作极其hashcode应用 18.Singleton.java java设计模式之单例模式 19.Factory.java 设计模式之工厂模式 20.Swing.java 介绍了java的图形应用 ...