【JAVA集合框架之工具类】

一、概述

JAVA集合框架中有两个很重要的工具类，一个是Collections，另一个是Arrays。分别封装了对集合的操作方法和对数组的操作方法，这些操作方法使得程序员的开发更加高效。

public class Collections extends Object      全类名：java.util.Collections 

public class Arrays extends Object           全类名：java.util.Arrays 

二.Collections类。

1.Collections.sort方法。

public static <T extends Comparable<? super T>> void sort(List<T> list)

public static <T> void sort(List<T> list, Comparator<? super T> c)

（1）示例。

现在有一些字符串，可能有重复元素，想要将它们存入一个容器中并按照一定的规则进行排序，该怎么做？

思路：使用ArrayList集合进行存储并使用Collections.sort方法进行排序。

 1 package p01.ColletionsDemo.p01.SortDemo;
 2
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5
 6 public class SortDemo {
 7
 8     public static void main(String[] args) {
 9         Demo1();
10
11     }
12     private static void Demo1() {
13         ArrayList<String>al=new ArrayList<String>();
14         al.add("abc");
15         al.add("bca");
16         al.add("aab");
17         al.add("bac");
18         al.add("cba");
19         System.out.println("排序前："+al);
20         Collections.sort(al);
21         System.out.println("排序后："+al);
22     }
23
24 }

这是按照字符串的自然排序方式排序的代码，即输出结果的字符串是按照字典序排序的。

现在有了新的需求，即按照字符串长度排序，如果字符串长度相同按照字典序排序，这时候需要使用比较器。

 1 package p01.ColletionsDemo.p01.SortDemo;
 2
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6
 7 public class SortDemo {
 8     public static void main(String[] args) {
 9         //Demo1();
10         Demo2();
11     }
12     /*
13      * Demo2：该方法采用带比较器的Collections.sort方法
14      */
15     private static void Demo2() {
16         ArrayList<String>al=new ArrayList<String>();
17         al.add("abcd");
18         al.add("abc");
19         al.add("bc");
20         al.add("aabadsf");
21         al.add("b");
22         al.add("cbae");
23         al.add("bade");
24         System.out.println("排序前："+al);
25         Collections.sort(al,new ComparatorByLength());
26         System.out.println("排序后："+al);
27     }
28     /*
29      * Demo1：该方法使用的是不带比较器的Collections.sort方法。
30      */
31     private static void Demo1() {
32         ArrayList<String>al=new ArrayList<String>();
33         al.add("abc");
34         al.add("abc");
35         al.add("bca");
36         al.add("aab");
37         al.add("bac");
38         al.add("cba");
39         System.out.println("排序前："+al);
40         Collections.sort(al);
41         System.out.println("排序后："+al);
42     }
43
44 }
45 class ComparatorByLength implements Comparator<String>
46 {
47
48     @Override
49     public int compare(String o1, String o2) {
50         int temp=o1.length()-o2.length();
51         return temp==0?o1.compareTo(o2):temp;
52     }
53
54 }

两个重载方法使用起来非常方便，但是其实现原理是什么也需要了解。

（2）模拟不使用比较器的sort方法。

  1 package p01.ColletionsDemo.p02.SortDemo;
  2
  3 import java.util.ArrayList;
  4 import java.util.List;
  5
  6 class Person implements Comparable<Person>
  7 {
  8
  9     private String name;
 10     private int age;
 11     @Override
 12     public String toString() {
 13         return "Person [name=" + name + ", age=" + age + "]\n";
 14     }
 15     public String getName() {
 16         return name;
 17     }
 18     public void setName(String name) {
 19         this.name = name;
 20     }
 21     public int getAge() {
 22         return age;
 23     }
 24     public void setAge(int age) {
 25         this.age = age;
 26     }
 27     public Person(String name, int age) {
 28         super();
 29         this.name = name;
 30         this.age = age;
 31     }
 32     public Person() {
 33         super();
 34     }
 35     @Override
 36     public int compareTo(Person o) {
 37         int temp=this.age-o.getAge();
 38         return temp==0?this.name.compareTo(o.getName()):temp;
 39     }
 40 }
 41 class Student extends Person
 42 {
 43
 44     public Student() {
 45         super();
 46     }
 47
 48     public Student(String name, int age) {
 49         super(name, age);
 50     }
 51
 52 }
 53 class Worker extends Person
 54 {
 55
 56     public Worker() {
 57         super();
 58     }
 59
 60     public Worker(String name, int age) {
 61         super(name, age);
 62     }
 63
 64 }
 65
 66 public class SortDemo {
 67     /**
 68      * 该类模拟带不带比较器的Collections.sort方法。
 69      * @param args
 70      */
 71     public static void main(String[] args) {
 72
 73         Demo1();
 74     }
 75
 76     private static void Demo1() {
 77         ArrayList<Person>al=new ArrayList<Person>();
 78         al.add(new Person("lisi",24));
 79         al.add(new Person("wangwu",25));
 80         al.add(new Person("zhangsan",23));
 81         al.add(new Person("chenqi",27));
 82         al.add(new Person("zhaoliu",26));
 83
 84         System.out.println("排序前："+al);
 85         MyCollections.sort(al);
 86         System.out.println("排序后："+al);
 87     }
 88
 89 }
 90 /*
 91  * 使用自定义Collections类
 92  */
 93 class  MyCollections
 94 {
 95     public static <T extends Comparable<? super T>> void  sort(List <T>list)
 96     {
 97         for(int i=0;i<=list.size()-2;i++)
 98         {
 99             for(int j=i+1;j<=list.size()-1;j++)
100             {
101                 if( list.get(i).compareTo(list.get(j))>0)
102                 {
103                     T t=list.get(i);
104                     list.set(i, list.get(j));
105                     list.set(j, t);
106                 }
107             }
108         }
109     }
110 }

改程序的核心就是MyColletions类了：

 1 class  MyCollections
 2 {
 3     public static <T extends Comparable<? super T>> void  sort(List <T>list)
 4     {
 5         for(int i=0;i<=list.size()-2;i++)
 6         {
 7             for(int j=i+1;j<=list.size()-1;j++)
 8             {
 9                 if( list.get(i).compareTo(list.get(j))>0)
10                 {
11                     T t=list.get(i);
12                     list.set(i, list.get(j));
13                     list.set(j, t);
14                 }
15             }
16         }
17     }
18 }