1 //java基础视频教程第14天-01-集合框架（体系概述）
2 /*
3 集合用于存对象的
4
5 数组时固定长度的，而集合是可变长度的
6
7 数组只能存指定同一种数据类型，而集合可以存各种类型的对象
8
9 对于要了解一个框架体系：参阅顶层，创建底层，
10 顶层定义所有子类的共性功能，而为什么创建底层呢？1.顶层的类有些是抽象类不能new对象，2.底层的类功能方法更多.
11
12
13 Collection有很多子接口，其中就有List和Set，而List有ArrayList和LinkedList以及Vector，而Set中有Haseset和Treeset
14 集合框架为什么有如此多的容器，因为它们的存储方式不相同，这个存储方式称之为：数据结构
15 */
16 class
17 {
18 public static void main(String[] args)
19 {
20 System.out.println("Hello World!");
21 }
22 }
1 //java基础视频教程第14天-02-集合框架（共性方法）
2 /*
3 注意：
4 Person p = new Person();
5 ArrayList al = new ArrayList();
6 al.add(p);
7 作为集合，就有增删改查功能，
8 这里集合添加的对象，其实添加的是对象的引用或则是对象的地址值，所以记住了，在堆内存中，集合对象和其它对象是分开的，集合对象装的只是其它对象的对象引用或者地址值
9 */
10 import java.util.*; //导入java.util包
11 class CollectionDemo
12 {
13 public static void main(String[] args)
14 {
15
16 //method1();
17 method2();
18
19 }
20 public static void method1()
21 {
22 ArrayList al = new ArrayList(); //用Collection接口的子类ArrayList创建集合
23 //增
24 al.add("java1");
25 al.add("java2");
26 al.add("java3");
27 al.add("java4");
28 sop(al.size()); //对于JDK1.5以后泛型的出现导致了安全隐患的产生，这里编译时会出现注意事项，希望你能修正 //返回数字
29 sop(al); //打印出这个集合对象，不会打印出哈希值的
30 //删
31 sop(al.remove("java2")); //移除其中一个元素，返回boolean
32 sop(al);
33 //al.clear(); //清空所有数据，无返回值
34 sop(al);
35 //判
36 sop(al.contains("java4")); //判断是否包含java4这个元素
37 sop(al.isEmpty()); //判断集合是否为空
38
39 }
40 public static void method2()
41 {
42 ArrayList al1 = new ArrayList();
43 al1.add("java1");
44 al1.add("java2");
45 al1.add("java3");
46 al1.add("java4");
47 ArrayList al2 = new ArrayList();
48 al2.add("java3");
49 al2.add("java4");
50 //al2.add("java5");
51 //al2.add("java6");
52 //交集
53
54 //sop(al1.retainAll(al2)); //将al1和al2中相同的元素赋给al1，
55 //sop(al1); //结果：java3,java4
56
57 //sop(al1.removeAll(al2)); //会将al1中与al2中非相同的元素保留，相同的去除
58 sop(al1); //结果：java1，java2
59
60 sop(al1.containsAll(al2)); //判断al1中是否包含al2 ，不包含
61 }
62 public static void sop(Object obj)
63 {
64 System.out.println(obj);
65 }
66 }
1 //java基础视频教程第14天-03-集合框架（迭代器）
2 /*
3 迭代器：
4 迭代器就是电玩城的夹子（比喻）
5 其实迭代器就是取集合中元素的方法，对于集合中不同集合都有不同的数据结构，要想获取这些集合中这些容器的元素，显然一种获取方法不能解决，
6 于是在每个集合容器中定义一个获取元素的内部类，并抽出它们的共性(在取元素时 ，判断元素存在与否，取出元素)构成了Iterator抽象方法，并对外提供访问方法iterator
7 Iterator是迭代器接口，接口中定义了三个方法hasNext，next，remove
8 */
9 import java.util.*;
10 class ArrayListAdd
11 {
12 public static void main(String[] args)
13 {
14 ArrayList al = new ArrayList();
15 al.add("java1");
16 al.add("java2");
17 al.add("java3");
18 al.add("java4");
19
20 //查
21 /*
22 Iterator it = al.iterator(); //集合al调用迭代器方法iterator返回的是一个Iterator接口的子类对象，这个对象实现了Iterator，它就有hasNext，next，remove方法
23 sop(it.next()); //返回迭代的下一个元素
24 while(it.hasNext()) //返回true表示还有可以迭代的元素，false表示没有元素可以迭代了
25 {
26 sop(it.next());
27 }
28 */
29 //老外的写法：更加注重于内存的管理
30 for (Iterator it = al.iterator();it.hasNext() ; ) //这样写了，当程序执行完毕之后，it就会在内存中消失，而上面用while执行完毕之后it还会在内存中存在
31 {
32 sop(it.next());
33 }
34 }
35 public static void sop(Object obj)
36 {
37 System.out.println(obj);
38 }
39 }
1 //java基础视频教程第14天-04-集合框架（List集合共性方法）
2 /*
3 List和Set的区别，List中的元素可以重复，因为List中的元素有下角标，是有序的，而Set中的元素是无序的，不能有重复的元素
4 List中特有的方法：凡是操作下角标index都是它的特有方法
5 //增加
6 add(Object element)，在类表尾部添加元素
7 add(int index,Object element)，在指定位置上插入元素
8 addAll(Collection c)
9 addAll(int index, Collection c)，在指定位置插入列表Collection中的所有元素
10 //删除
11 remove(int index);
12 remove(Object o)
13 //改
14 set(int index,Object element);
15 //查
16 get(int index)，获取指定位置的元素，indexOf(Object o),返回指定元素的位置，lastIndexOf(Object o)，反向索引
17 subList(int start,int end) //包含头不包含尾，set(int index,E element)//List特有方法，改变集合中的每个元素
18 listIterator(); //List特有迭代器，remove(Object o),按照对象移除，remove(int index)，按照角标移除，size()，返回元素的个数
19
20 */
21 import java.util.*;
22 class ListDemo
23 {
24 public static void main(String[] args)
25 {
26 ArrayList al = new ArrayList();
27 al.add("java1");
28 al.add("java2");
29 al.add("java3");
30 //增
31 al.add(1,"java007");
32 sop(al);
33 //删
34 al.remove(3);
35 sop(al);
36 //改
37 al.set(2,"java0");
38 sop(al);
39 //查
40 sop(al.get(2)); //可以循环打印出
41 sop(al.subList(1,2)); //取头取不到尾，返回类型是List类型
42 sop(al.indexOf("java1"));
43 Iterator it = al.iterator(); //用的父类Collection的iterator方法
44 while(it.hasNext())
45 {
46 sop(it.next());
47 }
48 }
49 public static void sop(Object obj)
50 {
51 System.out.println(obj);
52 }
53 }
1 //java基础视频教程第14天-05-集合框架（ListIterator）
2 /*
3 在迭代方法中不能用集合中的方法操作数据，不然会出现并行更改异常，这是一个runtime异常，需要手动更改
4 然而在Iterator中只有hasNext(),next(),remove()方法，没有添加设置等操作方法，这时就用到它的子类ListIterator接口
5 它当中既有父类飞方法，也有，add，set，hasPrevious,previous等方法
6 */
7 import java.util.*; //学习这章时，不要忘记导入包
8 class ListIteratorDemo
9 {
10 public static void main(String[] args)
11 {
12 ArrayList al = new ArrayList();
13 al.add("java1");
14 al.add("java2");
15 al.add("java3");
16 sop(al);
17
18 //Iterator迭代接口
19 /*
20 Iterator it = al.iterator();
21 while(it.hasNext())
22 {
23 Object obj = it.next();
24 if(obj.equals("java2"))
25 it.remove("java1"); //移除没有出问题，移除是迭代器自有的方法
26 al.add("java4"); //经过测试在迭代操作中用集合添加方法add会导致并行更改异常ConcurrentModificationException，是一个runtimeException()
27 sop("obj="+obj);
28 }
29 sop(al);
30 */
31 //Iterator迭代接口子类ListIterator
32 ListIterator li =al.listIterator();
33 while(li.hasNext())
34 {
35
36 if(li.next()=="java2")
37 li.add("java4"); //子类迭代器有添加删除，修改的功能
38
39 }
40 while(li.hasPrevious()) //反序查询
41 {
42 sop(li.previous());
43
44 }
45 }
46 public static void sop(Object obj)
47 {
48 System.out.println(obj);
49 }
50 }
1 //java基础视频教程第14天-06-集合框架（List集合具体对象的特点）
2 /*
3 Collection:
4 |--List:元素是有序的，元素可以重复，因为每个元素都有对应的索引
5 |--ArrayList:它的数据结构是数组结构，并且数组长度默认为10，当装满之后还要添加则以50%长度延长，每个元素都有下标，所以查询和更改很快速，但是删除和添加时，下标都会随着改变，所以删除和添加就会很慢
6 |--LinkList:它的底层数据结构为链表结构，链表结构的特点就是没有下标，通过前一元素联系后一元素，所以当删除和添加一个元素时就很快捷，只要把前后元素联系断开或链接就可以，但是查询和修改就会很低效，因为查询时是从第一元素开始查询直到要访问的元素。
7 |--Vector:它的底层数据结构也是数组结构，JDK1.2之后ArrayList替代了它，它的数组长度也是10，会以100%长度延长，并且它是同步的，而ArrayList不是同步的，所以ArrayList效率会高些，对于同步安全性问题，可以自己加锁防止
8 |--Set:元素是无序的，元素不可以重复
9 */
1 //java基础视频教程第14天-07-集合框架（Vector中的枚举）
2 /*
3 凡是带有Element的方法都是vector的特有方法
4 vector中有一个特有的方法枚举elements(),返回类型为枚举类型Enumeration
5 其实elements的方法和iterator迭代器的方法差不多，其实iterator替代了它，而且迭代器iterator中还比它多一个remove方法
6 如果vector中没有这个枚举的方法也许就会被淘汰了，在I/O中有个对象用到枚举的，它们都是JDK1.0版本以前的老前辈
7 */
8 import java.util.*;
9 class vectorDemo
10 {
11 public static void main(String[] args)
12 {
13 Vector v = new Vector();
14 v.add("java1");
15 v.add("java2");
16 v.add("java3");
17 v.add("java4");
18
19 Enumeration en = v.elements(); //注意elements()是vector的方法，返回值是枚举Enumeration类型
20 while(en.hasMoreElements())
21 {
22 sop(en.nextElement());
23 }
24 }
25 public static void sop(Object obj)
26 {
27 System.out.println(obj);
28 }
29 }
1 //java基础视频教程第14天-08-集合框架(LinkedList)
2 /*
3 凡是看见First，Last都是LinkedList里的特有方法
4 这些方法是从JDK1.2开始的
5 addFirst
6 addLast
7
8 getFirst
9 getLast
10
11 removeFirst
12 removeLast
13 替代：从JDK1.6开始
14 offerFirst();添加
15 offerLast();
16
17 peekFirst();打印 //获取元素，但不删除元素
18 peekLast(); //当集合中没有元素时不会出异常，只会返回null
19
20 pollFirst();删除并打印 //获取元素，但删除元素
21 pollLast(); //当集合中没有元素时不会出异常，只会返回null
22
23 */
24 import java.util.*;
25 class LinkedListDemo
26 {
27 public static void main(String[] args)
28 {
29 LinkedList li = new LinkedList();
30 li.addFirst("java1");
31 li.addFirst("java2");
32 li.addFirst("java3");
33 li.addFirst("java4"); //说明一下，addFirst()是在第一个位置上添加元素，所以，java4是最后一个添加进来的，所以是第一个元素
34
35 sop(li.size());
36 //sop(li);
37 sop(li.getFirst()); //获取第一个元素，不会改变元素个数，当集合中没有元素会出现异常NoSuchElementException
38 sop(li.getLast()); //获取最后一个元素，不会改变元素个数，当集合中没有元素会出现异常NoSuchElementException
39 sop(li.removeFirst()); //移除第一个元素，同时可以打印出这个值，会改变元素个数,当集合中没有元素会出现异常NoSuchElementException
40 sop(li.removeLast()); //移除最后一个元素，同时获取这个元素，会改变元素个数，当集合中没有元素会出现异常NoSuchElementException
41 while(!li.isEmpty())
42 {
43 sop(li.removeFirst());
44 }
45
46 LinkedList li1 = new LinkedList();
47 li1.offerFirst("java5");
48 li1.offerFirst("java6");
49 li1.offerFirst("java7");
50 li1.offerFirst("java8");
51 sop(li1.peekFirst()); //当集合中没有元素时不会出异常，只会返回null
52 sop(li1.pollFirst()); //当集合中没有元素时不会出异常，只会返回null
53 while(!li1.isEmpty())
54 {
55 sop(li1.pollFirst());
56 }
57
58 }
59 public static void sop(Object obj)
60 {
61 System.out.println(obj);
62 }
63 }
1 //java基础视频教程第14天-09-集合框架（LinkedList练习）
2 /*
3 用LinkedList模拟堆栈或者队列数据结构
4
5 堆栈数据结构是先进后出 FILO
6 队列数据结构是先进先出 First in First out FIFO
7
8 为什么要模拟呢？因为在以后的开发当中，都会基于某个集合定义自己的集合，以便于复用
9 如何模拟，其实就是把原有的某个集合封装并私有化，通过对外方法提供访问接口，这样可以提高复用性，并且可以方便我们开发， 说白了就是基于原来的集合
10 */
11 import java.util.*;
12 class LinkedListTest
13 {
14 public static void main(String[] args)
15 {
16 DuiLie d= new DuiLie();
17 d.myAdd("java1");
18 d.myAdd("java2");
19 d.myAdd("java3");
20 d.myAdd("java4");
21
22 while(!d.isNull())
23 {
24 System.out.println(d.myGet());
25 }
26 }
27 }
28 class DuiLie
29 {
30 private LinkedList li;
31 DuiLie()
32 {
33 li = new LinkedList();
34 }
35 public void myAdd(Object obj) //对外方法
36 {
37 li.addFirst(obj);
38 }
39 public Object myGet() //对外方法
40 {
41 return li.removeFirst(); //如果改成removeLast()就是先进先出了（队列数据结构）
42 }
43 public Boolean isNull() //对外方法
44 {
45 return li.isEmpty();
46 }
47
48
49 }
1 //java基础视频教程第14天-10-集合框架（ArrayList练习）
2 /*
3 去除ArrayList集合中重复的元素。
4 思路：
5 通过建立一个空集合，然后把ArrayList集合中元素与新集合中的元素做比较，新集合中没有这个元素就把这个元素添加到新集合中去，
6 有这个元素就添加，最后返回新的集合，其中的元素就是ArrayList集合中非重复的元素。
7 */
8 import java.util.*;
9 class ArrayListTest1
10 {
11 public static void main(String[] args)
12 {
13 ArrayList al = new ArrayList();
14 al.(add("java1"));
15 al.(add("java2"));
16 al.(add("java1"));
17 al.(add("java2"));
18 al.(add("java3"));
19
20 ArrayList newAl = new ArrayList();
21 Iterator i = al.iterator();
22 while(i.hasNext())
23 {
24 if(!newAl.contains(i.next()))
25 {
26 newAl.add(i.next());
27 }
28 }
29 sop(newAl);
30 }
31 public static void sop(Object obj)
32 {
33 System.out.println(obj);
34 }
35 }
1 //java基础视频教程第14天-10-集合框架（ArrayList练习）
2 /*
3 去除ArrayList集合中重复的元素。
4 思路：
5 通过建立一个空集合，然后把ArrayList集合中元素与新集合中的元素做比较，新集合中没有这个元素就把这个元素添加到新集合中去，
6 有这个元素就添加，最后返回新的集合，其中的元素就是ArrayList集合中非重复的元素。
7 */
8 import java.util.*;
9 class ArrayListTest
10 {
11 public static void main(String[] args)
12 {
13 ArrayList al = new ArrayList();
14 al.add("java1");
15 al.add("java2");
16 al.add("java1");
17 al.add("java2");
18 al.add("java3");
19 //al.add("java4");
20
21 sop(al);
22 al = singleElements(al);
23 sop(al);
24
25 }
26
27 public static ArrayList singleElements(ArrayList al)
28 {
29 ArrayList newAl = new ArrayList();
30 Iterator i = al.iterator();
31 while(i.hasNext())
32 {
33 Object obj = i.next(); //注意：在这个循环中不能出现多次i.next(),因为出现一次指针就会下移一次，如果元素是偶数还好说，是奇数的话就会出现NoSuchElemensException,所以这里用obj代替
34 if(!newAl.contains(obj))
35 newAl.add(obj);
36 /*
37 if(!newAl.contains(i.next()))
38 newAl.add(i.next()); //while里面不能出现两次i.next(),出现一次指针就会下移一次，这样得到的结果就不是取不同的元素了，而且如果元素个数为奇数时就会出现NoSuchElemensException异常
39 */
40 }
41 return newAl;
42 }
43
44 public static void sop(Object obj)
45 {
46 System.out.println(obj);
47 }
48 }
1 //java基础视频教程第14天-11-集合框架(ArrayList练习2)
2 /*
3 需求：将自定义对象作为元素传入ArrayList，并去除相同的元素
4 思路：
5 1.建立对象类，这里方便一个类可以建立多个不同对象，在一开始就在构造函数中传入值，
6 2.向集合ArrayList添加对象
7 3.去除相同的元素
8
9 List集合判断元素是否相同，依据是元素的equals方法，元素是对象，就要重写equals方法，元素是字符串，就不用重写
10 List集合判断元素是否相同，依据的是元素的equals方法
11 */
12 import java.util.*;
13 class Person
14 {
15 private String name;
16 private int age;
17 Person(String name,int age)
18 {
19 this.name = name;
20 this.age = age;
21 }
22 public boolean equals(Object obj)
23 {
24 /*
25 !newAl.contains(obj)第一次newAl里面没有值，不能做比较，所以就把new Person("毕向东1"，1)加到newAl集合中去，然后第二次 newAl中有
26 元素new Person("毕向东1",1),就会new Person("毕向东1"，1).contains(new Person("毕向东2"，2))；其实底层结构是这个样的：（new Person("毕向东2"，2)==null？new Person("毕向东1"，1)==null:new Person("毕向东2"，2).equals(new Person("毕向东1"，1)))
27 最重要new Person("毕向东2"，2).equals(new Person("毕向东1"，1))，这里是是两个对象在比较，自然用的都是对象的equals在比较，所以这里要重写Person对象的equals
28
29 如何重写equals，这里要求person对象调用equals方法，比较的是对象中name和age,
30
31 newAl.contains(new person("毕向东2"，2))，contains(Object o)，(o==null ? e==null : o.equals(e))，此处就是毕向东2在调用equals()方法，所以这里开始的this代替的就是毕向东2，e就是传进来的毕向东1
32 */
33 if(!(obj instanceof Person)) //做一下判断，不要不是Person对象也传进来，
34 return false;
35 Person p = (Person)obj;
36 System.out.println((this.name+"---"+p.name+"---"+this.age+"---"+p.age)); //通过这个可以查看比较顺序
37 return((this.name).equals(p.name)&&(this.age==p.age));
38
39
40 }
41 public String getName()
42 {
43 return name;
44 }
45 public int getAge()
46 {
47 return age;
48 }
49 }
50 class ArrayListTest1
51 {
52 public static void main(String[] args)
53 {
54 ArrayList al = new ArrayList();
55 al.add(new Person("毕向东1",1));
56 al.add(new Person("毕向东2",2));
57 al.add(new Person("毕向东3",3));
58 al.add(new Person("毕向东2",2));
59 al.add(new Person("毕向东4",4));
60 al.add(new Person("毕向东3",3));
61
62 sop(al); //从这里可以看出集合里面存的是对象地址，而非对象
63 sop(al.remove(new Person("毕向东4",4))); //注意。同样remove方法也是调用的底层equals方法，通过比较找到相同的然后再删除，底层结构是这样的(o==null ? get(i)==null : o.equals(get(i)))
64 al = newArrayList(al);
65 Iterator i = al.iterator();
66 while(i.hasNext())
67 {
68 Object obj =i.next(); //这里是多态,i.next()返回的是E（Object）类型
69 Person p = (Person)obj; //要想使用对象中的成员就必须向下转型，注意哈
70 sop(p.getName()+"---"+p.getAge());
71 }
72
73
74
75 }
76 public static void sop(Object obj)
77 {
78 System.out.println(obj);
79 }
80
81 public static ArrayList newArrayList(ArrayList al)
82 {
83 ArrayList newAl = new ArrayList();
84 Iterator i = al.iterator();
85 while(i.hasNext())
86 {
87 Object obj = i.next();
88 if(!newAl.contains(obj)) //这里的contains(Object o)其实底层调用的是(o==null？e==null:o.equals(e)),而此处传的是对象，对象有自己的equals方法，，这里的e为什么？？？？？？？？？？？？？？？
89 { //比较的是内存地址值，所以此处如果你不重写Peron的equals方法，即使你传的对象名字和年龄相同也会因为地址值不同认为是不用的元素
90 newAl.add(obj); //但是这里的contains是如何底层自动调用equals方法的呢？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
91 }
92 }
93 return newAl;
94 }
95 }
1 //java基础视频教程第14天-12-集合框架（HashSet）
2 /*
3 对于开发时用ArrayList还是LinkList，都是根据实际情况而定的，当涉及到频繁的删除和增加就用LinkedList,当频繁涉及到修改和查询就用ArrayList
4
5 Set：里面存的元素是无序的，为什么会无序，因为存的元素都是存的哈希值，哈希值是计算机底层自己运算的，哈希值有自己的排列方式
6 |--HashSet：哈希表结构
7 |--TreeSet
8 */
9 import java.util.*;
10 class Demo
11 {
12 public int hashCode()
13 {
14 return 60;
15 }
16 }
17 class HashSetDemo
18 {
19 public static void main(String[] args)
20 {
21 /*
22 Demo d1 = new Demo();
23 Demo d2 = new Demo();
24 sop(d1); //当我把Demo对象的hashCode方法复写了之后，导致它们的hash值相同了，这是就会再比较是不是同一个对象，比较是不是同一对象用equals方法，如果不是同一对象就会在原来的位置上顺延一个值，这时这个位置上就有两个值
25 sop(d2); //打印对象其实调用的是toString方法，toString方法返回String，底层调用方法是 getClass().getName() + '@' + Integer.toHexString(hashCode())
26 */
27 HashSet hs = new HashSet();
28
29 sop(hs.add("java1"));
30 sop(hs.add(null)); //public boolean add(E e)//(e==null ? e2==null : e.equals(e2)).
31 sop(hs.add("java1")); //public boolean add(E e)//(e==null ? e2==null : e.equals(e2)).
32 hs.add("java2");
33 hs.add("java3");
34 hs.add("java4");
35
36 Iterator it = hs.iterator();
37 while(it.hasNext())
38 {
39 sop(it.next()); //打印是无序的
40 }
41
42 }
43 public static void sop(Object o)
44 {
45 System.out.println(o);
46 }
47 }
1 //java基础视频教程第14天-13-集合框架（HashSet存储自定义对象）
2 /*
3 首先你的明白HashSet是哈希表结构，哈希表结构的特点是存放元素是无序的，所以存放元素不能够重复，当你要添加一个元素的时候，
4 它首先会去判断这个元素的hash值，然后然后与HashSet集合中的元素的哈希值作比较，不同就存放进来一个位置上，如果哈希值相同，则就比较这两个对象的内部是否相同
5 所谓内部就是比较对象中成员的是否相同（用equals），如果对象内容不同，则会在相同位置上顺延一个位置存放这个值，如果对象内容相同则不会存这个元素
6
7 |--Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
8 |--HashSet：底层数据结构是哈希表
9 HashSet是如何保证元素的唯一性的呢？
10 通过元素的两个方法，hashCode和equals来完成的
11 如果元素的HashCode值相同，才会判断equals是否为true
12 如果元素的hashcode值不同，不会调用equals
13
14 注意：对于判断元素的是否存在，以及删除等操作，依赖的方法是元素的hashcode和equal是方法
15
16 |--TreeSet：
17 Set集合的功能和Collection是一致的。
18
19
20 */
21 import java.util.*;
22 class Person
23 {
24 private String name;
25 private int age;
26 Person(String name,int age)
27 {
28 this.name = name;
29 this.age = age;
30 }
31 public int hashCode()
32 {
33 System.out.println(this.name+"---"+"HashCode"); //可以查看每一个元素都去调用了hashCode方法
34 return this.name.hashCode()+age*39; //加上age是为了防止，名字相同年龄不同的情况，*39是防止当哈希值加上age相等，确保返回值的唯一性
35
36 }
37 public boolean equals(Object o)
38 {
39 if(!(o instanceof Person))
40 return false;
41 Person p = (Person)o;
42 System.out.println(this.name+"---"+p.name+"---"+this.age+"---"+p.age); //可以看见当hash值相同时，再次比较对象中的内容
43 return(p.name.equals(this.name)&& p.age==this.age);
44
45 }
46 public String getName()
47 {
48 return name;
49 }
50 public int getAge()
51 {
52 return age;
53 }
54 }
55 class HashSetDemo1
56 {
57 public static void main(String[] args)
58 {
59 HashSet hs = new HashSet();
60 hs.add(new Person("毕向东1",1));
61 hs.add(new Person("毕向东2",2)); //添加元素时，首先会判断判断这个元素的Hash值是否与集合中已有的元素Hash值相同，如果相同还会判断它们对象的内容是否相同
62 hs.add(new Person("毕向东3",3)); //public boolean add(E e)底层为(e==null? e2==null: e.equals(e2))
63 hs.add(new Person("毕向东4",5));
64 hs.add(new Person("毕向东2",2));
65
66 Iterator i = hs.iterator();
67 while(i.hasNext())
68 {
69 Object o =i.next();
70 Person p =(Person)o;
71 sop(p.getName()+"---"+p.getAge()); //用迭代器的方式输出HashSet集合中的值
72 }
73 }
74 public static void sop(Object o)
75 {
76 System.out.println(o);
77 }
78 }
79
1 //java基础视频教程第14天-14-集合框架（HashSet判断和删除的依据）
2 /*
3 首先你的明白HashSet是哈希表结构，哈希表结构的特点是存放元素是无序的，所以存放元素不能够重复，当你要添加一个元素的时候，
4 它首先会去判断这个元素的hash值，然后然后与HashSet集合中的元素的哈希值作比较，不同就存放进来一个位置上，如果哈希值相同，则就比较这两个对象的内部是否相同
5 所谓内部就是比较对象中成员的是否相同（用equals），如果对象内容不同，则会在相同位置上顺延一个位置存放这个值，如果对象内容相同则不会存这个元素
6
7 |--Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
8 |--HashSet：底层数据结构是哈希表
9 HashSet是如何保证元素的唯一性的呢？
10 通过元素的两个方法，hashCode和equals来完成的
11 如果元素的HashCode值相同，才会判断equals是否为true
12 如果元素的hashcode值不同，不会调用equals
13
14 注意：对于判断元素的是否存在，以及删除等操作，依赖的方法是元素的hashcode和equal是方法
15
16 |--TreeSet：
17 Set集合的功能和Collection是一致的。
18
19
20 */
21 import java.util.*;
22 class Person
23 {
24 private String name;
25 private int age;
26 Person(String name,int age)
27 {
28 this.name = name;
29 this.age = age;
30 }
31 public int hashCode()
32 {
33 System.out.println(this.name+"---"+"HashCode"); //可以查看每一个元素都去调用了hashCode方法
34 return this.name.hashCode()+age*39; //加上age是为了防止，名字相同年龄不同的情况，*39是防止当哈希值加上age相等，确保返回值的唯一性
35
36 }
37 public boolean equals(Object o)
38 {
39 if(!(o instanceof Person))
40 return false;
41 Person p = (Person)o;
42 System.out.println(this.name+"---"+p.name+"---"+this.age+"---"+p.age); //可以看见当hash值相同时，再次比较对象中的内容
43 return(p.name.equals(this.name)&& p.age==this.age);
44
45 }
46 public String getName()
47 {
48 return name;
49 }
50 public int getAge()
51 {
52 return age;
53 }
54 }
55 class HashSetDemo2
56 {
57 public static void main(String[] args)
58 {
59 HashSet hs = new HashSet();
60 hs.add(new Person("毕向东1",1));
61 hs.add(new Person("毕向东2",2)); //添加元素时，首先会判断判断这个元素的Hash值是否与集合中已有的元素Hash值相同，如果相同还会判断它们对象的内容是否相同
62 hs.add(new Person("毕向东3",3)); //public boolean add(E e)底层为(e==null? e2==null: e.equals(e2))
63 hs.add(new Person("毕向东4",5));
64
65 sop(hs.contains(new Person("毕向东1",1)));
66 sop(hs.remove(new Person("毕向东4",5))); //删除和包含其实是先查哈希值，然后查对象，发现哈希值相同就会去查对象中的内容
67 Iterator i = hs.iterator();
68
69 while(i.hasNext())
70 {
71 Object o =i.next();
72 Person p =(Person)o;
73 sop(p.getName()+"---"+p.getAge()); //用迭代器的方式输出HashSet集合中的值
74 }
75 }
76 public static void sop(Object o)
77 {
78 System.out.println(o);
79 }
80 }
81
1 //java基础视频教程第15天-01-集合框架（TreeSet）
2 /*
3 |--Set:元素排列无序，不能有重复元素
4 |--HashSet：哈希表结构，打印出的排列无序，添加值需要先判断hashCode，如果哈希值相同，在通过equals方法比较对象是否相同
5 |--TreeSte：打印出的排列是按照自然顺序排列的
6 */
7 import java.util.*;
8 class treeSetDemo
9 {
10 public static void main(String[] args)
11 {
12 TreeSet ts = new TreeSet();
13 ts.add("cde");
14 ts.add("abc");
15 ts.add("def");
16 ts.add("bcd");
17 Iterator i = ts.iterator();
18 while(i.hasNext())
19 {
20 sop(i.next()); //发现打印出来的元素是按照自然顺序排列的
21 }
22
23 }
24 public static void sop(Object o)
25 {
26 System.out.println(o);
27 }
28 }
1 //java基础视屏教程第15天-02-集合框架(TreeSet存储自定义对象)
2 /*
3 由于TreeSet的排序是可以将元素按照自然排序排列打印，但是对于添加的对象元素来说，判断对象的自然顺序就需要实现Comparable，让对象具有可比性
4
5 需求：
6 往TreeSet集合中存储自定义对象学生
7 想按照学生的年龄进行排序
8
9 记住：排序时，当主要条件相同时，一定判断一下次要条件
10 */
11 import java.util.*;
12 class Student implements Comparable //实现这个接口，可以强制对实现它的对象做自然排序，其实就是一个方法conpareTo（Comparable是java.lang包中的一个接口，谁实现它，它就对谁进行自然排序）
13 {
14 private String name;
15 private int age;
16 Student(String name,int age)
17 {
18 this.name = name;
19 this.age = age;
20 }
21 public int compareTo(Object o)
22 {
23 if(!(o instanceof Student))
24 throw new RuntimeException("不是学生对象"); //抛异常但是没有处理??????????????????????
25 Student s = (Student)o;
26 System.out.println(this.name+"--conpare--"+s.name);
27 if(this.age>s.age)
28 return 1; //此处想取反，就把数字都改成反的
29 else if(this.age==s.age) //排序时，当主要条件相同时，一定要判断一下次要条件
30 return ((this.name).compareTo(s.name)); //Sring也实现了Comparable的方法，比较的是字符串的Asicc码大小 //此处想取反，就把返回值都改成反的
31 else
32 {
33 return -1; //此处想取反，就把数字都改成反的
34 }
35
36 }
37 public String getName()
38 {
39 return name;
40 }
41 public int getAge()
42 {
43 return age;
44 }
45 }
46 class TreeSetDemo3
47 {
48 public static void main(String[] args)
49 {
50 TreeSet ts = new TreeSet();
51 ts.add(new Student("毕向东1",1));
52 ts.add(new Student("毕向东2",2));
53 ts.add(new Student("毕向东1",2));
54
55 Iterator i = ts.iterator();
56 while(i.hasNext())
57 {
58 Object o = i.next();
59 Student s = (Student)o;
60 sop(s.getName()+"----"+s.getAge());
61 }
62 }
63 public static void sop(Object o)
64 {
65 System.out.println(o);
66 }
67 }
1 //java基础视屏教程第15天-03-集合框架(二叉树)
2 /*
3 TreeSet数据结构是二叉树，这是保证元素唯一性的依据（compareTo方法返回 0）二叉树的特点是以第一个数为根，然后比他小的放左边，比他大的放右边，然后再根据此基础结构延续，最终看上去就像一棵树不断二分树枝一样
4 取值的特点是从左下小的取，但当一个数右上和右下都有比他大的数时，先去右下的值
5
6 TreeSet的元素对象必须实现Comparable接口，这样这些对象才有比较性，才能存入TreeSet集合中，当返回为1时，表示调用者对象元素大于比较者对象元素，比较的是自然顺序，当返回为-1时，表示调用者对象小于比较者对象元素，当返回为0时，如果还有次要条件就再次比较；
7
8 当重写了compareTo方法：
9 //当返回1时怎么存的就怎么取，返回-1时，怎么存的就怎么倒着取，返回0时，就表示元素相同，则会返回唯一的那个元素
10 */
11 import java.util.*;
12 class Student implements Comparable //实现这个接口，可以强制对实现它的对象做自然排序，其实就是一个方法conpareTo（Comparable是java.lang包中的一个接口，谁实现它，它就对谁进行自然排序）
13 {
14 private String name;
15 private int age;
16 Student(String name,int age)
17 {
18 this.name = name;
19 this.age = age;
20 }
21 public int compareTo(Object o)
22 {
23 return 1; //当返回1时怎么存的就怎么取，返回-1时，怎么存的就怎么倒着取，返回0时，就表示元素相同，则会返回唯一的那个元素
24 /*
25 if(!(o instanceof Student))
26 throw new RuntimeException("不是学生对象"); //抛异常但是没有处理??????????????????????
27 Student s = (Student)o;
28 System.out.println(this.name+"--conpare--"+s.name);
29 if(this.age>s.age)
30 return 1; //此处想取反，就把数字都改成反的
31 else if(this.age==s.age) //排序时，当主要条件相同时，一定要判断一下次要条件
32 return ((this.name).compareTo(s.name)); //Sring也实现了Comparable的方法，比较的是字符串的Asicc码大小 //此处想取反，就把返回值都改成反的
33 else
34 {
35 return -1; //此处想取反，就把数字都改成反的
36 }
37 */
38 }
39 public String getName()
40 {
41 return name;
42 }
43 public int getAge()
44 {
45 return age;
46 }
47 }
48 class TreeSetDemo2
49 {
50 public static void main(String[] args)
51 {
52 TreeSet ts = new TreeSet();
53 ts.add(new Student("毕向东1",1));
54 ts.add(new Student("毕向东2",2));
55 ts.add(new Student("毕向东1",2));
56
57 Iterator i = ts.iterator();
58 while(i.hasNext())
59 {
60 Object o = i.next();
61 Student s = (Student)o;
62 sop(s.getName()+"----"+s.getAge());
63 }
64 }
65 public static void sop(Object o)
66 {
67 System.out.println(o);
68 }
69 }
1 //java基础视频教程第15天-04-集合框架(实现Comparator方法排序)
2 /*
3 Set:无序，不可重复元素
4 |--HashSet:数据结构是哈希表，线程是非同步的
5 保证元素唯一性的原理：判断元素的hashCode值是否相同
6 如果相同，还会继续判断元素的equals方法是否为true
7
8 |--TreeSet:可以对Set集合中的元素进行排序
9 底层数据结构为二叉树
10 保证元素唯一性的依据
11 conpareTo方法return 0
12
13
14 当TreeSet中的元素无法比较时，或者元素比较不是我们想要的，而且不能改动代码，这是我们可以将TreeSet容器变成一个比较器，这就需要自定义一个实现Comparator接口的类，并实现它的方法compare,然后将对象以参数的形式传递给TreeSet
15
16 注意一点Comparable里面的方法是compareTo方法，Comparator里面是compare方法
17 */
18 import java.util.*;
19 class Student implements Comparable
20 {
21 private String name;
22 private int age;
23 Student(String name,int age)
24 {
25 this.name = name;
26 this.age = age;
27 }
28 public int compareTo(Object o) //按年龄比较
29 {
30 if(!(o instanceof Student))
31 throw new RuntimeException("不是同Student对象");
32 Student s = (Student)o;
33 if(this.age>s.age)
34 {
35 return 1;
36 }else if(this.age<s.age)
37 {
38 return -1;
39 }
40 else
41 {
42 return((this.name).compareTo(s.name));
43 }
44 }
45 public String getName()
46 {
47 return name;
48 }
49 public int getAge()
50 {
51 return age;
52 }
53 }
54 class TreeSetDemo4
55 {
56 public static void main(String[] args)
57 {
58 TreeSet ts = new TreeSet(new myComparator()); //以构造函数的形式传一个比较器
59 ts.add(new Student("毕向东9",91));
60 ts.add(new Student("毕向东3",12));
61 ts.add(new Student("毕向东4",63));
62 ts.add(new Student("毕向东6",14));
63 ts.add(new Student("毕向东6",15));
64
65 Iterator i = ts.iterator();
66 while(i.hasNext())
67 {
68 Object o = i.next();
69 Student s = (Student)o;
70 sop(s.getName()+"---"+s.getAge());
71 }
72 }
73 public static void sop(Object o)
74 {
75 System.out.println(o);
76 }
77 }
78 class myComparator implements Comparator //Comparator是一个接口，共有两个方法要实现，一个是int compare(Object o1,Object o2),一个是equals，equals不用复写了，因为这个类已经继承了Object的equals方法
79 {
80
81 public int compare(Object o1,Object o2) //通过比较姓名，对姓名进行排序
82 {
83
84 Student s1 = (Student)o1;
85 Student s2 = (Student)o2;
86 int num = (s1.getName()).compareTo(s2.getName()); //比较字符串，返回的已经是1，0,-1
87 if(num==0) //注意是==而非=
88 {
89 //return s1.getAge()-s2.getAge(); //最便宜的方法方法4
90
91 /*
92 方法2
93 //这又是一种麻烦方法
94 if(s1.getAge()>s2.getAge())
95 return 1;
96 if(s1.getAge()<s2.getAge())
97 return -1;
98 return 0;
99 */
100 //方法3
101 return (new Integer(s1.getAge()).compareTo(s2.getAge())); //对象的年龄是一个整数，整数对象包装类Iterator也实现了Comparable接口,所以也有compareTo方法
102 }
103 return num;
104 /*
105 方法1
106 if(num>0)
107 {
108 return 1;
109 }
110 else if (num<0)
111 {
112 return -1;
113 }else
114 {
115 if(s1.getAge()>s2.getAge())
116 {
117 return 1;
118 }else if(s1.getAge()<s2.getAge())
119 {
120 return -1;
121 }
122 else
123 {
124 return 0;
125 }
126 }
127 */
128 }
129 }
1 //java基础视频教程第15天-05-集合框架(TreeSet练习)
2 /*按照字符串的长度排序*/
3 import java.util.*;
4 class TreeSetTest
5 {
6 public static void main(String[] args)
7 {
8 TreeSet ts = new TreeSet(new myCompare());
9 ts.add("ajdk");
10 ts.add("dkkgl");
11 ts.add("eiitee");
12 ts.add("dd");
13 ts.add("aa");
14 ts.add(";b;b");
15 Iterator i = ts.iterator();
16 while(i.hasNext())
17 {
18 sop(i.next());
19 }
20
21 }
22 public static void sop(Object o)
23 {
24 System.out.println(o);
25 }
26 }
27 class myCompare implements Comparator
28 {
29 public int compare(Object o1,Object o2)
30 {
31 String s1 = (String)o1;
32 String s2 = (String)o2;
33 int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
34 if(num ==0) //经常搞错
35 {
36 return (s1).compareTo(s2); //字符串也有compareTo方法，
37 }
38 return num;
39 }
40 }
1 //java基础视频教程第15天-06-集合框架（泛型概述）
2 /*
3 泛型：JDK1.5版本之后出现的新特性。用于解决安全问题，是一个安全机制
4
5 泛型出现的好处：
6 1.将运行时期出现的问题classCastException，转移到编译时期
7 方便与程序员解决问题，让运行事情问题减少，安全
8 2.避免的强制转换的麻烦
9 */
10 import java.util.*;
11 class GenericDemo
12 {
13 public static void main(String[] args)
14 {
15 TreeSet<Integer> ts = new TreeSet<Integer>(); //泛型，这就是泛型，JDK1.5之后出现的一个安全机制，这样是为了规定这个集合中只能存什么数据类型的对象，不能存基本数据，解决了安全问题
16 ts.add(111);
17 ts.add(222);
18 ts.add(333);
19 ts.add(3333);
20 Iterator<Integer> i = ts.iterator(); //这里也用了泛型，是因为迭代器引入的数据也必须是这种数据类型,加了泛型之后就不用强制转型了
21 while(i.hasNext())
22 {
23
24 sop(i.next());
25
26 }
27 }
28 public static void sop(Object o)
29 {
30 System.out.println(o);
31 }
32 }
1 //java基础视频教程第15天-07-集合框架（泛型使用）
2 /*
3 凡是带<>的都要加泛型，E代表元素T代表type类型
4 <>是用来接收引用数据类型的
5
6 //HashSet的equals(Object o)必须要写转型，因为它是复写的Object，Object没有泛型
7 */
8 import java.util.*;
9 class GenericDemo1
10 {
11 public static void main(String[] args)
12 {
13 TreeSet<String> ts = new TreeSet<String>(new myCompare());
14 ts.add("fadf");
15 ts.add("fjf");
16 ts.add("cg");
17 ts.add("l");
18 Iterator<String> i = ts.iterator(); //用到了泛型
19 while(i.hasNext())
20 {
21 String s = i.next();
22 sop(s);
23 }
24 }
25 public static void sop(Object o)
26 {
27 System.out.println(o);
28 }
29 }
30 class myCompare implements Comparator<String> //用到了泛型
31 {
32 public int compare(String o1,String o2)
33 {
34 int num =new Integer(o2.length()).compareTo(new Integer(o1.length())); //如果要反向打印，不必改变num的正负，直接交换o1和o2的位置即可
35 if(num==0)
36 return o2.compareTo(o1); //如果要反向打印，不必改变num的正负，直接交换o1和o2的位置即可
37 return num;
38 }
39 }
1 //java基础教程第15天-08-集合框架(泛型类)
2 /*
3 什么时候定义泛型类？
4 当类中要操作的引用数据类型不确定的时候
5 早期定义Object来完成扩展
6 现在定义泛型来完成扩展
7 */
8 class Student
9 {
10 }
11 class Worker
12 {
13 }
14 /*
15 class Tool
16 {
17 private Worker w;
18 public void setWorker(Worker w)
19 {
20 this.w =w;
21 }
22 public Worker getWorker()
23 {
24 return w;
25 }
26 }
27 */
28 /*
29 class Tool //早期的做法是用Object接收不明确的引用数据类型，得到的也是Object类，需要转型
30 {
31 private Object obj;
32 public void setObject(Object obj)
33 {
34 this.obj = obj;
35 }
36 public Object getObject()
37 {
38 return obj;
39 }
40 }
41 */
42 class Utils<QQ> //当调用者的引用数据类型不明确时用泛型 //泛型定义在类上
43 {
44 private QQ q;
45 public void setObject(QQ q)
46 {
47 this.q = q;
48 }
49 public QQ getObject()
50 {
51 return q;
52 }
53
54 }
55 class GenericDemo3
56 {
57 public static void main(String[] args)
58 {
59 /*
60 Tool t = new Tool();
61 t.setWorker(new Worker());
62 Worker w = (Worker)t.getWorker();
63 */
64 /*
65 Tool t = new Tool();
66 t.setObject(new Student());
67 Student s = (Student)t.getObject();
68 */
69 Utils<Student> u = new Utils<Student>();
70 u.setObject(new Student());
71 Student t = (Student)u.getObject();
72 }
73 }
1 //java基础视频教程15天-09-集合框架（泛型类）
2
3 /*class Demo<E> //泛型写在类上，一旦建立对象传递了具体的数据类型，这个类中的方法也就被限定了只能传递这种值了
4 {
5 public void show(E e)
6 {
7 System.out.println("show:"+e);
8 }
9 public void print(E e)
10 {
11 System.out.println("print:"+e);
12 }
13 }
14 */
15 class Demo
16 {
17 public <T> void show(T t) //将泛型定义在方法上，提高了对象中方法传递数据类型的灵活性,还要注意一点，泛型加在返回值的前面
18 {
19 System.out.println("show:"+t);
20 }
21 public <T> void print(T t) //此处的T与上面的T是没有什么关系，我这里这个T也可以写成D或者其它什么的
22 {
23 System.out.println("print:"+t);
24 }
25 }
26 class GenericDemo4
27 {
28 public static void main(String[] args)
29 {
30 /*
31 Demo<String> d = new Demo<String>();
32 d.show("jdjd");
33 d.print("daaad");
34 */
35 Demo d = new Demo();
36 d.show("fasf");
37 d.print(3); //自动装箱
38 }
39 }
1 //java基础视频教程第15天-10-集合框架（静态方法泛型）
2 class Demo<T>
3 {
4 public void show(T t) //在类上定义泛型，里面的方法传递的类型随着类相同
5 {
6 System.out.println("show:"+t);
7 }
8 public <Q> void print(Q q)
9 {
10 System.out.println("print:"+q);
11 }
12 /*public static void dayin(T t) //静态方法不能打印类上面定义的泛型，因为类上面定义的泛型只有new对象的时候才能传进来的，而静态方法又比对象先存在，所以，打印不了
13 {
14 System.out.println("dayin:"+t);
15 }
16 */
17 public static <Q> void dayin(Q q) //如果静态方法要使用泛型就定义在静态方法中，不要用类的泛型，在方法中定义泛型，泛型定义在修饰符的后面，返回值的前面
18 {
19 System.out.println("dayin:"+q);
20 }
21 }
22 class GenericDemo2
23 {
24 public static void main(String[] args)
25 {
26 Demo<String> d = new Demo<String>();
27 d.show("flfajl");
28 d.print(2);
29 d.dayin("dadd");
30 }
31 }
1 //java基础视频教程第15天-11-集合框架（泛型接口）
2 interface Inter<E>
3 {
4 void show(E e);
5 }
6 /*
7 class interImp implements Inter<String> //实行接口时指定要传入的数据类型
8 {
9 public void show(String e)
10 {
11 System.out.println("show:"+e);
12 }
13 }
14 */
15 class interImp<E> implements Inter<E> //由调用者来指定传入数据类型
16 {
17 public void show(E e)
18 {
19 System.out.println("show:"+e);
20 }
21 }
22 class interImpl
23 {
24 public static void main(String[] args)
25 {
26 /*
27 interImp i = new interImp(); //实现接口的时候就已经之指定了传入数据类型
28 i.show("ddd");
29 */
30 interImp<Integer> i = new interImp<Integer>(); //调用者
31 i.show(3);
32 }
33 }
1 //java基础视频教程第15天-12-集合框架（泛型限定）
2 /*
3 ? 通配符，也可以理解为占位符
4 泛型的限定：
5 ？extends E：可以接收E类型或者E的子类型，上限
6 ? super E: 可以接收E类型或者E的父类型，下限
7
8 问题：泛型限定有问题？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
9 */
10 import java.util.*;
11 class GenericDemo6
12 {
13 public static void main(String[] args)
14 {
15
16 ArrayList<String> al = new ArrayList<String>();
17 al.add("abc1");
18 al.add("abc2");
19 al.add("abc3");
20 printColl(al);
21
22 ArrayList<Integer> all = new ArrayList<Integer>();
23 all.add(123);
24 all.add(1234);
25 all.add(12344);
26 printColl(all);
27
28 ArrayList<Person> rt = new ArrayList<Person>();
29 rt.add(new Person("abc--1"));
30 rt.add(new Person("abc--2"));
31 rt.add(new Person("abc--3"));
32 printP(rt);
33
34 ArrayList<Student> ra = new ArrayList<Student>();
35 ra.add(new Student("ZHANGSHAN"));
36 ra.add(new Student("LISI"));
37 ra.add(new Student("WANGMAZI"));
38 printP(ra);
39 }
40
41 public static <T> void printColl(ArrayList<T/*?*/> e) //此处泛型既可以是不明确类型通配符？，也可以是T具体类型，不明确类型不能用明确类型的方法，比如length方法等
42 {
43
44 Iterator<T/*?*/> i = e.iterator();
45 while(i.hasNext())
46 {
47 sop(i.next());
48 }
49 }
50 public static void printP(ArrayList<? extends Person> e) //上行限定
51 {
52 Iterator<? extends Person> i = e.iterator();
53 while(i.hasNext())
54 {
55 sop((i.next()).getName()); //有特定方法时，不要用?
56 }
57 }
58
59 public static void sop(Object o)
60 {
61 System.out.println(o);
62 }
63 }
64 class Person
65 {
66 private String name;
67 Person(String name)
68 {
69 this.name = name;
70 }
71 public String getName()
72 {
73 return name;
74 }
75 }
76 class Student extends Person
77 {
78 Student(String name)
79 {
80 super(name);
81 }
82 }
1 //java基础视频教程第15天-13-集合框架（泛型限定2）
2 /*
3 Comparator(Comparator<? super E> comparator)，E是子类
4 */
5 import java.util.*;
6 class GenericDemo7
7 {
8 public static void main(String[] args)
9 {
10 TreeSet<Student> s = new TreeSet<Student>(/*new StudentComp()*/new Comp());
11 s.add(new Student("abc1"));
12 s.add(new Student("abc2"));
13 s.add(new Student("abc3"));
14 Iterator<Student> is = s.iterator();
15 while(is.hasNext())
16 {
17 System.out.println((is.next().getName()));
18 }
19
20 TreeSet<Worker> w = new TreeSet<Worker>(/*new WorkerComp()*/new Comp());
21 w.add(new Worker("wabc1"));
22 w.add(new Worker("wabc2"));
23 w.add(new Worker("wabc3"));
24 Iterator<Worker> iw = w.iterator();
25 while(iw.hasNext())
26 {
27 System.out.println((iw.next().getName()));
28 }
29 }
30
31
32 }
33 class Comp implements Comparator<Person>
34 {
35 public int compare(Person p1,Person p2) //Person p1 = new Student("abc1"),Person p2 = new Student("abc2");
36 {
37 return p1.getName().compareTo(p2.getName());
38 }
39 }
40 /*
41 class StudentComp implements Comparator<Student>
42 {
43 public int compare(Student p1,Student p2)
44 {
45 return p1.getName().compareTo(p2.getName());
46 }
47 }
48 class WorkerComp implements Comparator<Worker>
49 {
50 public int compare(Worker p1,Worker p2)
51 {
52 return p1.getName().compareTo(p2.getName());
53 }
54 }
55 */
56 class Person
57 {
58 private String name;
59 Person(String name)
60 {
61 this.name = name;
62 }
63 public String getName()
64 {
65 return name;
66 }
67 }
68 class Student extends Person
69 {
70 Student(String name)
71 {
72 super(name);
73 }
74 }
75 class Worker extends Person
76 {
77 Worker(String name)
78 {
79 super(name);
80 }
81 }
浙公网安备 33010602011771号