TreeSet

 1 package cn.hello;
 2 
 3 public class Student implements Comparable<Student>{
 4     public String name;
 5     int age;
 6     public String address;
 7     public Student(){
 8         
 9     }
10     public Student(String name,int age){
11         this.name=name;
12         this.age=age;
13     }
14     
15     public Student(String name,int age,String address){
16         this.name=name;
17         this.age=age;
18         this.address=address;
19     }
20     public void show(){
21         System.out.println("show");
22     }
23     
24     public void method(String s){
25         System.out.println("method"+s);
26     }
27     public String getString(String s,int i){
28         return s+"---"+i;
29     }
30     private void funciton(){
31         System.out.println("private function");
32     }
33     @Override
34     public String toString() {
35         return "Student [name=" + name + ", age=" + age + ", address="
36                 + address + "]";
37     }
38     @Override
39     public int hashCode() {
40         final int prime = 31;
41         int result = 1;
42         result = prime * result + ((address == null) ? 0 : address.hashCode());
43         result = prime * result + age;
44         result = prime * result + ((name == null) ? 0 : name.hashCode());
45         return result;
46     }
47     @Override
48     public boolean equals(Object obj) {
49         if (this == obj)
50             return true;
51         if (obj == null)
52             return false;
53         if (getClass() != obj.getClass())
54             return false;
55         Student other = (Student) obj;
56         if (address == null) {
57             if (other.address != null)
58                 return false;
59         } else if (!address.equals(other.address))
60             return false;
61         if (age != other.age)
62             return false;
63         if (name == null) {
64             if (other.name != null)
65                 return false;
66         } else if (!name.equals(other.name))
67             return false;
68         return true;
69     }
70     @Override
71     public int compareTo(Student s) {
72         // TODO Auto-generated method stub
73         int num=this.age-s.age;
74         int num2  =num==0    ?   this.name.compareTo(s.name)  :   num;
75         return num2;
76         
77     }
78     
79 }

 1 package cn.hello;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.Collection;
 6 import java.util.Enumeration;
 7 import java.util.HashSet;
 8 import java.util.Iterator;
 9 import java.util.LinkedHashSet;
10 import java.util.LinkedList;
11 import java.util.List;
12 import java.util.Random;
13 import java.util.Scanner;
14 import java.util.Set;
15 import java.util.TreeSet;
16 import java.util.Vector;
17 
18 
19 
20 /*
21  * 数组和集合的区别
22  * 1：长度区别
23  *             数组长度固定
24  *             集合长度可变
25  * 2内容不同
26  *             数组存储的是同一种类型的元素
27  *             集合可以存储不同类型的元素
28  *     3元素数据类型
29  *             数组可以存储基本数据类型，也可以存储引用数据类型
30  *          集合只能存储引用数据类型(对象）
31  * 
32  * Collection 
33  *                 List:   ArrayList  ,Vector,   LinkedList
34  *                Set :  HashSet    ,TreeSet
35  * 
36  * List:   有序的collection集合，元素有序，可重复。可根据索引访问元素
37  *             特有功能：void add(int index,Object element)
38  *                                 Object get(int index)
39  *                                 ListIterator listIterator():List集合特有的迭代器
40  *                                 Object remove(int index)
41  *                                 Object set(int index,Object element)
42  * 
43  * ArrayList:特点  底层数据结构是数组，查询快，增删慢  线程不安全，效率高
44  * Vector  :  数组，查询快，增删慢，效率低，线程安全
45  * LinkedList:链表，查询慢，增删快，不安全，效率高
46  * 
47  * 
48  * Vector特有功能：  public void addElement(Object obj)   
49  *                                     public Object elementAt(int index)
50  *                                     public Enumeration elements()
51  * 
52  * LinkedList的特有功能：addFirst  addLast    getFirst    getLast    removeFirst   removeLast  
53  * 
54  * 随机10个数，不可重复   ；   输入几个数，0结束，最大
55  * 
56  * Set:  不可重复，无序（存储顺序和取出顺序不一致）,集合有自己的输出序列。
57  * 
58  * HashSet  :在存储自定义对象的时候，要重写hashCode  和equals
59  * 
60  * LinkedHashSet:  唯一，有序
61  * 
62  * TreeSet:  自然顺序对元素进行排序,   唯一
63  *             排序有两种：自然排序，比较器排序
64  * 
65  *                 比较器排序：
66  *             一个类想要能够进行自然排序，必须实现自然排序接口
67  * 
68  *      步骤：
69  *          1  自定义对象继承Compareable
70  *          2  为保证唯一性  重写  HashCode equals
71  *          3   为了自然排序   重写CompareTo
72  * */
73 
74 public class Test01{
75     public static void main(String[] args) {
76         TreeSet<Student> ts=new TreeSet<Student>();
77         
78         Student s1=new Student("hello",22,"world");
79         Student s2=new Student("become",12,"better");
80         Student s3=new Student("go",44,"where");
81         Student s4=new Student("ca",44,"where");
82         
83         ts.add(s1);
84         ts.add(s2);
85         ts.add(s3);
86         ts.add(s4);
87         
88         for(Student s:ts){
89             System.out.println(s);
90         }
91         
92         
93     }
94 }