Collection集合

第一节集合框架及迭代器 1401-03

 1 /*collection包括list与set，list包括arraylist linkedlist vector ，set包括hashset treeSet
 2 为什么会出现这么多的容器呢？
 3 因为每一个容器对数据的存储方式都有不同，这个存储方式称之为数据结构
 4 引用变量存在于栈内存 new person（）存在于堆内存*/
 5 /*
 6 Collection定义了集合框架的共性功能。
 7 1，添加add(e);addAll(collection);
 8 2，删除remove(e);removeAll(collection);clear();
 9 3，判断。contains(e);isEmpty();
10 4，获取iterator();size();
11 5，获取交集。retainAll();
12 6，集合变数组。toArray();
13 1，add方法的参数类型是Object。以便于接收任意类型对象。
14 2，集合中存储的都是对象的引用(地址)
15 什么是迭代器呢？
16 其实就是集合的取出元素的方式。
17 就是把取出方式定义在集合的内部，这样的取出方式就可以
18 直接访问集合内容的元素那么取出方式就被定义成了内部类
19 内部类可以访问容器中的成员方法 不用定义对象
20 而每一个容器的数据结构不同，所以取出的细节不同，但是有
21 共性内容判断和取出。那么可以将写共性内容抽取
22 那么这些内部类都符合一个规则，这个规则就是iterator
23 如何获取集合的取出对象呢？通过一个对外提供的方法
24 iterator（）；如同抓娃娃游戏机中的夹子。
25 迭代器是取出方式，会直接访问集合中的元素。
26 所以将迭代器通过内部类的形式来进行描述。
27 通过容器的iterator()方法获取该内部类的对象。*/
28 
29 package uestc;
30 
31 import java.util.ArrayList;
32 import java.util.Iterator;
33 
34 public class CollectionDemo {
35 
36     public static void main(String[] args) {
37         method_2();
38     }
39     public static void method_get() {
40         ArrayList<String> arrayList=new ArrayList<String>();
41         arrayList.add("java01");
42         arrayList.add("java02");
43         arrayList.add("java03");
44         arrayList.add("java04");
45         arrayList.add("java05");
46         arrayList.add("java06");
47         Iterator<String> iterator=arrayList.iterator();
48         while(iterator.hasNext())
49         {
50             System.out.println(iterator.next());
51         }
52     }
53     public static void method_2() 
54     {
55         ArrayList<String> arrayList=new ArrayList<>();
56         arrayList.add("java01");
57         arrayList.add("java02");
58         arrayList.add("java03");
59         arrayList.add("java04");
60         arrayList.add("java05");
61         arrayList.add("java06");
62         ArrayList<String> arraylist2=new ArrayList<String>();
63         arraylist2.add("java01");
64         arraylist2.add("java02");
65         arraylist2.add("java03");
66         arrayList.retainAll(arraylist2);//取交集
67         //System.out.println(arrayList.removeAll(arraylist2));
68         System.out.println(arrayList);
69     }
70  
71 }

第二节 listDemo 04-06

 1 /*Collection
 2     |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
 3         |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。50%延长数组
 4         |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
 5         |--Vector:底层是数组数据结构。线程同步。查询、增删都慢 被ArrayList替代了。因为效率低。
 6     |--Set：元素是无序，元素不可以重复。因为集合体系没有索引
 7 List：
 8     特有方法。凡是可以操作角标的方法都是该体系特有的方法。
 9 增add(index,element);addAll(index,Collection);
10 删remove(index);改set(index,element);
11 查get(index):subList(from,to);listIterator();
12 int indexOf(obj):获取指定元素的位置。ListIterator listIterator();
13 List集合特有的迭代器。ListIterator是Iterator的子接口（继承了Iterator）。
14 在迭代时，不可以通过集合对象的方法操作集合中的元素见①处。
15 因为会发生ConcurrentModificationException异常。
16 所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，
17 只能对元素进行判断，取出，删除的操作，
18 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
19 该接口只能通过List集合的listIterator方法获取。*/
20 package uestc;
21 import java.util.ArrayList;
22 import java.util.Collection;
23 import java.util.Iterator;
24 import java.util.ListIterator;
25 
26 import com.sun.xml.internal.bind.v2.schemagen.xmlschema.List;
27 public class CollectionDemo {
28     public static void method() {
29         ArrayList<String> arrayList=new ArrayList<String>();
30         arrayList.add("java01");
31         arrayList.add("java02");
32         arrayList.add("java03");
33         System.out.println(arrayList);
34         arrayList.add(1, "java09");
35         System.out.println(arrayList);
36         arrayList.remove(2);
37         System.out.println(arrayList);
38         arrayList.set(2, "java007");
39         System.out.println(arrayList);
40         for (int i = 0; i < arrayList.size(); i++) {
41             System.out.println("arraylist("+i+")="+arrayList.get(i));
42         }
43         Iterator<String> iterator=arrayList.iterator();
44         while (iterator.hasNext()) {
45             System.out.println(iterator.next());
46         }
47         System.out.println("index="+arrayList.indexOf("java09"));
48         Collection<String> subList= arrayList.subList(1, 2);
49         System.out.println("sub="+subList);
50     }
51     public static void main(String[] args) {
52         ArrayList<String> arrayList=new ArrayList<String>();
53         arrayList.add("java01");
54         arrayList.add("java02");
55         arrayList.add("java03");
56         System.out.println(arrayList);
57         ListIterator<String> listIterator=arrayList.listIterator();
58         System.out.println("hasPrevious:"+listIterator.hasPrevious());
59         System.out.println("hasNext:"+listIterator.hasNext());
60         while (listIterator.hasNext()) {
61             Object object=listIterator.next();
62             if (object.equals("java02")) {
63                 //listIterator.add("java001");
64                 listIterator.set("java001");
65             }
66             
67         }
68         System.out.println(arrayList);
69         System.out.println("hasPrevious:"+listIterator.hasPrevious());
70         while (listIterator.hasPrevious()) {
71             System.out.println(listIterator.previous());//逆向遍历 反向打印 03 001 01
72         }
73         System.out.println("hasPrevious:"+listIterator.hasPrevious());
74         System.out.println("hasNext:"+listIterator.hasNext());
75         Iterator<String> iterator=arrayList.iterator();
76         while (iterator.hasNext()) {
77             Object object=iterator.next();
78             if (object.equals("java001")) {
79                 //arrayList.add("java002");①用集合的方法与用迭代器并发执行对元素的操作会发生异常 只能用一种
80                 iterator.remove();//用迭代器的方法将java001的引用从集合中移除了
81                 }
82                 System.out.println("object="+object);//能够打印java02元素的引用移除之后故不在集合中但是还在内存中故还是被obj引用打印
83             }
84         System.out.println(arrayList);
85         
86     }
87  }

主函数运行结果如下：

 1 [java01, java02, java03]
 2 hasPrevious:false
 3 hasNext:true
 4 [java01, java001, java03]
 5 hasPrevious:true
 6 java03
 7 java001
 8 java01
 9 hasPrevious:false
10 hasNext:true
11 object=java01
12 object=java001
13 object=java03
14 [java01, java03]

第三节枚举07

 1 /*枚举就是Vector特有的取去方式。vector去除方式有for get方法 iterator和枚举*/
 2 package uestc;
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Enumeration;
 6 import java.util.Iterator;
 7 import java.util.ListIterator;
 8 import java.util.Vector;
 9 public class CollectionDemo {
10     
11     public static void main(String[] args) {
12     Vector<String> vector=new Vector<String>();
13     vector.add("java01");
14     vector.add("java02");
15     vector.add("java03");
16     vector.add("java04");
17     Enumeration<String> enumeration=vector.elements();
18     while (enumeration.hasMoreElements()) {
19         System.out.println(enumeration.nextElement());
20         }
21     }
22     
23  
24 }

第四节 LInklistDemo 14-08

 1 /*linkedlist的特有方法
 2  * offerfirst（）：offerlast（）；
 3  * //增加元素
 4  * peekfirst（）；peeklast（）；
 5  * 获取元素但不删除元素 如果集合中没有元素则返回null
 6  * pollfirst（）；polllast（）；
 7  * 获取元素但是元素被删除，如果集合中没有元素则返回null*/
 8 package uestc;
 9 import java.util.LinkedList;
10 public class CollectionDemo {
11     
12     public static void main(String[] args) {
13         LinkedList<String> linkedList=new LinkedList<>();
14         linkedList.addLast("java01");
15         linkedList.addLast("java02");
16         linkedList.addLast("java03");
17         linkedList.addLast("java04");
18         linkedList.addLast("java05");
19         System.out.println(linkedList);
20         System.out.println(linkedList.getFirst());
21         System.out.println(linkedList.getFirst());
22         System.out.println(linkedList.removeFirst());//打印将java01并删掉
23         System.out.println("size="+linkedList.size());
24         while (!linkedList.isEmpty()) {
25             System.out.println(linkedList.removeLast());
26             }
27     }
28   }

第五节模拟堆栈 14-09

 1 /*使用linkedlist模拟一个堆栈或者数据结构
 2  * 堆栈：先进后出，如同一个杯子
 3  * 队列：先进先出，如同一个水管*/
 4 package uestc;
 5 import java.util.ArrayList;
 6 import java.util.Collection;
 7 import java.util.Enumeration;
 8 import java.util.Iterator;
 9 import java.util.LinkedList;
10 import java.util.List;
11 import java.util.ListIterator;
12 import java.util.Vector;
13 
14 import jdk.nashorn.internal.ir.WhileNode;
15 class DuiLie
16 {
17     private LinkedList linkedList;
18     public DuiLie() {
19         linkedList=new LinkedList<>();
20     }
21     public void myAdd(Object object) {
22          linkedList.add(object);
23     }
24     public Object MyGet() {
25         return linkedList.removeFirst();//实现队列 若想实现堆栈 则改为removelist（）即可
26     }
27     public boolean isNull()
28     {
29         return linkedList.isEmpty();
30     }
31 }
32 public class CollectionDemo {
33     
34     public static void main(String[] args) {
35         DuiLie duiLie=new DuiLie();
36         duiLie.myAdd("java01");
37         duiLie.myAdd("java02");
38         duiLie.myAdd("java03");
39         duiLie.myAdd("java04");
40     
41         while(!duiLie.isNull())
42         {
43             System.out.println(duiLie.MyGet());
44         }
45     }
46 }

第六节去除Arraylsit中重复的元素 14-10

 1 /*去除arraylsit中的重复元素*/
 2 package uestc;
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Enumeration;
 6 import java.util.Iterator;
 7 import java.util.LinkedList;
 8 import java.util.List;
 9 import java.util.ListIterator;
10 import java.util.Vector;
11 public class CollectionDemo {
12     
13     public static void main(String[] args) {
14     ArrayList<String> arrayList=new ArrayList<String>();
15     arrayList.add("java01");
16     arrayList.add("java02");
17     arrayList.add("java03");
18     arrayList.add("java04");
19     arrayList.add("java05");
20     arrayList.add("java04");
21     
22     
23 //    Iterator<String> iterator=arrayList.iterator();
24 //    while (iterator.hasNext()) {
25 //        System.out.println(iterator.next()+"..."+iterator.next());
26 //        //在迭代时循环中next调用一次就要hasnext（）判断一次it里面含有偶数个元素可以 奇数个元素就报错
27 //    }
28     System.out.println(arrayList);
29     arrayList=singleElement(arrayList);
30     System.out.println(arrayList);
31     }
32     public static ArrayList<String> singleElement (ArrayList<String> arrayList) {
33         //定义一个临时容器
34         ArrayList aList=new ArrayList<String>();
35         Iterator it=arrayList.iterator();
36         while (it.hasNext()) {
37             Object object=it.next();
38             if (!aList.contains(object)) {
39                 aList.add(object);
40             }
41         }
42         return aList;
43     }
44 }

打印结果：

1 [java01, java02, java03, java04, java05, java04]
2 [java01, java02, java03, java04, java05]

第七节练习14-11

 1 /*将自定义的对象作为元素存到Arraylist集合中去，并删除重复元素
 2  * 比如：存入人对象。同姓名同年龄的人视为同一个人，为重复元素
 3  * 思路：1.对人描述将数据封装进人的对象
 4  * 2.定义容器，将人存入
 5  * 3.取出
 6  * list集合判断元素是否相同，依据是元素的equals方法*/
 7 package uestc;
 8 import java.util.ArrayList;
 9 import java.util.Collection;
10 import java.util.Enumeration;
11 import java.util.Iterator;
12 import java.util.LinkedList;
13 import java.util.List;
14 import java.util.ListIterator;
15 import java.util.Vector;
16 
17 import com.sun.org.apache.bcel.internal.generic.NEW;
18 class person
19 {
20     private String name;
21     private int age;
22     public person(String name,int age) {
23     this.name=name;
24     this.age=age;
25     }
26     public boolean equals(Object object) {//移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true
27         if (!(object instanceof person)) 
28             return false;
29         person p=(person)object;
30         System.out.println(this.name+"::"+p.name);
31         return this.name.equals(p.name)&&this.age==p.age;
32     }
33     public String getName() {
34         return name;
35     }
36     public int getAge() {
37         return age;
38     }
39     
40 }
41 class Demo
42 {}
43 public class CollectionDemo {
44     
45     public static void main(String[] args) {
46     ArrayList arrayList=new ArrayList();
47     //arrayList.add(new Demo());
48     arrayList.add(new person("zhangsan",1));//arraylsit.add(object obj);object obj=new perso ("zhangsan",1)
49     arrayList.add(new person("zhangsan",2));
50     arrayList.add(new person("zhangsan",2));
51     arrayList.add(new person("lisi",2));
52     arrayList.add(new person("lisi",10));
53     arrayList=singleElement(arrayList);
54     System.out.println("remove 03:"+arrayList.remove(new person("lisi", 10)));
55     //remove方法底层也是依赖元素的equals方法
56     Iterator iterator=arrayList.iterator();
57     while (iterator.hasNext()) {
58         person person = (person) iterator.next();//是object obj=it.next() person p=(person)obj;的简写
59         System.out.println(person.getName()+"::"+person.getAge());
60         
61     }
62     }
63     public static ArrayList singleElement (ArrayList arrayList) {
64                  //定义一个临时容器
65           ArrayList aList=new ArrayList();
66           Iterator it=arrayList.iterator();
67            while (it.hasNext()) {
68               Object object=it.next();
69               if (!aList.contains(object)) {//contains调用的是equals进行对象的比较如果不重写equals则比较的是newperson的地址值而
70                                            //我们要比较的是对象的name及年龄故应该重写equals方法进行name与年龄的比较
71                  aList.add(object);
72               }
73            }
74             return aList;
75    }
76 }

输出结果：

1 lisi::zhangsan
2 lisi::wangwu
3 lisi::lisi
4 remove 03:true
5 zhangsan::1
6 wangwu::2

第八节 14-12 SET集合

set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复

　　HashSet：底层数据结构是哈希表，是线程不安全的。不同步

　　TreeSet：

Set集合功能室和Collection是一致的。

哈希表是按照哈希表值存在的当哈希值不同时对象存的哈希值不同位置当哈希值相同时再比较对象的内容是否相同对象不相同则在相同的地址下顺延

第九节 14 13-14 HashSet

hashset如何保证元素的唯一性呢？是通过元素的两个方法，hashCode和equals在、来完成，如果元素的HashCode值相同，才会判断equals是否为true，如果元素的hashcode值不同。不会调用equals 注意对于判断元素是否存在add（）以及删除remove（）操作依然依赖的方法是根据hashcode和后再根据equals方法而arraylist只是依赖equals方法。

 1 /*往hash色图集合中存入自定对象
 2  * 姓名和年龄相同视为同一个人，重复元素*/
 3 package uestc;
 4 import java.util.HashSet;
 5 import java.util.Iterator;
 6 class Person
 7 {
 8     private String name;
 9     private int age;
10     Person(String name,int age)
11     {
12         this.name=name;
13         this.age=age;
14     }
15     public int hashCode()
16     {
17         System.out.println(this.name+"...hashCode");
18         return name.hashCode()+age*37;//按照题目中个的条件进行设置哈希值age*37根据哈希值与年龄判断是否存在该对象 故定义返回的新哈希值为哈希值与年龄的组合而*37保证哈希值的唯一性
19     }
20     public boolean equals(Object object)//必须为object否则不是复写
21     {
22         if (!(object instanceof Person)) {
23             return false;
24         } 
25         Person p=(Person)object;
26         System.out.println(this.name+"...equals..."+p.name);
27         return this.name.equals(p.name)&& this.age==p.age;
28     }
29     public String getName()
30     {
31         return name;
32     }
33     public int getAge() {
34          return age;
35     }
36 }
37 
38 public class CollectionDemo {
39     
40     public static void main(String[] args) {
41         HashSet<Person> hashSet=new HashSet<>();
42         hashSet.add(new Person("a1", 11));
43         hashSet.add(new Person("a2", 12));//增加的时候去判断哈希值与对象大风内容
44         hashSet.add(new Person("a2", 12));
45         hashSet.add(new Person("a3", 14));
46         Iterator<Person> iterator=hashSet.iterator();
47         while (iterator.hasNext()) {
48         Person person=iterator.next();
49         System.out.println(person.getName()+"::"+person.getAge());
50             
51         }
52     
53    }
54 }

第十节 treeset 存储自定义对象

 1 /*set:无序，不可以重复元素
 2  *     hashset：数据结构是哈希表，线程是非同步的
 3  *  保证元素唯一性的原理：判断元素的hashcode值是否相同 如果相同 还会继续判断元素的equals方法 是否为true
 4  *  treeset：可以对set集合中的元素进行排序 放到treeset里面的对象要具有比较性 底层数据结构是二叉树 保证元素的唯一性的依据：
 5  *  compareTo方法：return 0则代表存入的数据相同只能存入第一个对象
 6  *  treeset排序的第一种的方式：让元素自身具有比较性
 7  *  元素需要实现comparable接口，覆盖compareTo方法 这种方式也叫做元素的自然排序
 8  *  第二种方式：当元素不具备比较性时 或者具备的比较性不是所需要的 这是就需要让集合自身具备比较性 在集合初始化的时候就有了比较方式
 9  *  需求：往treeset集合中存储自定对象学生
10  *  想按照学生得年龄进行排序
11  *  记住：排序时当主要条件相同时一定判断一下次要条件。字典顺序为自然顺序。
12  *  classcastexception类型转换异常*/
13 package uestc;
14 import java.util.ArrayList;
15 import java.util.HashSet;
16 import java.util.Iterator;
17 import java.util.List;
18 import java.util.TreeSet;
19 class Student implements Comparable<Object>
20 {
21     private String name;
22     private int age;
23     public Student(String name,int age)
24     {
25         this.name=name;
26         this.age=age;
27     }
28     public int compareTo(Object object) {
29         //return 1;则是进来的数据总是原来的数据大 数据一致往二叉树的右侧延伸 而treeset由小到大 取数故能按照原来存的顺序取出数据
30         if (!(object instanceof Student)) {
31             throw new RuntimeException("不是学生对象");
32         }
33         Student student=(Student)object;
34         System.out.println(this.name+"...compareto..."+student.name);
35         if (this.age>student.age) {
36             return 1;
37         }
38         if (this.age==student.age) {
39             return this.name.compareTo(student.name);
40         }
41         return -1;
42     }
43     public String getName()
44     {
45         return name;
46     }
47     public int getAge() {
48          return age;
49     }
50 }
51 
52 public class CollectionDemo {
53     
54     public static void main(String[] args) {
55         TreeSet<Student> students=new TreeSet<>();
56         students.add(new Student("lisi02", 22));
57         students.add(new Student("lisi007", 20));
58         students.add(new Student("lisi09", 19));
59         students.add(new Student("lisi08", 19));
60         Iterator<Student> iterator=students.iterator();
61         while (iterator.hasNext()) {
62             Student student=(Student)iterator.next();
63             System.out.println(student.getName()+"..."+student.getName());
64             
65         }
66         }
67 
68 }

第十一节 Compator实现对姓名的排序

 1 /*当元素自身不具备比较性或者比较性不是所需要的 这是让容器自身具备比较性 定义了比较器 将比较器对象作为参数传递给treeset集合的构造函数
 2  * 当两种排序都存在时与比较器为主 定义一个类实现comparable接口 覆盖compare方法 而comparable里面是comparable方法*/
 3 package uestc;
 4 import java.util.ArrayList;
 5 import java.util.Comparator;
 6 import java.util.HashSet;
 7 import java.util.Iterator;
 8 import java.util.List;
 9 import java.util.TreeSet;
10 class Student implements Comparable<Object>
11 {
12     private String name;
13     private int age;
14     public Student(String name,int age)
15     {
16         this.name=name;
17         this.age=age;
18     }
19     public int compareTo(Object object) {
20         //return 1;则是进来的数据总是原来的数据大 数据一致往二叉树的右侧延伸 而treeset由小到大 取数故能按照原来存的顺序取出数据
21         if (!(object instanceof Student)) {
22             throw new RuntimeException("不是学生对象");
23         }
24         Student student=(Student)object;
25 //        System.out.println(this.name+"...compareto..."+student.name);
26         if (this.age>student.age) {
27             return 1;
28         }
29         if (this.age==student.age) {
30             return this.name.compareTo(student.name);
31         }
32         return -1;
33     }
34     public String getName()
35     {
36         return name;
37     }
38     public int getAge() {
39          return age;
40     }
41 }
42 
43 public class CollectionDemo {
44     
45     public static void main(String[] args) {
46         TreeSet<Student> students=new TreeSet<>(new MyCompator());//传入一个新的对象比较器
47         students.add(new Student("lisi02", 22));
48         students.add(new Student("lisi007", 20));
49         students.add(new Student("lisi09", 19));
50         students.add(new Student("lisi08", 19));
51         students.add(new Student("lisi08", 18));
52         Iterator<Student> iterator=students.iterator();
53         while (iterator.hasNext()) {
54             Student student=(Student)iterator.next();
55             System.out.println(student.getName()+"..."+student.getAge());
56             
57         }
58     }
59 
60 }
61 class  MyCompator implements Comparator<Object>//comparator的子类
62 {
63     public int compare(Object object1,Object object2 ) {//不用覆盖equals方法 因为继承了object类
64         Student student1=(Student)object1;
65         Student student2=(Student)object2;
66         int num=student1.getName().compareTo(student2.getName());
67         if (num==0) {
68             return new Integer(student1.getAge()).compareTo(new Integer(student2.getAge()));
69             }
70         return num;
71     }
72 }

输出结果：

lisi007...20
lisi02...22
lisi08...18
lisi08...19
lisi09...19

第十二节字符串长度的比较

 1 /*练习：按照字符串长度排序
 2  * 使用比较器*/
 3 package uestc;
 4 import java.util.Comparator;
 5 import java.util.Iterator;
 6 import java.util.TreeSet;
 7 
 8 
 9 public class CollectionDemo {
10     
11     public static void main(String[] args) {
12         TreeSet<String> treeSet=new TreeSet<>(new  MyCompator());//传入一个新的对象比较器
13         treeSet.add("abcd");
14         treeSet.add("acd");
15         treeSet.add("add");
16         treeSet.add("acdqw");
17         treeSet.add("ac");
18         
19         Iterator<String> iterator=treeSet.iterator();
20         while (iterator.hasNext()) {
21             System.out.println(iterator.next());
22             
23         }
24     }
25 
26 }
27 class  MyCompator implements Comparator<Object>//comparator的子类
28 {   
29     public int compare(Object object1,Object object2) 
30     {
31         String string1=(String)object1;
32         String string2=(String)object2;
33 //        if (string1.length()>string2.length()) {
34 //            return 1;
35 //            }
36 //        if (string1.length()==string2.length()) {
37 //            return 0;//若有这一句 两个相同长度的字符串则被认为成同一对象 只能存入一个
38 //           }
39         int num=new Integer(string1.length()).compareTo(string2.length());
40         if (num==0) {
41             return string1.compareTo(string2);//对相同长度的字符串 进行逐个比较
42         }
43         return num;
44     
45     }
46     
47 }

第十三节 15 06-07 泛型的使用

 1 /*泛型：jdk1.5版本以后出现的新特性 用于解决安全问题 是一个类型安全机制 
 2  * 好处：1将运行时期出现的classcastexception转移到了编译时期
 3  * 2避免了强转
 4  * 泛型格式通过<>来定义要操作的引用数据类型*/
 5 package uestc;
 6 
 7 import java.util.Comparator;
 8 import java.util.Iterator;
 9 import java.util.TreeSet;
10 
11 public class CollectionDemo {
12     
13     public static void main(String[] args) {
14     TreeSet<String> treeSet=new TreeSet<String>();
15     treeSet.add("abc");
16     treeSet.add("absc");
17     treeSet.add("abd");
18     treeSet.add("ab");
19     Iterator<String> iterator=treeSet.iterator();
20     while (iterator.hasNext()) {
21         String string=iterator.next();
22         System.out.println(string);
23         }
24     }
25     class lenComparator implements Comparator<String>
26     {
27         public int compare(String string1,String string2) {
28             int num=new Integer(string1.length()).compareTo(new Integer(string2.length()));
29             if (num==0) {
30                 return string1.compareTo(string2);
31             }
32             return num;
33         }
34     }
35     
36 
37 }

输出结果：

ab
abc
abd
absc

15-08 泛型的定义

什么时候定义泛型类？当类中要操作的数据类型不确定的时候

 1 /*什么时候定义泛型 当类中要操作的引用数据类型不确定的时候*/
 2 package uestc;
 3 public class CollectionDemo {
 4     
 5     public static void main(String[] args) {
 6     
 7     utils<work> work=new utils<work>();
 8     work.setObject(new student());
 9     work work2=work.getObject();
10 //    Tool tool=new Tool();
11 //    tool.setObject(new student());
12 //    work worker=(work)tool.getObject();
13     }
14     
15 
16 }
17 //class Tool
18 //{
19 //    private work worker;
20 //    public void setObject(work worker) {
21 //        this.worker=worker;
22 //    }
23 //    public work getWork() {
24 //        return worker;
25 //    }
26 //}
27 class Tool
28 {
29     private Object object ;
30     public void setObject(Object object) {
31         this.object=object;
32     }
33     public Object getObject() {
34         return object;
35     }
36 }
37 class work {}
38 class student extends work{}
39 class utils<QQ>
40 {
41     private QQ q;
42     public void setObject(QQ q) {
43         this.q=q;
44         }
45     public QQ getObject() {
46         return q;
47     }
48 }

Collection集合

第一节集合框架及迭代器 1401-03

第二节 listDemo 04-06

第三节 枚举07

第四节 LInklistDemo 14-08

第五节 模拟堆栈 14-09

第六节 去除Arraylsit中重复的元素 14-10

第七节 练习14-11

第八节 14-12 SET集合

第九节 14 13-14 HashSet

第十节 treeset 存储自定义对象

第十一节 Compator实现对姓名的排序

第十二节 字符串长度的比较

第十三节 15 06-07 泛型的使用

15-08 泛型的定义

第三节枚举07

第五节模拟堆栈 14-09

第六节去除Arraylsit中重复的元素 14-10

第七节练习14-11

第十二节字符串长度的比较