第十一章集合

* 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
*  说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）
*  //【持久化的存储：硬盘、服务器、数据库。讲到IO流时再讲】
*
* 2.1 数组在存储多个数据方面的特点：
*      > 一旦初始化以后，其长度就确定了。
*      > 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
*      //【严格是好处，放了不同类型就报错.
*      //集合类型不确定，什么都能往里放，并不好，不严格
*      //泛型能解决这件事】
*       比如：String[] arr;int[] arr1;Object[] arr2;
*       //【Object[] arr2;可以多态】
*
* 2.2 数组在存储多个数据方面的缺点：
*      > 一旦初始化以后，其长度就不可修改。
*      > 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
*      //【添加、删除、插入数据都要挪元素，没有方法可以直接拿来调用。数组只是数据结构中的一种，集合设计的数据结构很丰富：链表二叉树等，添加、删除、插入效率更高】
*
*      > 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
*      > 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

* 二、集合框架
*      |----Collection接口：单列集合，用来存储一个一个的对象
*          |----List接口：存储有序的、可重复的数据。  -->“动态”数组
*          //【和数组特点很像】
*              |----ArrayList、LinkedList、Vector
*              //【ArrayList、LinkedList、Vector的不同，底层扩容什么样的？】
*
*          |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
*              |----HashSet、LinkedHashSet、TreeSet
*          //【通常用Set做一些数据过滤的问题。有一些重复数据，放入Set里，放入顺序无所谓，发现放入的数据和前面的一样，就不要了，这样就过滤掉了】
*
*      |----Map接口：双列集合，用来存储一对(key - value)一对的数据   -->高中函数：y = f(x)//【x是key，y是value】
*              |----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
*              //【HashMap的底层实现原理。jdk7和8不一样】

集合：Collection接口：
>List接口（动态数组）：ArrayList、LinkedList、Vector
>Set接口（集合）：HashSet、LinkedHashSet、TreeSet

Map接口（函数）：

>HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

开发中，集合中List、Map用的最多，Set很少用
*  List用来替换数组

理解Map接口：

2.集合使用场景

二、Collection接口的常用方法

一共15个方法

1.常用方法1

public class CollectionTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);//【coll.toString()。ArrayList里重写的】

        //clear():清空集合元素
        //【不是把coll指向null，而是让元素都为null
        // elementData[i] = null;】
        //【coll.isEmpty()也不会报空指针异常】
        coll.clear();

        //isEmpty():判断当前集合是否为空
        //【不是集合是否为null，而是判断集合中是否有元素，就是看size】
        System.out.println(coll.isEmpty());

    }

}

（1）add(Object e)

（2）addAll(Collection coll)

（3）size()

（4）clear() :

不是把coll指向null，而是让集合元素都为null
elementData[i] = null;
这样coll.isEmpty()也不会报空指针异常

（5）isEmpty()：

不是集合是否为null，而是判断集合中是否有元素，就是看size是否为0

2.常用方法2

 /* Collection接口中声明的方法的测试
 *
 * 结论：
 * 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().
 */
public class CollectionTest {


    @Test
    public void test1(){
        Collection coll = new ArrayList();//【ArrayList，按顺序一个一个比较】
        coll.add(123);//【123是Integer包装类，不是int基本数据类型】
        coll.add(456);
/*
//        Person p = new Person("Jerry",20);
//        coll.add(p);
//        System.out.println(coll.contains(p));//true
          //【这样写，不管怎样都是true，
          //用Object类的equals，contains内部调==比较对象的地址值，是true，p是引用，保存了地                
            址；
          //重写了equals，调equals比较对象的内容也是true】
*/
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);//【false是Boolean包装类，不是boolean基本数据类型】

        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        //【向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().】
        boolean contains = coll.contains(123);
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
        //【结果是true，说明比较的是内容，用重写后的equals判断的，
        // 不是用==判断的】

        System.out.println(coll.contains(new Person("Jerry",20)));//false -->true
        //【要重写Person的equals方法，否则用的是Object类的equals方法（==比地址值）】

        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll1));
    }

    @Test
    public void test2(){
        //3.remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        coll.remove(1234);
        //【移除1234，先判断coll集合中有没有1234，所以还是要调equals】
        System.out.println(coll);

        coll.remove(new Person("Jerry",20));
        //【重写了Person类的equals，所以可以删除成功】
        System.out.println(coll);

        //4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
        Collection coll1 = Arrays.asList(123,456);//【Arrays.asList(...)返回一个List集合】
        coll.removeAll(coll1);
        //【调了Person的equals方法】
        System.out.println(coll);


    }

    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);
        //【remove和retainAll都会修改coll】


        //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
        //【调equals方法的是集合coll，形参是一个Object对象，怎样返回true？
        // Object obj也必须是集合，集合元素都和coll集合元素相同->true】
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry",20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        /*交换位置
        coll1.add(456);
        coll1.add(123);
        coll1.add(new Person("Jerry",20));
        coll1.add(new String("Tom"));
        coll1.add(false);
        System.out.println(coll.equals(coll1));
        //【false，因为List是有序的，内容一样顺序不一样也不相同】
        */
        System.out.println(coll.equals(coll1));//true
        //【调用了Person的equals方法。因为输出了"Person equals()...."】


    }

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        //【public native int hashCode();
        // hashCode()定义在Object类中，所有对象都可以调用】
        System.out.println(coll.hashCode());

        //8.集合 --->数组：toArray()
        //【    public Object[] toArray() {
        //        return Arrays.copyOf(elementData, size);
        //    }
        // 返回值类型是Object[]，
        // 前面添加的123、456、new Person、new String、false都是Object类型的元素，所以返回值也是Object[]，
        // Object[]数组，表示数组元素都是Object类型的】
        Object[] arr = coll.toArray();
        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

        //拓展：数组 --->集合:调用Arrays类的静态方法asList()
        //【Arrays.asList(T...a),可变形参相当于数组】
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);//【[AA, BB, CC]】

        List<int[]> arr3 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr3);//【[[I@22927a81]】
        //【[[I@22927a81]，
        // [I@22927a81一个元素，这个元素是一个一维的数组，这个数组的元素是int类型，
        // 把new int[]{123, 456}数组整体当成一个元素，不是把数组内部的元素当成几个元素。
        // 因为数组是引用数据类型，满足可变形参T...a(其实就是Object类)，
        //不会把123，456自动装箱。因为一整个int[]就可以看作是一个对象
        // 所以整个数组被当作“数组这一个对象”，
        // 元素是Integer类型，包装类，就可以单独当成一个对象。】

        List arr4 = Arrays.asList(123, 456);//【删去泛型此时认为是两个元素】
        System.out.println(arr4);//[123, 456]
        System.out.println(arr4.size());//2

        List arr1 = Arrays.asList(new int[]{123, 456});//【元素是基本数据类型，整个数组是一个对象】
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(new Integer[]{123, 456});//【包装类】
        System.out.println(arr2.size());//【2】

        //9.iterator():返回Iterator接口的实例，用于【遍历】集合元素。放在IteratorTest.java中测试

    }
}


//Person类
import java.util.Objects;

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("Person equals()....");//【测试语句，看contains()是否调用了equals】
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

常用方法二都会调用equals，所以要求元素所在类必须重写equals()

（6）contains(Object obj)：

判断当前集合中是否包含obj
在判断时会调用obj对象所在类的equals()。
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()，否则调用的是Object类的equals，比较地址值

（7）containsAll(Collection coll)

调用了元素所属类的equals()

（8）remove(Object obj)

调用了元素所属类的equals()

（9）removeAll(Collection coll)

调了元素所属类equals()

(10)retainAll(Collection coll)

调了元素所属类equals()

(11)equals(Object obj)

调了元素所属类的equals()

3.常用方法3

(12)hashCode() ：定义在 Object类中

(13)toArray()：集合-->数组

Object[] arr = coll.toArray();

(14)asList() ：数组-->集合

List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});

(15)iterator()：

返回Iterator接口的实例，用于遍历集合元素

Collection要重写哪个方法？
* equals()
* List：equals()
* Set：（HashSet、LinkedHashSet）equals()、hashCode()
*      （TreeSet）Comparable：compareTo()
*                Comparator：compare()
*                【TreeSet调contains、remove还是要重写compare或compareTo方法而不是equals】

三、Iterator迭代器

1.使用Iterator遍历Collection

* 集合元素的遍历操作，使用迭代器Iterator接口
* //【只用来遍历Collection接口，Map接口不用迭代器遍历】
* 1.内部的方法：hasNext() 和  next()
* 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
* 默认游标都在集合的第一个元素之前。
* 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
* //【这是迭代器里的remove()，不是Collection集合中的remove()】

public class IteratorTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();//【Iterator是接口，叫迭代器接口】
        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());//报异常：NoSuchElementException【没有这个元素】

        //方式二：不推荐
//        for(int i = 0;i < coll.size();i++){
//            System.out.println(iterator.next());
//        }

        //方式三：推荐
        hasNext():判断是否还有下一个元素
        while(iterator.hasNext()){
            //next():①指针下移 ②将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }

    }

    //【遍历集合的错误写法】
    @Test
    public void test2(){

        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //错误方式一：
//        Iterator iterator = coll.iterator();
//        while((iterator.next()) != null){
//            System.out.println(iterator.next());
//            //【输出：
//            // 456
//            // Tom】
//        }

        //错误方式二：
        //集合对象每次调用iterator()方法都得到一个【全新的迭代器对象】，默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());
            //【输出：
            // 123
            // 123
            // ...
            // 123】
        }


    }

    //测试Iterator中的remove()
    //如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
    // 再调用remove都会报IllegalStateException。
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();//【异常】
            Object obj = iterator.next();//【add时都是认为添加的是Object类型，取的时候也是Object类型】
            if("Tom".equals(obj)){//【"Tom".equals(obj)比obj.equals("Tom")健壮性更好，以防obj是null的情况】
                iterator.remove();
//                iterator.remove();
            }

        }
        //遍历集合
        iterator = coll.iterator();
        //【再次遍历要重新获取iterator指针，因为删除时用的迭代器已经指向集合中最后一个元素了】
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

2.Iterator迭代器的执行原理

3.Iterator迭代器的两种错误写法

见1

4.Iterator迭代器remove()的使用

见1

四、新特性foreach循环遍历集合

jdk 5.0 新增了foreach循环，用于遍历Collection集合、数组

for(集合元素的类型 局部变量 : 集合对象)遍历集合
for(数组元素的类型 局部变量 : 数组对象)遍历数组
【foreach内部仍然调用了迭代器。】
【Object这个位置，由coll集合中的元素是什么类型决定】
【Object obj就像for循环里的int i一样】
for(Object obj : coll){
    System.out.println(obj);
}

/*【foreach的工作过程：
coll取第一个元素赋给Object obj，然后sout打印obj
coll取第二个元素赋给Object obj，然后sout打印obj
...
coll取最后一个元素赋给Object obj，然后sout打印obj

怎么取的？
debug看一下
内部仍然调用了迭代器】
 */

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

/**
 * jdk 5.0 新增了foreach循环，用于遍历Collection集合、数组
 *
 * @author shkstart
 * @create 2019 上午 11:24
 */
public class ForTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素的类型 局部变量 : 集合对象)遍历集合
        //for(数组元素的类型 局部变量 : 数组对象)遍历数组
        //【内部仍然调用了迭代器。】
        //【Object这个位置，由coll集合中的元素是什么类型决定】
        //【Object obj就像for循环里的int i一样】
        for(Object obj : coll){
            System.out.println(obj);
        }

        /*【foreach的工作过程：
        coll取第一个元素赋给Object obj，然后sout打印obj
        coll取第二个元素赋给Object obj，然后sout打印obj
        ...
        coll取最后一个元素赋给Object obj，然后sout打印obj

        怎么取的？
        debug看一下
        内部仍然调用了迭代器】
         */
    }

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //for(数组元素的类型 局部变量 : 数组对象)
        for(int i : arr){
            System.out.println(i);
        }
    }

    //练习题
    @Test
    public void test3(){

        String[] arr = new String[]{"MM","MM","MM"};

//        //方式一：普通for赋值
//        for(int i = 0;i < arr.length;i++){
//            arr[i] = "GG";
//        }

        //方式二：增强for循环
        for(String s : arr){
            s = "GG";
        }

        //测试
//        for(String s : arr){
            System.out.println("前" + s);


//            s = "GG";
            System.out.println("后" + s);
//        }

        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }


    }
}

五、List接口

1.List接口常用实现类的对比

* 1. List接口框架
*      //单列数据
*    |----Collection接口：单列集合，用来存储一个一个的对象
*          |----List接口：存储有序的、可重复的数据。  -->“动态”数组,替换原有的数组
*              |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
*              //【基本上用这个，底层依然是数组，顺序存储。Array->数组】
*              //【超了长度，不用自己扩容，底层已经把方法写好了】
*              //【多线程，即使ArrayList是不安全的，也不用Vector，怎么解决呢？
*              //后面Collections工具类，List synchronizedList(List<T> list)，
*              //把ArrayList当作实参传进去，就可以返回一个线程安全的集合】
*

*              |----LinkedList：【对于频繁的插入、删除操作，使用此类效率比ArrayList高】；       底层使用双向链表存储
*              //【Link-->链表】
*              //【底层存储的数据结构不同，对数组元素的操作就不同】

*
*              |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[]  elementData存储
*              //效率低，所以不用。synchronized
*
*

2.ArrayList的源码分析

*   2.1 jdk 7情况下
*      ArrayList list = new ArrayList();//【底层创建了长度是10的Object[]数组elementData】
*      //【回顾：StringBuffer底层创建了一个长16的char[] value】
*
*      list.add(123);//elementData[0] = new Integer(123);
*      ...
*      list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
*      默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
*
*      【结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)】
*      //【避免中间环节扩容，效率高】

*   2.2 jdk 8中ArrayList的变化：
*      ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
*
*      list.add(123);//【第一次调用add()时，底层才创建了长度10的数组】，并将数据123添加到elementData[0]
*      ...
*      后续的添加和扩容操作与jdk 7 无异。

*   2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的【饿汉式】，而jdk8中的ArrayList的对象的创建类似于【单例的懒汉式】，【延迟了数组的创建，节省内存】。
*            //【jdk7，调构造器时候，ArrayList就在底层创建了长度是10的数组
*            //jdk8，调构造器时，创建了数组={}，add的时候才让数组的长度变为10】
*            //【jdk8的更好。例如：后台造了个ArrayList，要往里面放数据，数据要在数据库中请求，请求需要时间，7已经造好了，8不提前造，节省内存】

3.LinkedList的源码分析

//jkd7、jkd8无区别
*      LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，
       默认值为null

*      list.add(123);//将123封装到Node中，创建了Node对象。
*
*      其中，Node定义为：体现了LinkedList的双向链表的说法
*      private static class Node<E> {
            E item;
            Node<E> next;
            Node<E> prev;

            Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
            }
        }

4.Vector的源码分析

*      jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
*      在扩容方面，默认扩容为原来的数组长度的2倍。

5.ArrayList、LinkedList、Vector三者的异同

*  同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
*  不同：见上

*  ArrayList和Vector比
*  ArrayList和LinkedList比：
*              ArrayList   LinkedList
*      查找      O(1)        O(n)
*      删除      O(n)        O(1)
*      插入      O(n)        O(1)

6.List接口中的常用方法

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
//【重载Collection接口中的remove(Object obj)。remove可以按照索引删，也可以按照对象删】

Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

//【用数组的地方都可以替换成ArrayList。数组里定义的total相当于ArrayList里的size】

以上的方法都是基于index索引才有的

总结：常用方法：
增：add(Object obj)
//往末尾添加
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
     ② 增强for循环
     ③ 普通的循环
     //【因为有index索引了，所以也可以用普通的for循环】

public class ListTest {


    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("***************");

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }

        System.out.println("***************");

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));//get(index)方法
        }



    }


    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        //【java中index中找不到都返回-1】
        int index = list.indexOf(4567);
        System.out.println(index);

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        //【ArrayList底层是数组，删除后，要把后面的元素往前移】
        Object obj = list.remove(0);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的【左闭右开】区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);


    }


    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);

        //void add(int index, Object ele):在index位置插入ele元素
        //【ArrayList底层是数组，添加前，要把索引后的元素都往后挪，再添加】
        list.add(1,"BB");
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);//【数组转集合】
        list.addAll(list1);
//        list.add(list1);
        //【add(list1)会把list1整体当成一个元素加入list，size = 6+1 = 7。集合类也是Object类】
        System.out.println(list.size());//9 = 6+3

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

    }


}

7.List遍历及方法总结

见6，test3

迭代器、foreach（增强for循环）、普通for循环

六、Set接口

1.Set接口实现类的对比

* 1. Set接口的框架：
*
* |----Collection接口：单列集合，用来存储一个一个的对象
*          |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
*              |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
*                  |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的 顺序遍历
*                  //【这不叫有序，那什么是无序呢？】
*                  对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
*                  //【为频繁操作遍历准备的类】
*
*                  //【LinkedHashSet在HashSet的基础上加了前后的指针，或者说是链表，
*                  效果是看起来"有序"，使得遍历LinkedHashSet的元素时，是按照添加时的顺序来的，就因为加了前后指针。但这个有序是骗人的，因为Set是无序的】
*
*              |----TreeSet：可以按照添加对象的指定属性，进行排序。
*              //底层用二叉树（红黑树）存的
*              //【之前List的实现类和HashSet类都可以随便放不同类型的对象，123，new Person，"haha"】
*              //要求可以排序，所以放入TreeSet的数据必须是同一个类new的。
*              //然后可以按照对象的某些属性排序。
*              //【Comparable、Comparator，然后调Arrays.sort或Collections.sort
*              //这两个接口在TreeSet体现】
*
*              //【为排序做准备的类】
*
*
* //【开发中用List和Map比较多，用Set比较少。Set和后面讲的Map有关，Map讲源码，Set自然懂了】
*
*  1. Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
*  //【List有序，有index索引，增加了很多和索引相关的方法。Set无序，没索引，所以没有新的方法】
*
*  2. 要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
*     要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码
*     //【怎么保持一致性？在hashCode()用到的属性，也要在equals中用】
*      重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。直接alt+shift+s生成最保险最方便

2.Set的无序性和不可重复性的理解

见3，元素添加过程。

以HashSet为例说明：
1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

//无序性并不是指遍历输出和添加时的顺序不同，以HashSet为例，
//【哈希值：hashCode()方法，Object类中的方法】

2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true.即：相同的元素只能添加一个。
//【记得重写equals，和hashCode，仅重写equals，还是判断地址值是否相同】
//【用Set过滤重复数据，用的就是不可重复性】

3.HashSet中元素的添加过程

添加元素的过程：以HashSet为例：
从添加元素的过程理解Set的无序性和不可重复性
//【这个理解有助于后面理解HashMap】
//【TreeSet和HashSet的添加元素过程不一样】

//很容易想到的方法：添加第一个元素，不用equals，因为是空的
//添加第二个元素，和第一个元素equals，false就放入HashSet容器里，true就不放入
//添加第三个元素，和第一个、第二个元素都要equals，false就放入，
//...
//添加第一千个元素（【底层是数组，也会扩容】），和前面999个元素equals，....
//这样效率很低，数越多，要遍历equals的次数也就越多，不靠谱。

//Set不是这样做的，
//7中，一创建Set，数组长度就指定为16了，8中，没有指定。
//它先考虑哈希值，调用所属类的hashCode()算哈希值（所以不止要重写equals还要重写hashCode()），用对象的属性算
//比如哈希值是13462，这个数就决定了对象在数组中的位置，不可能13462是索引，数组没那么长，所以对哈希值操作，算出真正的位置在哪
//假设操作的算法是和16取模，13462 % 16 = 0 ~ 15，取模结果就作为对象存在数组里的位置。

//Set的真实做法：
//1.添加第一个元素，算出哈希值，算出位置值，不用equals
//2.添加第二个元素，算出哈希值，算出位置值，先看位置上有没有元素，没有就直接放上去，不用equals
//3.添加第三个元素，算出哈希值，算出位置值，先看位置上有没有元素，没有就直接放上去，不用equals
//【不用equals比较，这就要求重写hashCode()和equals()时要一致】
//4.添加第四个元素，算出哈希值，算出位置值，先看位置上有没有元素，有元素（比如是第三个元素），
//此时，第三个元素，第四个元素，哈希值不一定一样，只是根据算法算出的位置值一样。比如1 % 16 = 1，17 % 16 = 1。
//如果哈希值不一样，则认为是不同的元素，就不用equals。
//那第四个元素放在哪？以链表的方式存放第三个和第四个元素。
//5.添加第五个元素，算出哈希值，算出位置值，先看位置上有没有元素，有元素（比如是第一个元素），
//而第五个元素和第一个元素的哈希值一样，不能直接说这两个元素一样，此时要用equals判断，
//用第五个元素的equals判断，把第一个元素作为实参传进去，第五个元素.equals(第一个元素)，
//返回值是true，第五个元素就放不进容器了（哈希值一样，equals也一样），
//返回值是false，第五个元素就放进容器了（哈希值一样，但equals不一样），添加成功

//【上面这样做的好处：
//假设现在放第一千个元素：算哈希值，算位置值，位置上没有元素就直接放入，比自己想的方法高效，一个都不用比。
//位置上有元素（此时可能不止一个元素），再长也不会有999个，一个个比完，都不一样，那就存入，
//和某一个一样，那后面的就不用比了，添加失败】

视频总结的：
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
数组此位置上是否已经有元素：
    如果此位置上没有其他元素，则元素a添加成功。 --->添加成功情况1
    如果此位置上有其他元素b(或【以链表形式存在的多个元素】），则比较元素a与元素b的hash值：
        如果hash值不相同，则元素a添加成功。--->添加成功情况2
        如果hash值相同，进而需要调用元素a所在类的equals()方法：
        //【将元素b或以链表形式存在的多个元素通过循环的方式，往equals形参里放】
               equals()返回true,元素a添加失败
               equals()返回false,则元素a添加成功。--->添加成功情况3

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下

【HashSet底层：数组+链表的结构。】

//【添加元素过程：哈希值，算位置值->比哈希值->调equals】

//【以上的对讲HashMap非常有用，因为new HashSet()，其实new了HashMap()
//    public HashSet() {
//        map = new HashMap<>();
//    }
//
//add添加元素，添加到HashMap中了
//    public boolean add(E e) {
//        return map.put(e, PRESENT)==null;
//    }】

* HashMap添加元素过程和HashSet一样。Set底层就是Map
*
* 
*  Set ： HashSet   LinkedHashSet   TreeSet
*  Map ： HashMap   LinkedHashMap   TreeMap
*  new一个HashSet，底层new的是HashMap
*  new一个LinkedHashSet，底层new的是LinkedHashMap
*  new一个TreeSet，底层是TreeMap

Set的无序性理解：

Set的无序性和不可重复性理解：

public class SetTest {

    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);//【添加第一个元素不用比较】
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        //【没重写User的equals和hashCode，遍历时就会有两个Tom，12
        // 没重写hashCode，调的是Object类里的hashCode，
        // public native int hashCode();   native说明调用的是底层的c语言。
        // 可以看作是随机计算哈希值，所以两个User对象哈希值不同，
        // 那算的位置值就不同，第二个User对象就直接放到一个空位置，比都不用比，所以连equals都没调，没输出"User equals()...."】
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


//        Set set = new HashSet();
//        set.add(456);
//        set.add(123);
//        set.add("AA");
//        set.add("CC");
//        set.add(new User("Tom",12));
//        set.add(129);
//
//        Iterator iterator = set.iterator();
//        while(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
        /*
        AA
        CC
        129
        456
        123
        User{name='Tom', age=12}
        输出和加入的顺序不同。【但这不叫无序性，LinkedHashSet遍历和添加时的顺序一样，能说是有序的吗？不能】
        无序性不是随机性
         */

    }

    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个
    //数据和后一个数据。
    //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        /*
        User equals()....
        456
        123
        AA
        CC
        User{name='Tom', age=12}
        129
       // 【遍历和添加时的顺序一样，能说LinkedHashSet是有序的吗？不能。（Set是无序、不可重复的）
       //无序性：指存放到数组位置上，是无序的，不是按顺序一个一个挨着放的。
       //那凭什么LinkedHashSet可以按照添加的顺序遍历？因为有Linked，有链表。课件p40】
         */
    }
}

public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");//【Set：不可重复性。测试Set类的iterator有无调用equals方法】
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        //【String重写过hashCode()，不再是随机计算了】

        result = 31 * result + age;
        return result;
    }
    //return name.hashCode() + age;//【两个对象属性值不一样，哈希值也别一样；属性值一样，则哈希值一样】
    //【用这句话的坏处：
    // 对象a：name的哈希值24，age等于20；对象b：name的哈希值是20，age等于24.两个的属性值不同，
    // 但是最后return的值相同，调equals->false。指针连一下。
    // 也存上去了，但是觉得能少用指针就少用指针
    //
    // result = 31 * result + age;让result乘上一个数再加上age，这样最后结果相同的概率就比较低。
    // 为什么是31？2^5 - 1 = 32
    // 2 << 5 - 1】


    //2.按照姓名从大到小排列--->二级排序：按照姓名从大到小排列，年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if (o instanceof User){
            User user = (User) o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);//【保存compareTo的返回值】
            if (compare != 0){
                return compare;
            }else {
                return Integer.compare(this.age,user.age);//【this.age是int基本数据类型，没有方法】
            }
        }else {
            throw new RuntimeException("输入的类型不匹配");
        }
    }


//    //1.按照姓名从大到小排列
//    @Override
//    public int compareTo(Object o) {
//        if (o instanceof User){
//            User user = (User) o;
//            return -this.name.compareTo(user.name);
//        }else {
//            throw new RuntimeException("输入的类型不匹配");
//        }
//    }
}

4.关于hashCode()和equals()的重写

见3

5.LinkedHashSet的使用

见3

6.TreeSet的自然排序和定制排序

TreeSet的底层：

TreeSet和后面要讲的TreeMap采用红黑树的存储结构

1.向TreeSet中添加的数据，要求是相同类的对象。
2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序（Comparator）

3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0。不再调用equals().
4.定制排序中，比较两个对象是否相同的标准为：compare()返回0。不再是调用equals().

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {

    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        //失败：不能添加【不同类】的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));

            //举例一：
//        set.add(34);//【都是Integer类型】
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);

        /*
        -34
        8
        11
        34
        43
        【按从小到大遍历】
        //【包装类实现了Comparable接口，按照从小到大的顺序比较】
         */

        //举例二：
//        set.add(new User("Tom",12));
//        set.add(new User("Jerry",32));
//        set.add(new User("Jim",2));
//        set.add(new User("Mike",65));
//        set.add(new User("Jack",33));
        //【User没实现Comparable，没重写compareTo时，遍历报异常
        // java.lang.ClassCastException: com.atguigu.java1.User cannot be cast to java.lang.Comparable
        // 也就是说，TreeSet的iterator遍历调用了Comparable的compareTo，或Comparator的compare】


        //【举例三：】
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));
        //【遍历结果：
        /*
        User{name='Tom', age=12}
        User{name='Mike', age=65}
        User{name='Jim', age=2}
        User{name='Jerry', age=32}
        User{name='Jack', age=33}
        */
        // 按照Set的添加过程，new User("Jack",33)和new User("Jack",56)，是不一样的两个元素，
        // 但compareTo 比较这两个对象，是一样的，return了0】
        //【Set里其他的实现类（HashSet和LinkedHashSet）都是用equals比较是否相同，
        // TreeSet用compareTo比较元素是否相同，所以要完善仅用姓名比较的compareTo，
        // 二级排序】


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }

    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(com);
        //【没传Comparator，就把元素用从小到大的逻辑（实现Comparable）放进TreeSet的底层结构红黑树中，
        // 传了Comparator，就用自己写的Comparator逻辑add元素】

        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Mary",33));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

}

七、Map接口

1.Map接口及其多个实现类的对比

* 一、Map的实现类的结构：
*  |----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
*         |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
*         //【和ArrayList一样，即使涉及到多线程问题，也不会因为线程安全而用Hashtable，
*         而是用Collections工具类中的相关方法，把HashMap变成安全的】
*
*              |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
*                      原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和  后一个元素。
*                      对于频繁的遍历操作，此类执行效率高于HashMap。
*
*         |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
*                      //排序是按照key来排的
*                      底层使用红黑树
*                      //和HashMap、LinkedHashMap、Hashtable底层结构不同
*
*         |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
*              |----Properties:常用来处理配置文件。key和value都是String类型

* //出现时间：Hashtable存键值对 -> Map -> HashMap -> TreeMap存有序键值对
*                                       HashMap遍历效率太差 -> LinkedHashMap
* //Vector -> List -> ArrayList -> LinkedList
* //Set -> HashSet -> TreeSet
*                  -> LinkedHashSet
*
*
*      HashMap的底层：数组+链表  （jdk7及之前）
*                    数组+链表+红黑树 （jdk 8）

*  面试题：
*  1. HashMap的底层实现原理？
*  2. HashMap 和 Hashtable的异同？
*  3. CurrentHashMap 与 Hashtable的异同？（暂时不讲）
*  //不论如何，把HashMap用工具类转成安全的之后，同步代码块里面都是单线程的，
*  为了让高并发的时候，执行效率更高，引入CurrentHashMap

transient讲序列化的时候再说

2.对Map中key、value的理解

*  //对Map的key、value的理解：
*    Map中的key:无序的、不可重复的，使用Set存储所有的key  ---> key所在的类要重写equals()和hashCode() （以HashMap为例）
*    //用什么Set存，取决于是什么Map：HashMap就用HashSet存，LinkedHashMap就用LinkedHashSet存
*    //自定义类重写equals()和hashCode()保证存入的数据是不可重复的
*    //如果是TreeMap，就要重写compareTo或compare保证数据不重复
*
*    Map中的value:无序的、可重复的，使用Collection存储所有的value --->value所在的类要重写equals()
*    一个键值对：key-value构成了一个entry对象。
*    //【key、value可以看作是是对象entry的属性】
*
*    Map中的Entry:无序的、不可重复的，使用Set存储所有的Entry

3.HashMap在jdk7中的底层实现原理

HashMap的底层实现原理？以jdk7为例说明：
*      HashMap map = new HashMap():
*      在实例化以后，底层创建了长度是16的一维数组Entry[] table。//put的数据都放在数组中
*      ...可能已经执行过多次put...
*      map.put(key1,value1)://【把key和value放入数组中，怎么放？以下是过程】
*      首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

*      如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
*      //实质上是Entry1添加成功
*
*      如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
*              如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
*              //要和链表上所有的entry比哈希值
*              如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
*                      如果equals()返回false:此时key1-value1添加成功。----情况3
*                      如果equals()返回true:使用value1替换value2。
*                      //【put("Tom",23);   key是Tom，value是23
*                      //put("Tom",45);
*                      //"Tom"和"Tom"的哈希值相同，equals返回true，遍历map结果是Tom 45】

*  //【总结：1.算哈希值 --> 算位置值
*  //2.位置为null，直接添加
*  //3.位置不为null，比哈希值 --> 3.1哈希值不同，添加为链表
*                           --> 3.2哈希值相同，（比地址值）比equals，equals返回false，添加为链表，equals返回true，替换】

*       补充：关于情况2和情况3：此时key1-value1和原来的数据以【链表】的方式存储。
*       //【jdk7源码：】
*       //【void addEntry(int hash, K key, V value, int bucketIndex) {
                if ((size >= threshold) && (null != table[bucketIndex])) {
                resize(2 * table.length);
                hash = (null != key) ? hash(key) : 0;
                bucketIndex = indexFor(hash, table.length);
            }//【这一块逻辑体现的是扩容】

                createEntry(hash, key, value, bucketIndex);//【不扩容，就直接添加】
           }
*
*          void createEntry(int hash, K key, V value, int bucketIndex) {
                Entry<K,V> e = table[bucketIndex];//【①先取出位置上原有的元素，】
                table[bucketIndex] = new Entry<>(hash, key, value, e);
                   //【②new新的Entry，放新添加的元素】
                   //【④把新造的Entry放入位置上】
                size++;
           }

           Entry(int h, K k, V v, Entry<K,V> n) {
                value = v;
                next = n;//【③原有的元素作为当前对象的next】
                key = k;
                hash = h;
           }
       】

*      //【jdk8源码：】
*      //【public V put(K key, V value) {
                return putVal(hash(key), key, value, false, true);
       // }
       //【final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    //        Node<K,V>[] tab; Node<K,V> p; int n, i;
    //        if ((tab = table) == null || (n = tab.length) == 0)
               //【首次put的逻辑】
               //【数组为空，就帮忙造一个数组】
    //            n = (tab = resize()).length;
    //        if ((p = tab[i = (n - 1) & hash]) == null)
    //            tab[i] = newNode(hash, key, value, null);//【算出的位置值上没有元素，直接存放】
    //        else {//【位置上有元素】
    //            Node<K,V> e; K k;
    //            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
                   //【比哈希值：哈希值相等，比地址值，地址值一样就不用比equals了，比equals，返回true】
                   //【这里只是比了位置上第一个元素的哈希值】
    //                e = p;//【把p存到e里，还没有替换】

                   //【能到这来，说明和位置上第一个元素哈希值不等或者哈希值相等equals返回false】
                   //【还要和链表上其他元素比较】
    //            else if (p instanceof TreeNode)
    //                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    //            else {
    //                for (int binCount = 0; ; ++binCount) {
                       //【for循环：位置上可能不止一个元素，可能是链表，所以要和链表上所有的元素比】
    //                    if ((e = p.next) == null) {//【p.next == null，说明这个位置上只有一个元素p】
    //                        p.next = newNode(hash, key, value, null);//【把新造的key-value作为p的next，这就是七上八下的八下】
    //                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st //【这一块是涉及什么时候链表变成红黑树】
                               //【当添加的链表长度超过8时，】
    //                            treeifyBin(tab, hash);//【就把链表变成红黑树】
    //                        break;
    //                    }
                           //【p.next不为null，说明p后面还有元素】
                           //【和链表上所有的Node比较哈希值，比较地址值，比较equals】
    //                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
    //                        break;//【哈希值一样，equals一样，就break跳出循环，去下面替换】
    //                    p = e;//【就可以变成下一个元素，循环继续，继续往下进行比较】
    //                }
    //            }

                   //【替换】
    //            if (e != null) { // existing mapping for key
    //                V oldValue = e.value;
    //                if (!onlyIfAbsent || oldValue == null)
    //                    e.value = value;
    //                afterNodeAccess(e);
    //                return oldValue;
    //            }
    //        }
    //        ++modCount;
    //        if (++size > threshold)
    //            resize();
    //        afterNodeInsertion(evict);
    //        return null;
//    }】

   final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
           resize();//【数组长度<64，不把链表变成树，而是扩容数组，因为树结构还是比数组复杂的，直接扩容更方便】
        else if ((e = tab[index = (n - 1) & hash]) != null) {
           TreeNode<K,V> hd = null, tl = null;
           do {
               TreeNode<K,V> p = replacementTreeNode(e, null);
               if (tl == null)
                   hd = p;
               else {
                   p.prev = tl;
                   tl.next = p;
               }
               tl = p;
           } while ((e = e.next) != null);
           if ((tab[index] = hd) != null)
               hd.treeify(tab);
        }
   }
*

*      在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置【非空】)时，扩容。
*      默认的扩容方式：扩容为原来容量的【2倍】，并将原有的数据【复制】过来。
*      //【扩容完后，重新计算在新数组中的位置值，有可能原来是链表，重新计算后就不在同一个位置了】

*
*      【jdk8 相较于jdk7在底层实现方面的不同：】
*      1. new HashMap():底层没有创建一个长度为16的数组
*      2. jdk 8底层的数组是：Node[],而非Entry[]
*      3. 首次调用put()方法时，底层创建长度为16的数组
*      4. jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+【红黑树】。
*         4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
          4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
*
*      DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
*      DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
*      //【ArrayList底层一开始容量是10，存前十个元素都不会扩容，到第11个才扩容
*      //HashMap底层一开始是16，不是到第17个才扩容，而是【提前扩容】
*      //为什么要提前扩容，不能满了再扩吗？它一定会满吗？怎样才叫满？
*      //因为位置值是通过哈希值算的，而且还有链表，有些位置可能始终都不会有元素。
*      //提前扩容：让数组里出现链表的情况尽可能少
*      //想让链表出现的少，让加载因子尽可能小
*      //假设加载因子=0.3，16x0.3=4.8，超过4个就要扩容，对数组的利用率就低了，所以太小也不好，
*      //太大了，链表就多了，也不太好。
*      //大量测试0.75兼并了对数组利用率高+链表少】
*
*      threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
*      //【扩容和threshold有关，扩容不是等到快装满了才扩容】
*
*      TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
*      MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

4.HashMap在jdk8中的底层实现原理

见3

jdk7：数组+链表

jdk8：数组+链表+红黑树

5.HashMap在jdk7中的源码分析

见3

6.HashMap在jdk8中的源码分析

见3

7.LinkedHashMap的底层实现

*  //【LinkedHashMap是HashMap的子类，底层使用的结构和HashMap相同，LinkedHashMap存储时还是用HashMap里定义的数组】
*  //【区别在于LinkedHashMap内部定义了一个Entry，替换了HashMap中的Node】
*  //【LinkedHashMap可以按照添加的顺序遍历】
*  //【把LinkedHashMap底层实现原理搞明白了，LinkedHashSet也就懂了】
* //【LinkedHashMap里的添加方法，用的是父类的，put调putVal
* final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)，
* 但它有自己重写的newNode
*     Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }】

*      源码中：
*      static class Entry<K,V> extends HashMap.Node<K,V> {
            Entry<K,V> before, after;//【能够记录添加的元素的先后顺序】
            Entry(int hash, K key, V value, Node<K,V> next) {
               super(hash, key, value, next);
            }
        }

* 【HashSet与HashMap
* 1.new一个HashSet，本质是new一个HashMap
*     public HashSet() {
        map = new HashMap<>();
      }
 2.向HashSet中add元素时，相当于把元素放入Map。
   放入Set中的数据相当于Map中的key，
   Map中的value是PRESENT，private static final Object PRESENT = new Object();一个static final常量，不是null
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
】

8.Map中的常用方法1

添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

9.Map中的常用方法2

    元视图操作的方法：
   //【Map的遍历：如何遍历Map的key、value、key和value】
   //【Collection的遍历：迭代器、foreach、普通for循环。Map没有迭代器】
   //【Map是由key和value构成的，所有的key是一个Set，拿到所有的key构成的Set，用Set的迭代器就行了，
   //拿到所有的value构成的Collection，用Collection的迭代器就行了
   //键值对整体构成一个Set，拿到所有键值对构成的Set】
    Set keySet()：返回所有key构成的Set集合
    Collection values()：返回所有value构成的Collection集合
    Set entrySet()：返回所有key-value对构成的Set集合

//【遍历并不是为了看Map里的元素，如果仅仅是为了看，直接System.out.println(map);
//用户注册，要填很多信息，name-编辑框、age-编辑框、学历-编辑框等等，
//name、age、学历都可以作为key，编辑框填的内容就是value。
//填完后，把数据发送到后台，后台用Map装，Map里面都是键值对，
//把Map数据装入数据库，数据库有很多字段：name、age、学历，
//把Map中每一个key和value取出放入数据库，一个一个取的过程就是遍历。
//把数据在后台，把数据转化为JSON呈现到浏览器】

*总结：常用方法：
* 添加：put(Object key,Object value)
* 删除：remove(Object key)
* 修改：put(Object key,Object value)
* 查询：get(Object key)
* 长度：size()
* 遍历：keySet() / values() / entrySet()

public class MapTest {

    /*
 元视图操作的方法：
 Set keySet()：返回所有key构成的Set集合
 Collection values()：返回所有value构成的Collection集合
 Set entrySet()：返回所有key-value对构成的Set集合

     */


    @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        /*
        AA
        BB
        45

        123
        56
        1234
         */
        System.out.println();



        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();//【obj就是一个一个的entry】
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
        System.out.println();
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);

        }

    }


    /*
 元素查询的操作：
 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等
 //【要想结果为true，obj也必须是Map，且内容一样】
     */
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        // Object get(Object key)
        System.out.println(map.get(45));
        //containsKey(Object key)
        boolean isExist = map.containsKey("BB");//【判断哈希值->判断equals】
        System.out.println(isExist);

        isExist = map.containsValue(123);//【有两个123，找到是true就不会再往下找了】
        System.out.println(isExist);

        map.clear();

        System.out.println(map.isEmpty());

    }

    /*
     添加、删除、修改操作：
 Object put(Object key,Object value)：将指定key-value添加到(或【修改】)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key)：移除指定key的key-value对，并返回value
 void clear()：清空当前map中的所有数据
     */
    @Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);//【实际开发中，key的类型是统一的，value的类型是统一的。到泛型再讲。key是String的情况比较多。】
        map.put(45,123);
        map.put("BB",56);
        //【修改/替换】
        //【"AA"哈希值相同，value不同，修改】
        map.put("AA",87);//【Map算哈希值，是算key的哈希值】

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);

        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();//与map = null操作不同
        //【是让Map里的元素都为null，而不是让Map指向null】
        System.out.println(map.size());//【不会空指针异常】//0
        System.out.println(map);//【{}】
    }

//    LinkedHashMap可以按照添加的顺序遍历，能记录添加的顺序
    @Test
    public void test2(){
        Map map = new HashMap();
        map = new LinkedHashMap();
        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");

        System.out.println(map);
    }


    @Test
    public void test1(){
        Map map = new HashMap();
//        map = new Hashtable();
        map.put(null,123);
        //【HashMap能存null的应用场景：
        // 在浏览器登录账号name，密码password，点登录，
        // 数据保存在map中，怎么保存？
        // 两个键值对。
        //                  key         value
        // 第一个键值对：    name         小明
        // 第二个键值对：    password     1234567，
        //然后在数据库中校验
        // 如果用户忘了写，那value就是null，在Hashtable中就会导致空指针异常】
    }
}

10.TreeMap的两种添加方式

public class TreeMapTest {

    //向TreeMap中添加key-value，要求key必须是由【同一个类】创建的对象
    //因为要【按照key进行排序】：自然排序 、定制排序
    //【不能按照value排序】
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);//【开发中，key、value一般都是固定类型，讲泛型再强调这件事】
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配！");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }


}

public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }
}

11.Properties处理属性文件

public class PropertiesTest {

    //Properties:常用来处理配置文件。【key和value都是String类型】
    //【配置文件：物理上存在的文件。用Properties把配置文件读到内存中
    // 比如修改了idea的配置信息，怎么在idea运行中体现这些修改了？idea的指令读配置文件。
    // java中，用Properties读配置文件】

    //【idea配置文件，默认在工程下，右键new File(name写jdbc.properties)
    // 或Resource Bundle(写jdbc，自动补充.properties)，
    // （后面讲java操作数据库的技术，就是jdbc）。
    // jdbc.properties写name不要name = Tom，会认为name是" Tom"而不是"Tom"】
    public static void main(String[] args)  {
        FileInputStream fis = null;
        try {
            Properties pros = new Properties();

            fis = new FileInputStream("jdbc.properties");//【流要有关闭操作】
            pros.load(fis);//加载【流】对应的文件

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");

            System.out.println("name = " + name + ", password = " + password);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

12.Collections工具类常用方法

* xxx
* xxxs：工具类；xxx不能造对象，通过xxxs调方法返回一个xxx类型的对象；
* xxx Factory调方法返回一个xxx类型的对象

* Collections:操作Collection、【Map】的工具类

/*
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
//【    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
            int srcSize = src.size();
            if (srcSize > dest.size())
                throw new IndexOutOfBoundsException("Source does not fit in dest");

            if (srcSize < COPY_THRESHOLD || (src instanceof RandomAccess && dest instanceof RandomAccess)) {
            for (int i=0; i<srcSize; i++)
                dest.set(i, src.get(i));
            } else {
                ListIterator<? super T> di=dest.listIterator();
                ListIterator<? extends T> si=src.listIterator();
                for (int i=0; i<srcSize; i++) {
                    di.next();
                    di.set(si.next());
                }
            }
       }】
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

 */

public class CollectionsTest {


        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);


    }

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(765);
        list.add(765);
        list.add(-97);
        list.add(0);

        System.out.println(list);

//        Collections.reverse(list);
//        Collections.shuffle(list);
//        Collections.sort(list);
//        Collections.swap(list,1,2);
        int frequency = Collections.frequency(list, 123);

        System.out.println(list);
        System.out.println(frequency);

    }

}