java-Set集合、HashSet集合、LinkedHashSet集合和TreeSet集合

1、Set集合,无索引,不可以重复,无序(存取不一致)

 1 public class Demo {
 2 
 3     public static void main(String[] args) {
 4         //demo1();
 5         demo2();
 6     }
 7 
 8     private static void demo2() {
 9         HashSet<Person> hs = new HashSet<>();
10         hs.add(new Person("张三", 23));
11         hs.add(new Person("张三", 23));
12         hs.add(new Person("李四", 24));
13         hs.add(new Person("李四", 24));
14         hs.add(new Person("李四", 24));
15         hs.add(new Person("李四", 24));
16         System.out.println(hs);
17     }
18 
19     public static void demo1() {
20         HashSet<String> hs = new HashSet<>();                    //创建HashSet对象
21         boolean b1 = hs.add("a");
22         boolean b2 = hs.add("a");                                //当向set集合中存储重复元素的时候返回为false
23         hs.add("b");
24         hs.add("c");
25         hs.add("d");
26         System.out.println(hs);                                    //HashSet的继承体系中有重写toString方法
27         System.out.println(b1);
28         System.out.println(b2);
29         
30         for (String string : hs) {                                //只要能用迭代器迭代的,就可以使用增强for循环遍历
31             System.out.println(string);
32         }
33     }
34 
35 }

2、LinkedHashSet集合
  * 底层是链表实现的,是set集合中唯一一个能保证怎么存就怎么取的集合对象
  * 因为是HashSet的子类,所以也是保证元素唯一的,与HashSet的原理一样

 1 public class Demo {
 2 
 3     public static void main(String[] args) {
 4         LinkedHashSet<String> lhs = new LinkedHashSet<>();
 5         lhs.add("a");
 6         lhs.add("a");
 7         lhs.add("a");
 8         lhs.add("a");
 9         lhs.add("b");
10         lhs.add("c");
11         lhs.add("d");
12         
13         System.out.println(lhs);
14     }
15 
16 }

3、TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一

  * 当compareTo方法返回0的时候集合中只有一个元素
  * 当compareTo方法返回正数的时候集合会怎么存就怎么取
  * 当compareTo方法返回负数的时候集合会倒序存储

 1 public class Demo {
 2 
 3     public static void main(String[] args) {
 4         //demo1();
 5         //demo2();
 6         //demo3();
 7         //demo4();
 8         demo5();
 9     }
10 
11     private static void demo5() {
12         //需求:将字符串按照长度排序
13         TreeSet<String> ts = new TreeSet<>(new CompareByLen());        //Comparator c = new CompareByLen();
14         ts.add("aaaaaaaa");
15         ts.add("z");
16         ts.add("wc");
17         ts.add("nba");
18         ts.add("cba");
19         
20         System.out.println(ts);
21     }
22 
23     public static void demo4() {
24         TreeSet<Person> ts = new TreeSet<>();
25         ts.add(new Person("zhangsan", 23));
26         ts.add(new Person("lisi", 13));
27         ts.add(new Person("wangwu", 33));
28         ts.add(new Person("zhaoliu", 43));
29         ts.add(new Person("aaaa", 53));
30         
31         System.out.println(ts);
32     }
33 
34     public static void demo3() {
35         TreeSet<Person> ts = new TreeSet<>();
36         ts.add(new Person("李四", 13));
37         ts.add(new Person("张三", 23));
38         ts.add(new Person("王五", 43));
39         ts.add(new Person("赵六", 33));
40         
41         System.out.println('张' + 0);
42         System.out.println('李' + 0);
43         System.out.println('王' + 0);
44         System.out.println('赵' + 0);
45         
46         System.out.println(ts);
47     }
48 
49     public static void demo2() {
50         TreeSet<Person> ts = new TreeSet<>();
51         ts.add(new Person("张三", 23));
52         ts.add(new Person("李四", 13));
53         ts.add(new Person("周七", 13));
54         ts.add(new Person("王五", 43));
55         ts.add(new Person("赵六", 33));
56         
57         System.out.println(ts);
58     }
59 
60     public static void demo1() {
61         TreeSet<Integer> ts = new TreeSet<>();
62         ts.add(3);
63         ts.add(1);
64         ts.add(1);
65         ts.add(2);
66         ts.add(2);
67         ts.add(3);
68         ts.add(3);
69         
70         System.out.println(ts);
71     }
72 
73 }
74 
75 
76 class CompareByLen /*extends Object*/ implements Comparator<String> {
77 
78     @Override
79     public int compare(String s1, String s2) {        //按照字符串的长度比较
80         int num = s1.length() - s2.length();        //长度为主要条件
81         return num == 0 ? s1.compareTo(s2) : num;    //内容为次要条件
82     }
83     
84 }

4、例:

 1 public class Test {
 2 
 3     /**
 4      * 程序启动后, 可以从键盘输入接收多个整数, 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
 5      * 
 6      * 1,创建Scanner对象,键盘录入
 7      * 2,创建TreeSet集合对象,TreeSet集合中传入比较器
 8      * 3,无限循环不断接收整数,遇到quit退出,因为退出是quit,所以键盘录入的时候应该都以字符串的形式录入
 9      * 4,判断是quit就退出,不是将其转换为Integer,并添加到集合中
10      * 5,遍历TreeSet集合并打印每一个元素
11      */
12     public static void main(String[] args) {
13         //1,创建Scanner对象,键盘录入
14         Scanner sc = new Scanner(System.in);
15         //2,创建TreeSet集合对象,TreeSet集合中传入比较器
16         TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
17 
18             @Override
19             public int compare(Integer i1, Integer i2) {
20                 //int num = i2 - i1;                    //自动拆箱
21                 int num = i2.compareTo(i1);
22                 return num == 0 ? 1 : num;
23             }
24         });
25         //3,无限循环不断接收整数,遇到quit退出,因为退出是quit,所以键盘录入的时候应该都以字符串的形式录入
26         while(true) {
27             String line = sc.nextLine();                //将键盘录入的字符串存储在line中
28             if("quit".equals(line)) {
29                 break;
30             }
31             //4,判断是quit就退出,不是将其转换为Integer,并添加到集合中
32             Integer i = Integer.parseInt(line);
33             ts.add(i);
34         }
35         
36         // 5,遍历TreeSet集合并打印每一个元素
37         for (Integer integer : ts) {
38             System.out.println(integer);
39         }
40     }
41 
42 }

猜你喜欢

转载自www.cnblogs.com/hfumin/p/10222800.html