Collections.sort的两种用法 转

Java代码  

  1. /**
  2. * @author guwh
  3. * @version 创建时间:2011-11-3 上午10:49:36
  4. * 类说明
  5. */
  6. package com.jabberchina.test;
  7. import java.util.ArrayList;
  8. import java.util.Collections;
  9. import java.util.Comparator;
  10. import java.util.List;
  11. public class SortTest {
  12. public static void main(String[] args) {
  13. List<String> lists = new ArrayList<String>();
  14. List<A> list = new ArrayList<A>();
  15. List<B> listB = new ArrayList<B>();
  16. lists.add("5");
  17. lists.add("2");
  18. lists.add("9");
  19. //lists中的对象String 本身含有compareTo方法,所以可以直接调用sort方法,按自然顺序排序,即升序排序
  20. Collections.sort(lists);
  21. A aa = new A();
  22. aa.setName("aa");
  23. aa.setOrder(1);
  24. A bb = new A();
  25. bb.setName("bb");
  26. bb.setOrder(2);
  27. list.add(bb);
  28. list.add(aa);
  29. //list中的对象A实现Comparable接口
  30. Collections.sort(list);
  31. B ab = new B();
  32. ab.setName("ab");
  33. ab.setOrder("1");
  34. B ba = new B();
  35. ba.setName("ba");
  36. ba.setOrder("2");
  37. listB.add(ba);
  38. listB.add(ab);
  39. //根据Collections.sort重载方法来实现
  40. Collections.sort(listB,new Comparator<B>(){
  41. @Override
  42. public int compare(B b1, B b2) {
  43. return b1.getOrder().compareTo(b2.getOrder());
  44. }
  45. });
  46. System.out.println(lists);
  47. System.out.println(list);
  48. System.out.println(listB);
  49. }
  50. }
  51. class A implements Comparable<A>{
  52. private String name;
  53. private Integer order;
  54. public String getName() {
  55. return name;
  56. }
  57. public void setName(String name) {
  58. this.name = name;
  59. }
  60. public Integer getOrder() {
  61. return order;
  62. }
  63. public void setOrder(Integer order) {
  64. this.order = order;
  65. }
  66. @Override
  67. public String toString() {
  68. return "name is "+name+" order is "+order;
  69. }
  70. @Override
  71. public int compareTo(A a) {
  72. return this.order.compareTo(a.getOrder());
  73. }
  74. }
  75. class B{
  76. private String name;
  77. private String order;
  78. public String getName() {
  79. return name;
  80. }
  81. public void setName(String name) {
  82. this.name = name;
  83. }
  84. public String getOrder() {
  85. return order;
  86. }
  87. public void setOrder(String order) {
  88. this.order = order;
  89. }
  90. @Override
  91. public String toString() {
  92. return "name is "+name+" order is "+order;
  93. }
  94. }
  95. 打印的结果为:
  96. [2, 5, 9]
  97. [name is aa order is 1, name is bb order is 2]
  98. [name is ab order is 1, name is ba order is 2]
时间: 2024-10-24 06:05:32

Collections.sort的两种用法 转的相关文章

java基础——Collections.sort的两种用法

Collections是一个工具类,sort是其中的静态方法,是用来对List类型进行排序的,它有两种参数形式: public static <T extends Comparable<? super T>> void sort(List<T> list) { list.sort(null); } public static <T> void sort(List<T> list, Comparator<? super T> c) {

Java中Collections类的排序sort函数两种用法 (转http://viver120.blog.163.com/blog/static/60072482013010111228695/)

java中的Colletions类主要实现列表List的排序功能.根据函数参数的传递,具体的排序可以分为 : 1.  自然排序(natural ordering). 函数原型:sort(List<T> list)说明:参数是要参与排序列表的List对象                                                               实例说明:参与排序的列表的元素Student必须实现Comparable接口的public int compareTo(

Android Collections.sort的几种用法介绍

Java代码   /** * @author alex * @version 创建时间:2014-11-3 上午10:49:36 * 类说明 */ package com.jabberchina.test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class SortTest { public stati

JSP中的include的两种用法

1.两种用法 <@inlcude file ="header.jsp"/> 此时引入的是静态的jsp文件,它将引入的jsp中的源代码原封不动地附加到当前文件中,所以在jsp程序中使用这个指令的时候file里面的值(即要导入的文件)不能带多余的标签或是与当前jsp文件重复的东西.例如里面不要包含<html><body>这样的标签,因为是把源代码原封不动的附加过来,所以会与当前的jsp中的这样的标签重复导致出错. <jsp:include page

Android---24---Spinner的两种用法

Spinner是一个列表选择框,它有两种用法: 一种是使用android:entries属性的,一种是不使用该属性,通过动态的添加Adapter来实现的. 第一种: MainActivity.java: import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.MenuItem; import android.view.View; import andr

operator 的两种用法

C++,有时它的确是个耐玩的东东,就比如operator,它有两种用法,一种是operator overloading(操作符重载),一种是operator casting(操作隐式转换). 1.操作符重载C++可以通过operator实现重载操作符,格式如下:类型T operator 操作符 (),比如重载+,比如下面这个例子template<typename T> class A{public:     const T operator+(const T& rhs)     {  

jsp中include的两种用法

JSP中的include的两种用法 1.两种用法 <%@ include file=” ”%> <jsp:include page=” ” flush=”true”/> 2.用法区别 (1)执行时间上区别 <%@ include file=”relativeURI”%>                   是在翻译阶段执行 <jsp:include page=”relativeURI” flush=”true” />  在请求处理阶段执行. (2)引入内容的

c++ operator操作符的两种用法:重载和隐式类型转换,string转其他基本数据类型的简洁实现string_cast

C++中的operator主要有两个作用,一是操作符的重载,一是自定义对象类型的隐式转换.对于操作符的重载,许多人都不陌生,但是估计不少人都不太熟悉operator的第二种用法,即自定义对象类型的隐式转换,我们下面就用以下这个小例子温故一下这两种用法: 1 #include <iostream> 2 #include <sstream> 3 using namespace std; 4 5 class FuncObj 6 { 7 public: 8 FuncObj(int n):

include的两种用法之间的区别

以下是对include 两种用法的区别 主要有两个方面的不同; 一:执行时间上: <%@ include file="relativeURI"%> 是在翻译阶段执行 <jsp:include page="relativeURI" flush="true" /> 在请求处理阶段执行. 二:引入内容的不同: <%@ include file="relativeURI"%> 引入静态文本(html