Map集合

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

TreeSet集合会自动排序

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

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

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

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

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

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

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

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

TreeSet<String>  s=new TreeSet<>();

s.add("2");

s.add("5");

 s.add("1");

 s.add("7");

syso(s);  //打印结果为  1，2，5，7 因为String类实现了 Comparable接口

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

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

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

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

package CollectionDemo;

import java.util.TreeSet;

public class Demo8 {

    public static void main(String[] args) {
        
        TreeSet<Employee> s =new TreeSet<>();
        s.add(new Employee("zs",22,4500));
        s.add(new Employee("ls",20,8500));
        s.add(new Employee("ml",28,9500));
        s.add(new Employee("ww",33,3500));
        System.out.println(s);
    }

}
class Employee implements Comparable<Employee>{  //这里的Comparable接口为什么要加泛型<Employee>，因为不加泛型的话默认是Object类，下面还要进行类型转换，所以在这里加一个泛型
    String name;
    int age;
    double salary;
    public Employee() {
        super();
    }
    public Employee(String name, int age, double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }
    @Override
    public int compareTo(Employee o) {
        
        if(this.salary-o.salary>0) {
            return -1;
        }
        else if(this.salary==o.salary){
            if(this.age-o.age>0) {
                return -1;
            }
            else if(this.age==o.age) {
                if(this.name.compareTo(o.name)<0) {
                    return 1;
                }
            }
            
        }
        return 0;
    }
    
    
    
}

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

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

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

Map与Collection的区别：

Collection存储的是一个元素，

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

下面为Map的两种遍历方式

package CollectionDemo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Demo9 {

    public static void main(String[] args) {
        HashMap<String,String> map=new HashMap<>();
        map.put("1","一");
        map.put("2","二");
        map.put("3","三");
        map.put("4","四");
        Set<String> set=map.keySet();
        Iterator<String> it=set.iterator();
        while(it.hasNext()) {
            String key=it.next();
            System.out.println(key+"==>"+map.get(key));
        }

    }

}
想来想去，泛型的作用就是，避免类型转换。


package CollectionDemo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo9 {

    public static void main(String[] args) {

        HashMap<String,String> map=new HashMap<>();
        map.put("1", "一");
        map.put("2", "二");
        map.put("3", "三");
        map.put("4", "四");
        
        Set<Map.Entry<String, String>> set=map.entrySet();
        Iterator<Map.Entry<String, String>> it=set.iterator();
        while(it.hasNext()) {
            Map.Entry<String, String> entry=it.next();
            System.out.println(entry.getKey()+"==>"+entry.getValue());
        }
    }
}

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

Set和Map的区别：

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

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

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