Map集合

最新推荐文章于 2024-08-16 17:35:37 发布

Controller-Me

最新推荐文章于 2024-08-16 17:35:37 发布

阅读量74

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qq_38830041/article/details/89346840

本文深入解析Java集合类的特性与应用，包括TreeSet的自动排序原理、红黑树结构、泛型的使用场景及作用，以及Map与Collection的区别。通过实例演示如何利用泛型避免类型转换，对比Set和Map在不同场景下的适用性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Map集合

LinkedList集合的底层为双向链表。

TreeSet集合会自动排序

例如插入 1，5，2，9，7

输出的是1，2，5，7，9

TreeSet的特点是：无序（存储顺序也插入顺序不相同），可自动排序，不重复

Comparable接口：强行对实现它的类进行整体排序，这种排序叫做类的自然排序。

TreeSet就实现了Comparable接口，所以TreeSet可自动排序。

红黑树结构：插入的第一个元素是根节点，然后后来插入的每一个元素都要与根节点进行比较，如果比根节点小，则放在根节点的左侧，如果比根节点大，则放在右侧，然后顺着根节点的左侧或右侧一直比较下去，

直到找到适合自己的位置。

红黑树是自平衡的，当不能构成二叉树结构的时候，会旋转，直至旋转至达到二叉树平衡，也就是说红黑树的根节点会变化。

 1 TreeSet<String>  s=new TreeSet<>();
 2 
 3 s.add("2");
 4 
 5 s.add("5");
 6 
 7  s.add("1");
 8 
 9  s.add("7");
10 
11 syso(s);  //打印结果为  1，2，5，7 因为String类实现了 Comparable接口

而自己写的类则需要手动实现Comparable接口。

1 @Override  //根据年龄排序
2 //    public int compareTo(Person5 o) {
3 //        // TODO Auto-generated method stub
4 //        return this.age-o.age;
5 //    };

因为TreeSet的底层是红黑树结构（所以叫TreeSet）,所以重写的CompareTo()方法，返回一个int类型的数值的行了，因为红黑树会根据返回的数值进行排序的。

下面是一个对集合进行排序的程序，主要是依靠重写了CompareTo()方法。

 1 package CollectionDemo;
 2 
 3 import java.util.TreeSet;
 4 
 5 public class Demo8 {
 6 
 7     public static void main(String[] args) {
 8         
 9         TreeSet<Employee> s =new TreeSet<>();
10         s.add(new Employee("zs",22,4500));
11         s.add(new Employee("ls",20,8500));
12         s.add(new Employee("ml",28,9500));
13         s.add(new Employee("ww",33,3500));
14         System.out.println(s);
15     }
16 
17 }
18 class Employee implements Comparable<Employee>{  //这里的Comparable接口为什么要加泛型<Employee>，因为不加泛型的话默认是Object类，下面还要进行类型转换，所以在这里加一个泛型
19     String name;
20     int age;
21     double salary;
22     public Employee() {
23         super();
24     }
25     public Employee(String name, int age, double salary) {
26         super();
27         this.name = name;
28         this.age = age;
29         this.salary = salary;
30     }
31     @Override
32     public String toString() {
33         return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
34     }
35     @Override
36     public int compareTo(Employee o) {
37         
38         if(this.salary-o.salary>0) {
39             return -1;
40         }
41         else if(this.salary==o.salary){
42             if(this.age-o.age>0) {
43                 return -1;
44             }
45             else if(this.age==o.age) {
46                 if(this.name.compareTo(o.name)<0) {
47                     return 1;
48                 }
49             }
50             
51         }
52         return 0;
53     }
54     
55     
56     
57 }

泛型什么时候用：当你的集合中，只装一种类型的对象时，可以加一个泛型，因为不加泛型，默认就是Object类型，还需要自己类型转换。

泛型的作用就是，避免类型转换。

第三方比较器：当类已经封装好，不能进行修改，然而此时需要加一个排序功能时，就可以使用第三方比较器，

Map与Collection的区别：

Collection存储的是一个元素，

Map存储的是一对元素，称为双列集合，键值对，键：key 值：value

下面为Map的两种遍历方式

 1 package CollectionDemo;
 2 
 3 import java.util.HashMap;
 4 import java.util.Iterator;
 5 import java.util.Set;
 6 
 7 public class Demo9 {
 8 
 9     public static void main(String[] args) {
10         HashMap<String,String> map=new HashMap<>();
11         map.put("1","一");
12         map.put("2","二");
13         map.put("3","三");
14         map.put("4","四");
15         Set<String> set=map.keySet();
16         Iterator<String> it=set.iterator();
17         while(it.hasNext()) {
18             String key=it.next();
19             System.out.println(key+"==>"+map.get(key));
20         }
21 
22     }
23 
24 }
25 想来想去，泛型的作用就是，避免类型转换。
26 
27 
28 package CollectionDemo;
29 
30 import java.util.HashMap;
31 import java.util.Iterator;
32 import java.util.Map;
33 import java.util.Set;
34 
35 public class Demo9 {
36 
37     public static void main(String[] args) {
38 
39         HashMap<String,String> map=new HashMap<>();
40         map.put("1", "一");
41         map.put("2", "二");
42         map.put("3", "三");
43         map.put("4", "四");
44         
45         Set<Map.Entry<String, String>> set=map.entrySet();
46         Iterator<Map.Entry<String, String>> it=set.iterator();
47         while(it.hasNext()) {
48             Map.Entry<String, String> entry=it.next();
49             System.out.println(entry.getKey()+"==>"+entry.getValue());
50         }
51     }
52 }