集合底层原理

1.ArrayList底层

List<String> list = new ArrayList();


//ArrayList底层是采用Object[]来存储元素,由此可知，ArrayList是有序在的，随机访问时效率极高，但在增加，删除时效率偏低，因为涉及到元素移动

//Arraylist每次扩容都是扩容到原来的1.5倍


//当添加元素时应该考录容量问题
//当集合中的元素个数与数组的长度一致时，即
size == elements.length
//说明数组已经没有空间，此时需要扩容
int len = elements.length + elements.length >> 1 // 右移动一位相当于 *0.5
//在使用addAll 时 需要判断 len 是否大于需要添加的数组长度,如果小于 len = 需要添加数组长度
 objec obj = new Object(len);
//将原数组中的元素拷贝到新数组中去
System.arraycopy(elments,0,obj,0,elments.length)

1. 1 iterator 与 listiterator 的区别：

   1.iterator 只能单向遍历，listiterator可以双向遍历。

   2.iterator只能遍历，删除元素，listiterator增加了添加、替换、获取前面、后面一个元素索引的功能

​

2.ArrayList add 方法的大概过程：

add(x)
//首先判断一下当前数组的容量是否够用，如果够用，添加到末尾，
//如果不够用，先进行扩容,扩容到原来的1.5倍,完成扩容后再添加。

2.LinkedList底层

LinkedList<String> list = new LinkedList();

//LinkedList底层是用双向链表来存储元素，根据链表的特性可知，其在增加、删除元素时效率极高，只需要进行衔接即可，而在遍历元素时效率较低，因为要从一端遍历到另一端

3.Vector

Vector<> vector = new Vector();

//vector是线程安全集合，因为每个方法都加了锁
//用法和ArrayList一样

4.HashMap底层

Map<String,Integer> map = new HashMap()
//HashMap存储的是一组无序的键值对，根据哈希码计算存储的位置，因为对象的哈希码不确定，所有HashMap存储的元素是无序的。

//HashMap采用数组'链表、以及红黑树来存储数据。（jdk 1.7 之前没有红黑树，1.8之后出现）
//链表主要用来针对hash碰撞引发的位置冲突。
//红黑树主要用来解决链表太长，查询效率慢的问题。

//存储数据底层

//HashMap初始容量是16，每次扩容都必须是2的n次幂，原因是为了服务Key映射到index的哈希算法
//index = hash(key)%(16-1)
//当容量达到阈值（当前容量*加载因子（默认是0.75））时，会选择扩容，扩容过后需要重新构建数组和链表，
//元素的index需要重新计算，计算规则是：
//   首先用哈希值和新数组长度按位与运算，结果是1，则index不变，是0，index=原数组长度+1
//当链表长度大于8时，会触发树化方法，链表变为树，但不一定变为树，因为有可能重新计算元素下标时链表长度会小于8

红黑树的红黑规则

/*
 一个节点要么红色、要么是黑色的
根节点必须是黑色的
如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为 Nil ，这些 Nil 被视作叶节点，每一个叶节点(Nil)是黑色的
如果某个节点是红色的，那么它的子节点必须是黑色的（不能出现两个红色节点相连的情况）
对每个节点，从该节点到其所有的后代叶节点的简单路径上【就是从该节点到叶节点的每一条路径上】，均包含相同数目的黑色节点
*/

5.比较器接口

Comparable 和Comparator:

//我们在使用数组或集合时经常遇到排序问题，数字能够比较大小，而对象不能直接比较大小，为了解决这个问题，Comparable和Comarator来了

Comparable接口对实现的每个类的对象强加了总排序。称为自然排序，CompareTo称为自然比较方法

//Student类
public class Student implements Comparable<Student> {
    private String name ;
    private Integer score ;
....//其他方法略
    @Override
    public int compareTo(Student o) {
        return score > o.score?1:score==o.score?0:-1;
    }
}

//main
  List<Student> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            Student student = new Student();
            student.setName("student"+i);
            student.setScore(random.nextInt(100));
            list.add(student);
        }
        Collections.sort(list);//排序

//Comparator对某些对象集合施加总排序。可以将比较器传递给排序方法（Collections.srot或Arrays.srot），以实现排序的精准控制。
//Comparator属于外比较强，它会将两个对象拿出来进行比较   
    
    
     List<Student> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            Student student = new Student();
            student.setName("student"+i);
            student.setScore(random.nextInt(100));
            list.add(student);
        }
    Comparator<Student> comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getScore()>o2.getScore()?-1:o1.getScore()==o2.getScore()?0:1;
            }
        };

        list.sort(comparator);//排序
        list.forEach(c-> System.out.println(c.toString()));

6.TreeMap

//TreeMap是基于红黑树的NavigableMap实现，根据集合存储的键的自然排序或Comparator来对键进行排序

//创建TreeMap,student类必须实现comparable
   TreeMap<Student,Integer> student = new TreeMap<>();

//TreeMap存储的对象类必须实现Comparable，或在创建TreeMap时将Comparator传递给其构造方法。
//实现Comparator
 Comparator comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o2.getScore(),o1.getScore());
            }
        };
//创建TreeMap
     TreeMap<Student,Integer> student = new TreeMap<>(comparator);

7.LinkedHashMap

//LinkedHashMap是有序列表

8.set

8.1 hashSet

//hashSet底层采用hashMap来存储元素，因为HashMap的Key是唯一的，所以HashSet存储的元素是唯一的。
//因为HashMap存储元素是无序的，因此HaxhSet存储元素也是无序的。
 HashSet<String> str = new HashSet<>();

8.2 TreeSet

//TreeSet底层由TreeMap的NavigableSet实现，因此元素使用其自然顺序或在集合创建时提供的Comparator进行排序
Comparator<Student> comparator = Comparator.comparing(Student::getAge);
        TreeSet<Student> stu = new TreeSet<>(comparator);

//Comparator.comparing(Student::getAge)   

//         new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//               return o1.getAge()>o2.getAge()?1:o1.getAge()==o2.getAge()?0:-1;
//            }
//        };

8.3 LinkedHashSet

// 此实现与HashSet的不同之处在于，它维护在其所有条目中运行的双向链接列表。
// 有序集合

9.泛型的上限和下限

 //? extends Number 这里的语法表示:   ?表示Number的子类，因为Number由很多子类，比如Integer、Double
 //Long等。因此集合中存储的具体元素类型是无法确定的，所有不能进行添加操作，因为添加必须确定泛型的类型。
        List<? extends Number> numbers = new ArrayList<>();

//？ super Number 这里的语法表示：  ?表示Number的父类，因为Number的父类也可能有很多种，但无论如何Number与其子类
//必定是这些父类的一个实例，从本质上来看就是确定了至少Number这个类型可以添加到集合中去。
        List<? super Number> list = new ArrayList<>();
        list.add(1);
        list.add(1.0);
        list.add(1.0f);
        list.forEach(System.out::println);