java基础学习_集合类03_用户登录注册案例(集合版)、Set集合、Collection集合总结_day17总结

简介: ======================================================================================================================================================...

=============================================================================
=============================================================================
涉及到的知识点有:
1:用户登录注册案例(集合版)(理解)
2:Set集合(理解)
  (1)Set集合的特点
  (2)HashSet集合(掌握)
  (3)TreeSet集合(理解)
  (4)案例
3:Collection集合总结(掌握)
4:针对Collection集合我们到底使用谁呢?(掌握)
5:在集合中常见的数据结构(掌握)
=============================================================================
=============================================================================
1:用户登录注册案例(集合版)(理解)
-----------------------------------------------------------------------------
2:Set集合(理解)
  (1)Set集合的特点
    无序:存和取的顺序不一致,无索引,不可以存储重复元素(唯一)
---------------------------------------
  (2)HashSet集合(掌握)
    A:底层的数据结构是哈希表(是一个元素为链表的数组)

    
    B:哈希表底层依赖两个方法:hashCode()和equals()
      执行顺序:
        首先比较哈希值是否相同
          相同:继续执行equals()方法
            返回true:元素重复了,不添加
            返回false:直接把元素添加到集合
          不相同:就直接把元素添加到集合
    C:如何保证元素唯一性的呢?
      由hashCode()和equals()保证的。
      即:int hashCode()
        boolean equals(Object obj)
    D:开发的时候,代码非常的简单,自动生成即可。
    E:案例
      1.HashSet存储字符串并遍历(注意:字符串默认重写了hasCode()和equals()方法)
      2.HashSet存储自定义对象并遍历(对象的成员变量值都相同即为同一个元素)
    F:LinkedHashSet:底层的数据结构由哈希表和链表组成。
      哈希表保证元素的唯一性。
      链表保证元素有序。(存储和取出顺序一致)
    注意事项:
      1.一般来说,不同的字符串的哈希值是不同的。
        哈希值仅仅是逻辑值,可能一样。
        地址值是实际的物理值,不一样。
      2.HashSet:它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。
        注意:虽然Set集合的元素无序,但是,作为集合来说,它肯定有它自己的存储顺序,
              而你的顺序恰好和它的存储顺序一致,这代表不了有序,你可以多存储一些数据,就能看到效果。

---------------------------------------
  (3)TreeSet集合(理解)
    A:底层数据结构是红黑树(是一个自平衡的二叉树)(自平衡:说明其结构不会太深)

    
    B:保证元素的排序方式(具体那种方式取决于使用TreeSet的构造方法)
      a:自然排序(元素具备比较性)
        让元素所属的类实现自然排序 Comparable接口。

        示例代码如下:

 1 package cn.itcast_06;
 2 
 3 /*
 4  * 如果一个类的元素要想能够进行自然排序,就必须实现自然排序接口,然后重写compareTo()方法
 5  */
 6 public class Student implements Comparable<Student>{
 7     private String name;
 8     private int age;
 9 
10     public Student() {
11         super();
12     }
13 
14     public Student(String name, int age) {
15         super();
16         this.name = name;
17         this.age = age;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setName(String name) {
25         this.name = name;
26     }
27 
28     public int getAge() {
29         return age;
30     }
31 
32     public void setAge(int age) {
33         this.age = age;
34     }
35     
36     @Override
37     public int compareTo(Student s) {
38         // 主要条件:姓名的长度
39         int num = this.name.length() - s.name.length();
40         // 次要条件1:姓名的长度相同,不代表姓名的内容相同
41         int num2 = (num == 0 ? this.name.compareTo(s.name) : num);
42         // 次要条件2:姓名的长度和内容相同,不代表年龄也相同,所以还得继续比较年龄
43         int num3 = (num2 == 0 ? this.age - s.age : num2);
44         return num3;
45     }
46 
47 }
Student.java
 1 package cn.itcast_06;
 2 
 3 import java.util.TreeSet;
 4 
 5 /*
 6  * TreeSet存储自定义对象并保证排序和唯一
 7  * 
 8  * 需求:请按照姓名的长度排序。
 9  * 
10  * TreeSet集合保证元素排序和唯一性的原理:
11  *         唯一性:是根据比较的返回是否是0来决定。
12  *         排序:
13  *             A:自然排序(元素具备比较性)
14  *                 让元素所属的类实现自然排序 Comparable接口。
15  *             B:比较器排序(集合具备比较性)
16  *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。
17  */
18 public class TreeSetDemo {
19     public static void main(String[] args) {
20         // 创建集合对象
21         // TreeSet的构造方法:public TreeSet() // 自然排序
22         TreeSet<Student> ts = new TreeSet<Student>(); 
23 
24         // 创建元素对象
25         Student s1 = new Student("linqingxia", 27);
26         Student s2 = new Student("zhangguorong", 29);
27         Student s3 = new Student("wanglihong", 23);
28         Student s4 = new Student("linqingxia", 27);
29         Student s5 = new Student("liushishi", 22);
30         Student s6 = new Student("wuqilong", 40);
31         Student s7 = new Student("fengqingy", 22);
32         Student s8 = new Student("linqingxia", 29);
33 
34         // 添加元素到集合
35         ts.add(s1);
36         ts.add(s2);
37         ts.add(s3);
38         ts.add(s4);
39         ts.add(s5);
40         ts.add(s6);
41         ts.add(s7);
42         ts.add(s8);
43 
44         // 遍历集合
45         for (Student s : ts) {
46             System.out.println(s.getName() + "---" + s.getAge());
47         }
48     }
49 }
TreeSetDemo.java

     b:比较器排序(集合具备比较性)
        让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。

        示例代码如下:

        (1)用自己新建的实现类实现

 1 package cn.itcast_07;
 2 
 3 /*
 4  * 如果一个类的元素要想能够进行比较器排序。
 5  */
 6 public class Student {
 7     private String name;
 8     private int age;
 9 
10     public Student() {
11         super();
12     }
13 
14     public Student(String name, int age) {
15         super();
16         this.name = name;
17         this.age = age;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setName(String name) {
25         this.name = name;
26     }
27 
28     public int getAge() {
29         return age;
30     }
31 
32     public void setAge(int age) {
33         this.age = age;
34     }
35 
36 }
Student.java
 1 package cn.itcast_07;
 2 
 3 import java.util.Comparator;
 4 
 5 public class MyComparator implements Comparator<Student> {
 6 
 7     @Override
 8     public int compare(Student s1, Student s2) {
 9         // return 0;
10         
11         // 需求:请按照姓名的长度排序
12         // int num = this.name.length() - s.name.length();
13         // this --> s1    // s1不能直接访问name,因为s1是在MyComparator类中,而name是在Student类中,要想访问,需要通过getXxx()方法
14         // s --> s2
15         
16         // 姓名长度
17         int num = s1.getName().length() - s2.getName().length();
18         // 姓名内容
19         int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num);
20         // 年龄
21         int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2);
22         return num3;
23     }
24 
25 }
MyComparator.java
 1 package cn.itcast_07;
 2 
 3 import java.util.TreeSet;
 4 
 5 /*
 6  * 需求:请按照姓名的长度排序
 7  * 
 8  * TreeSet集合保证元素排序和唯一性的原理:
 9  *         唯一性:是根据比较的返回是否是0来决定。
10  *         排序:
11  *             A:自然排序(元素具备比较性)
12  *                 让元素所属的类实现自然排序 Comparable接口。
13  *             B:比较器排序(集合具备比较性)
14  *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。
15  */
16 public class TreeSetDemo {
17     public static void main(String[] args) {
18         // 创建集合对象
19         // TreeSet的构造方法:public TreeSet(Comparator<? super E> comparator) // 比较器排序,传递的数据类型是引用数据类型中的接口,说明传递的是实现类对象
20         TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());     // 示例:自己写了个具体实现类MyMyComparator,并重写compare()方法
21 
22         // 创建元素对象
23         Student s1 = new Student("linqingxia", 27);
24         Student s2 = new Student("zhangguorong", 29);
25         Student s3 = new Student("wanglihong", 23);
26         Student s4 = new Student("linqingxia", 27);
27         Student s5 = new Student("liushishi", 22);
28         Student s6 = new Student("wuqilong", 40);
29         Student s7 = new Student("fengqingy", 22);
30         Student s8 = new Student("linqingxia", 29);
31 
32         // 添加元素到集合
33         ts.add(s1);
34         ts.add(s2);
35         ts.add(s3);
36         ts.add(s4);
37         ts.add(s5);
38         ts.add(s6);
39         ts.add(s7);
40         ts.add(s8);
41 
42         // 遍历集合
43         for (Student s : ts) {
44             System.out.println(s.getName() + "---" + s.getAge());
45         }
46     }
47 }
TreeSetDemo.java

        (2)用用匿名内部类实现

 1 package cn.itcast_07;
 2 
 3 /*
 4  * 如果一个类的元素要想能够进行比较器排序。
 5  */
 6 public class Student {
 7     private String name;
 8     private int age;
 9 
10     public Student() {
11         super();
12     }
13 
14     public Student(String name, int age) {
15         super();
16         this.name = name;
17         this.age = age;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setName(String name) {
25         this.name = name;
26     }
27 
28     public int getAge() {
29         return age;
30     }
31 
32     public void setAge(int age) {
33         this.age = age;
34     }
35 
36 }
Student.java
 1 package cn.itcast_07;
 2 
 3 import java.util.Comparator;
 4 import java.util.TreeSet;
 5 
 6 /*
 7  * 需求:请按照姓名的长度排序
 8  * 
 9  * TreeSet集合保证元素排序和唯一性的原理:
10  *         唯一性:是根据比较的返回是否是0来决定。
11  *         排序:
12  *             A:自然排序(元素具备比较性)
13  *                 让元素所属的类实现自然排序 Comparable接口。
14  *             B:比较器排序(集合具备比较性)
15  *                 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。
16  */
17 public class TreeSetDemo {
18     public static void main(String[] args) {
19         // 创建集合对象
20         // TreeSet的构造方法:public TreeSet() // 自然排序
21         // TreeSet<Student> ts = new TreeSet<Student>(); 
22         
23         // TreeSet的构造方法:public TreeSet(Comparator<? super E> comparator) // 比较器排序,传递的数据类型是引用数据类型中的接口,说明传递的是实现类对象
24         // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());     // 示例:自己写了个具体实现类MyComparator,并重写compare()方法
25 
26         // 如果一个方法的参数是接口,那么真正需要的是接口的实现类的对象,而且该方法只调用一次。
27         // 所以使用匿名内部类就可以实现这个东西,这样就不用自己去重新写一个具体的实现类了。其实这种方式是很常见的。
28         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
29             @Override
30             public int compare(Student s1, Student s2) {
31                 // 姓名长度
32                 int num = s1.getName().length() - s2.getName().length();
33                 // 姓名内容
34                 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num);
35                 // 年龄
36                 int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2);
37                 return num3;
38             }
39         });
40 
41         // 创建元素对象
42         Student s1 = new Student("linqingxia", 27);
43         Student s2 = new Student("zhangguorong", 29);
44         Student s3 = new Student("wanglihong", 23);
45         Student s4 = new Student("linqingxia", 27);
46         Student s5 = new Student("liushishi", 22);
47         Student s6 = new Student("wuqilong", 40);
48         Student s7 = new Student("fengqingy", 22);
49         Student s8 = new Student("linqingxia", 29);
50 
51         // 添加元素到集合
52         ts.add(s1);
53         ts.add(s2);
54         ts.add(s3);
55         ts.add(s4);
56         ts.add(s5);
57         ts.add(s6);
58         ts.add(s7);
59         ts.add(s8);
60 
61         // 遍历集合
62         for (Student s : ts) {
63             System.out.println(s.getName() + "---" + s.getAge());
64         }
65     }
66 }
TreeSetDemo.java

    C:把我们讲过的代码看一遍即可
  (4)案例
    A:编写一个程序,获取10个1至20的随机数,要求随机数不能重复。

    1.用集合HashSet实现

 1 package cn.itcast_08;
 2 
 3 import java.util.HashSet;
 4 import java.util.Random;
 5 
 6 /*
 7  * 编写一个程序,获取10个1至20的随机数,要求随机数不能重复。
 8  * 
 9  * 分析:
10  *         A:创建随机数对象
11  *         B:创建一个HashSet集合
12  *         C:判断集合的长度是不是小于10,因为Integer包装类默认实现了Comparable接口,所以Integer类能自动判断是否有重复元素
13  *             是:就创建一个随机数添加
14  *             否:不搭理它
15  *         D:遍历HashSet集合
16  */
17 public class HashSetDemo {
18     public static void main(String[] args) {
19         // 创建随机数对象
20         Random r = new Random();
21 
22         // 创建一个HashSet集合
23         HashSet<Integer> hs = new HashSet<Integer>();
24 
25         // 判断集合的长度是不是小于10,因为Integer包装类默认实现了Comparable接口,所以Integer类能自动判断是否有重复元素
26         while (hs.size() < 10) {
27             int num = r.nextInt(20) + 1;
28             hs.add(num);
29         }
30 
31         // 遍历HashSet集合
32         for (Integer i : hs) {
33             System.out.println(i);
34         }
35     }
36 }
HashSetDemo.java

    2.用集合ArrayList实现

 1 package cn.itcast_02;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Random;
 5 
 6 /*
 7  * 获取10个1-20之间的随机数,要求不能重复
 8  * 
 9  * 用数组实现,但是数组的长度是固定的。
10  * 长度不好确定,所以我们使用集合实现。
11  * 
12  * 分析:
13  *         A:创建产生随机数的对象。
14  *         B:创建一个存储随机数的集合ArrayList。
15  *         C:定义一个统计变量。从0开始。
16  *         D:判断统计遍历是否小于10
17  *             是:产生一个随机数,判断该随机数在集合中是否存在。
18  *                     如果不存在:就添加,统计变量++。
19  *                     如果存在:就不搭理它。
20  *             否:不搭理它
21  *         E:遍历ArrayList集合
22  */
23 public class ArrayListDemo {
24     public static void main(String[] args) {
25         // 创建产生随机数的对象。
26         Random r = new Random();
27 
28         // 创建一个存储随机数的集合。
29         ArrayList<Integer> array = new ArrayList<Integer>();
30 
31         // 定义一个统计变量。从0开始。
32         int count = 0;
33 
34         // 判断统计遍历是否小于10
35         while (count < 10) {
36             // 产生一个随机数
37             int number = r.nextInt(20) + 1;
38 
39             // 判断该随机数在集合中是否存在。
40             if (!array.contains(number)) {
41                 // 如果不存在:就添加,统计变量++。
42                 array.add(number);
43                 count++;
44             }
45         }
46 
47         // 遍历集合
48         for (Integer i : array) {
49             System.out.println(i);
50         }
51     }
52 }
ArrayListDemo.java

    B:键盘录入5个学生信息(姓名、语文成绩、数学成绩、英语成绩),按照总分从高到低输出到控制台。

 1 package cn.itcast_09;
 2 
 3 public class Student {
 4     // 姓名
 5     private String name;
 6     // 语文成绩
 7     private int chinese;
 8     // 数学成绩
 9     private int math;
10     // 英语成绩
11     private int english;
12     
13     public Student() {
14         super();
15     }
16 
17     public Student(String name, int chinese, int math, int english) {
18         super();
19         this.name = name;
20         this.chinese = chinese;
21         this.math = math;
22         this.english = english;
23     }
24 
25     public String getName() {
26         return name;
27     }
28 
29     public void setName(String name) {
30         this.name = name;
31     }
32 
33     public int getChinese() {
34         return chinese;
35     }
36 
37     public void setChinese(int chinese) {
38         this.chinese = chinese;
39     }
40 
41     public int getMath() {
42         return math;
43     }
44 
45     public void setMath(int math) {
46         this.math = math;
47     }
48 
49     public int getEnglish() {
50         return english;
51     }
52 
53     public void setEnglish(int english) {
54         this.english = english;
55     }
56 
57     public int getSum() {
58         return this.chinese + this.math + this.english;
59     }
60 }
Student.java
 1 package cn.itcast_09;
 2 
 3 import java.util.Comparator;
 4 import java.util.Scanner;
 5 import java.util.TreeSet;
 6 
 7 /*
 8  * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
 9  * 
10  * 分析:
11  *         A:定义学生类
12  *         B:创建一个TreeSet集合
13  *         C:总分从高到底如何实现呢?        
14  *         D:键盘录入5个学生信息
15  *         E:遍历TreeSet集合
16  */
17 public class TreeSetDemo {
18     public static void main(String[] args) {
19         // 创建一个TreeSet集合
20         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
21             @Override
22             public int compare(Student s1, Student s2) {
23                 // 总分从高到低
24                 int num = s2.getSum() - s1.getSum();
25                 // 总分相同的不一定语文相同
26                 int num2 = (num == 0 ? s1.getChinese() - s2.getChinese() : num);
27                 // 总分和语文相同的不一定数序相同
28                 int num3 = (num2 == 0 ? s1.getMath() - s2.getMath() : num2);
29                 // 总分、语文和数学相同的不一定英语相同
30                 int num4 = (num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3);
31                 // 总分、语文、数学和英语相同的姓名还不一定相同
32                 int num5 = (num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4);
33                 return num5;
34             }
35         });
36 
37         System.out.println("学生信息录入开始");
38         // 键盘录入5个学生信息
39         for (int x = 1; x <= 5; x++) {
40             Scanner sc = new Scanner(System.in);
41             
42             System.out.println("请输入第" + x + "个学生的姓名:");
43             String name = sc.nextLine();
44             
45             System.out.println("请输入第" + x + "个学生的语文成绩:");
46             String chineseString = sc.nextLine();
47             
48             System.out.println("请输入第" + x + "个学生的数学成绩:");
49             String mathString = sc.nextLine();
50             
51             System.out.println("请输入第" + x + "个学生的英语成绩:");
52             String englishString = sc.nextLine();
53 
54             // 把录入的数据封装到学生对象中
55             Student s = new Student();
56             s.setName(name);
57             s.setChinese(Integer.parseInt(chineseString)); // 把字符串类型转换为int类型
58             s.setMath(Integer.parseInt(mathString));        // 把字符串类型转换为int类型
59             s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型
60 
61             // 把学生对象添加到集合
62             ts.add(s);
63         }
64         System.out.println("学生信息录入完毕");
65 
66         System.out.println("学习信息从高到低排序如下:");
67         System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩");
68         // 遍历TreeSet集合
69         for (Student s : ts) {
70             System.out.println(s.getName() + "\t" + s.getChinese() + "\t" + s.getMath() + "\t" + s.getEnglish());
71         }
72     }
73 }
TreeSetDemo.java

-----------------------------------------------------------------------------
3:Collection集合总结(掌握)

    Collection
        |--List 有序,元素可重复
            |--ArrayList
                底层数据结构是数组。查询快,增删慢。
                线程不安全,效率高
            |--Vector
                底层数据结构是数组。查询快,增删慢。
                线程安全,效率低
            |--LinkedList
                底层数据结构是链表。查询慢,增删快。
                线程不安全,效率高
        |--Set 无序,元素唯一
            |--HashSet
                底层数据结构是哈希表。
                如何保证元素唯一性的呢?
                    依赖两个方法:hashCode()和equals()
                    开发中自动生成这两个方法即可。
                |--LinkedHashSet
                    底层数据结构是链表和哈希表。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。
            |--TreeSet
                底层数据结构是红黑树(二叉树)。
                如何保证元素排序的呢?
                    自然排序
                    比较器排序
                如何保证元素唯一性的呢?
                    根据比较的返回值是否是0来决定。

-----------------------------------------------------------------------------
4:针对Collection集合我们到底使用谁呢?(掌握)

    元素唯一吗?
        是:用Set
            元素排序吗?
                是:TreeSet
                否:HashSet
                如果你知道是用Set,但是不知道是用哪个Set,就用HashSet。
            
        否:用List
            要安全吗?
                是:Vector
                否:ArrayList 或者 LinkedList
                    查询多:ArrayList
                    增删多:LinkedList
                如果你知道是用List,但是不知道是用哪个List,就用ArrayList。
---------------------------------------    
    如果你知道是用 Collection 集合,但是不知道使用谁,就用 ArrayList。
    如果你仅仅知道用集合,就用ArrayList。
    由此可见,ArrayList用的最多。

-----------------------------------------------------------------------------
5:在集合中常见的数据结构(掌握)

  ArrayXxx: 底层数据结构是数组,查询快,增删慢。
  LinkedXxx: 底层数据结构是链表,查询慢,增删快。
  HashXxx: 底层数据结构是哈希表。依赖两个方法:hashCode()和equals()。
  TreeXxx: 底层数据结构是二叉树。两种方式排序:自然排序和比较器排序。
=============================================================================

我的GitHub地址: https://github.com/heizemingjun
我的博客园地址: http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名,谢谢!】
相关文章
|
22天前
|
Java
Java 8 引入的 Streams 功能强大,提供了一种简洁高效的处理数据集合的方式
Java 8 引入的 Streams 功能强大,提供了一种简洁高效的处理数据集合的方式。本文介绍了 Streams 的基本概念和使用方法,包括创建 Streams、中间操作和终端操作,并通过多个案例详细解析了过滤、映射、归并、排序、分组和并行处理等操作,帮助读者更好地理解和掌握这一重要特性。
27 2
|
27天前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中,但对于自定义对象,需要注意重写`equals()`方法以确保正确的判断结果,同时根据具体的性能需求选择合适的`Set`实现类。
|
22天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
27天前
|
存储 Java 开发者
在 Java 中,如何遍历一个 Set 集合?
【10月更文挑战第30天】开发者可以根据具体的需求和代码风格选择合适的遍历方式。增强for循环简洁直观,适用于大多数简单的遍历场景;迭代器则更加灵活,可在遍历过程中进行更多复杂的操作;而Lambda表达式和`forEach`方法则提供了一种更简洁的函数式编程风格的遍历方式。
|
26天前
|
存储 Java 开发者
Java中的集合框架深入解析
【10月更文挑战第32天】本文旨在为读者揭开Java集合框架的神秘面纱,通过深入浅出的方式介绍其内部结构与运作机制。我们将从集合框架的设计哲学出发,探讨其如何影响我们的编程实践,并配以代码示例,展示如何在真实场景中应用这些知识。无论你是Java新手还是资深开发者,这篇文章都将为你提供新的视角和实用技巧。
27 0
|
2天前
|
算法
你对Collection中Set、List、Map理解?
你对Collection中Set、List、Map理解?
33 18
你对Collection中Set、List、Map理解?
|
2月前
|
存储 JavaScript 前端开发
Set、Map、WeakSet 和 WeakMap 的区别
在 JavaScript 中,Set 和 Map 用于存储唯一值和键值对,支持多种操作方法,如添加、删除和检查元素。WeakSet 和 WeakMap 则存储弱引用的对象,有助于防止内存泄漏,适合特定场景使用。
|
3月前
|
存储 Java API
【数据结构】map&set详解
本文详细介绍了Java集合框架中的Set系列和Map系列集合。Set系列包括HashSet(哈希表实现,无序且元素唯一)、LinkedHashSet(保持插入顺序的HashSet)、TreeSet(红黑树实现,自动排序)。Map系列为双列集合,键值一一对应,键不可重复,值可重复。文章还介绍了HashMap、LinkedHashMap、TreeMap的具体实现与应用场景,并提供了面试题示例,如随机链表复制、宝石与石头、前K个高频单词等问题的解决方案。
42 6
【数据结构】map&set详解
|
2月前
|
存储 缓存 Java
【用Java学习数据结构系列】HashMap与TreeMap的区别,以及Map与Set的关系
【用Java学习数据结构系列】HashMap与TreeMap的区别,以及Map与Set的关系
41 1
|
3月前
|
算法
你对Collection中Set、List、Map理解?
你对Collection中Set、List、Map理解?
39 5