1 public class CollectionEach{
 2     public static void main(String[] args){
 3     Collection readBooks=new HashSet();
 4     readBooks.add("Java 多线程边编程的艺术");
 5     readBooks.add("Java编程思想");
 6     readBooks.add("简洁之道");
 7     readBooks.add("Effective Java");
 8     readBooks.add("程序员职业素养");
 9     readBooks.foreach(ele->System.out.println("迭代集合元素:"+ele));
10     }
11 }

import java.util.Collection;
import java.util.HashSet;

public class CollectionStream
{
    public static void main(String[] args)
    {
        Collection books = new HashSet();
        books.add("Java并发编程的艺术");
        books.add("Effective java 中文版");
        books.add("代码整洁之道");
        books.add("深度学习、优化与识别");
        books.add("代码整洁之道_程序员的职业素养");
        books.add("人际关系与沟通");
        books.add("TensorFlow实战");
        books.add("TensorFlow实战Google深度学习框架");
        books.add("明朝那些事");

        //统计书名包含"码"子串的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).contains("码")).count());
        //统计书名包含"java"子串的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).contains("Java")).count());
        //统计书名字符串长度大于10的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).length() > 10).count());
        //先调用Collection对象的stream()方法将集合转换为Stream
        //再调用Stream的mapToInt()方法获取原有的Stream对应的IntStream
        books.stream().mapToInt(ele -> ((String) ele).length()).forEach(System.out::println);
    }
}

 1 import java.util.HashSet;
 2 import java.util.Iterator;
 3 
 4 public class HashTest2
 5 {
 6     public static void main(String[] args)
 7     {
 8         HashSet hs = new HashSet();
 9         hs.add(new R(5));
10         hs.add(new R(-3));
11         hs.add(new R(-9));
12         hs.add(new R(15));
13         //打印HashSet集合,集合 元素没有重复
14         System.out.println(hs);
15         //取出第一个元素
16         Iterator it = hs.iterator();
17         R first = (R) it.next();
18         System.out.println(first.count);
19 //        为第一个元素的count实例变量赋值
20         first.count = -3;
21         System.out.println(hs);
22         //删除count为-3的R对象
23         hs.remove(new R(-3));
24         //可以看到被删除了一个R元素
25         System.out.println(hs);
26         System.out.println("hs是否包含count为-3的R对象？" + hs.contains(new R(-3)));  //输出false
27         System.out.println("hs是否包含count为-2的R对象？" + hs.contains(new R(-2)));  //输出false
28     }
29 }
30 
31 class R
32 {
33     int count;
34 
35     public R(int count)
36     {
37         this.count = count;
38     }
39 
40     public String toString()
41     {
42         return "R[count:" + count + "]";
43     }
44 
45     public boolean equals(Object obj)
46     {
47         if (this == obj)
48         {
49             return true;
50         }
51         if (obj != null && obj.getClass() == R.class)
52         {
53             R r = (R) obj;
54             return this.count == r.count;
55         }
56         return false;
57     }
58 
59     public int hashCode()
60     {
61         return this.count;
62     }
63 }

[R[count:-3], R[count:5], R[count:-9], R[count:15]]
-3
[R[count:-3], R[count:5], R[count:-9], R[count:15]]
[R[count:5], R[count:-9], R[count:15]]
hs是否包含count为-3的R对象？false
hs是否包含count为-2的R对象？false

 1 import java.util.LinkedHashSet;
 2 
 3 public class LinkedHashSetTest
 4 {
 5     public static void main(String[] args)
 6     {
 7         LinkedHashSet books = new LinkedHashSet();
 8         books.add("疯狂Java讲义");
 9         books.add("轻量级Java EE企业应用实战");
10         books.add("Java并发编程的艺术");
11         String a = null;
12         books.add(a);
13         System.out.println(books);
14 
15 //        删除 疯狂Java讲义
16         books.remove("疯狂Java讲义");
17 //        重新添加 疯狂Java 讲义
18         books.add("疯狂Java讲义");
19         System.out.println(books);
20     }
21 }

 1 package com.edu.ynu.java.learn.collection;
 2 
 3 import java.util.TreeSet;
 4 
 5 public class TreeSetTest
 6 {
 7     public static void main(String[] args)
 8     {
 9         TreeSet nums = new TreeSet();
10         nums.add(15);
11         nums.add(20);
12         nums.add(-1);
13         nums.add(-19);
14 //        输出集合元素，看到集合元素已经处于排序状态
15         System.out.println(nums);
16 //        输出集合中的第一个元素
17         System.out.println(nums.first());
18 //        输出集合中最后一个元素
19         System.out.println(nums.last());
20 //        返回小于4的子集,不包含4
21         System.out.println(nums.headSet(2));
22 //        返回大于5的子集
23         System.out.println(nums.tailSet(3));
24 //        返回大于等于-6，小于4的子集
25         System.out.println(nums.subSet(-6, 4));
26     }
27 }

1 class Err{}
2 public class TreeSetErrorTest
3 {
4    public static void main(String[] args){
5     TreeSet ts=new TreeSet();
6     ts.add(new Err());
7     ts.add(new Err());
8 }
9 }

 1 import java.util.TreeSet;
 2 
 3 public class TreeSetTest2
 4 {
 5     public static void main(String[] args)
 6     {
 7         TreeSet set = new TreeSet();
 8         Z z1 = new Z(6);
 9         Z1 z2 = new Z1(5);
10         set.add(z1);
11 //        第二次天添加同一个对象,输出true,表明添加成功
12         System.out.println(set.add(z1));
13         //输出集合中的元素，数据两个变量
14         System.out.println(set);
15         ((Z) (set.first())).age = 9;
16 //        集合中两个元素的值都变为9
17         System.out.println("first age:" + ((Z) (set.first())).age + " last age" + ((Z) (set.last())).age);
18 
19     }
20 }
21 
22 class Z implements Comparable
23 {
24     int age;
25 
26     public Z(int age)
27     {
28         this.age = age;
29     }
30 
31     public int compareTo(Object o)
32     {
33         return 1;
34     }
35 
36     public boolean equals(Object obj)
37     {
38         return true;
39     }
40 }

 1 package com.edu.ynu.java.learn.collection;
 2 
 3 import java.util.TreeSet;
 4 
 5 public class TreeSetTest3
 6 {
 7     public static void main(String[] args)
 8     {
 9         TreeSet ts = new TreeSet();
10         ts.add(new M(5));
11         ts.add(new M(-3));
12         ts.add(new M(9));
13         ts.add(new M(-2));
14 //        打印TreeSet集合,集合元素时有序排列的
15         System.out.println(ts);
16 //        取出第一个元素
17         R first = (R) ts.first();
18 //        对第一个元素的count赋值
19         first.count = 20;
20 //        取出最后一个元素
21         R last = (R) ts.last();
22 //        对最后一个元素的count赋值,与第二个元素的count相同
23         last.count = -2;
24         //再次输出将看到TreeSet里的元素处于无序的状态，且有重复元素
25         System.out.println(ts);
26 //        删除实例变量被改变的元素，删除失败
27         System.out.println(ts.remove(new R(-2)));
28         System.out.println(ts);
29 //          删除实例变量没有被改变的元素，删除成功
30         System.out.println(ts.remove(new R(5)));
31         System.out.println(ts);
32     }
33 }
34 
35 class M implements Comparable
36 {
37     int count;
38 
39     public M(int count)
40     {
41         this.count = count;
42     }
43 
44     @Override
45     public String toString()
46     {
47         return "M[count:" + count + "]";
48     }
49 
50     @Override
51     public int compareTo(Object o)
52     {
53         return 0;
54     }
55 
56     //    重写equals方法，根据count来判断是否相等
57     public boolean equals(Object obj)
58     {
59         if (this == obj)
60         {
61             return true;
62         }
63         if (obj != null && obj.getClass() == R.class)
64         {
65             return ((R) obj).count == this.count;
66         }
67         return false;
68     }
69 
70     //重写compareTo()方法,根据count来比较大小
71     public int compateTo(Object obj)
72     {
73         M r = (M) obj;
74         return this.count > r.count ? 1 : this.count < r.count ? -1 : 0;
75     }
76 }

 1 import java.util.TreeSet;
 2 
 3 public class TreeTest4
 4 {
 5     public static void main(String[] args)
 6     {
 7 //        M_1 m1 = new M_1(57);
 8 //        M_1 m2 = new M_1(50);
 9 //        TreeSet ts = new TreeSet();
10 //        ts.add(m1);
11 //        ts.add(m2);
12 //        ts.add(new M_1(52));
13 //        ts.add(new M_1(58));
14 //        lamdba写法的实现
15         TreeSet ts = new TreeSet((o1, o2) -> {
16             M_1 M1 = (M_1) o1;
17             M_1 M2 = (M_1) o2;
18 
19             return M1.age > M2.age ? 1 : M1.age < M2.age ? -1 : 0;
20 
21         });
22         ts.add(new M_1(-3));
23         ts.add(new M_1(58));
24         ts.add(new M_1(49));
25         ts.add(new M_1(33));
26         System.out.println(ts);
27     }
28 }
29 
30 
31 class M_1 
32 {
33     int age;
34 
35     public M_1(int age)
36     {
37         this.age = age;
38     }
39 
40     @Override
41     public String toString()
42     {
43         return "M[age:" + this.age + "]";
44     }
45     
46 }

 1 import java.util.Comparator;
 2 import java.util.TreeSet;
 3 
 4 public class TreeTest4
 5 {
 6     public static void main(String[] args)
 7     {
 8 //        M_1 m1 = new M_1(57);
 9 //        M_1 m2 = new M_1(50);
10 //        TreeSet ts = new TreeSet();
11 //        ts.add(m1);
12 //        ts.add(m2);
13 //        ts.add(new M_1(52));
14 //        ts.add(new M_1(58));
15 //        lamdba写法的实现
16         TreeSet ts = new TreeSet(new M_1(6));
17         ts.add(new M_1(-3));
18         ts.add(new M_1(58));
19         ts.add(new M_1(49));
20         ts.add(new M_1(33));
21         System.out.println(ts);
22     }
23 }
24 
25 
26 class M_1 implements  Comparator
27 {
28     int age;
29 
30     public M_1(int age)
31     {
32         this.age = age;
33     }
34 
35     @Override
36     public String toString()
37     {
38         return "M[age:" + this.age + "]";
39     }
40 
41 
42 
43     @Override
44     public int compare(Object o1, Object o2)
45     {
46         M_1 M1 = (M_1) o1;
47         M_1 M2 = (M_1) o2;
48         return M1.age > M2.age ? -1 : M1.age < M2.age ? 1 : 0;
49     }
50 }