Map集合

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

TreeSet集合会自动排序

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

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

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

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

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

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

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

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

复制代码
1 TreeSet 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 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{ //这里的Comparable接口为什么要加泛型，因为不加泛型的话默认是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.salaryo.salary){
42 if(this.age-o.age>0) {
43 return -1;
44 }
45 else if(this.ageo.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 set=map.keySet();
16 Iterator 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 }
复制代码

集合的有序和无序，其实和集合的底层有关，底层是链表，每次插入一个就往后加一个

Set和Map的区别：

Map有键，可以直接用键来对对象进行排序，例如一个学生管理系统，学号是键，学生对象是值，利用键来对学生对象进行排序，更方便一点。

而Set，要利用学号来对学生对象进行排序，还需要先将学生对象的学号取出来，才能排序，相比之下，对于学生管理系统，Map更适合一点，

不同的集合类型，有不同的特点，也自然适用于不同的地方。