尚硅谷-集合笔记3

package com.atgugui.java;

import org.junit.Test;

import java.util.*;

/**
 ** 1. /----Collection接口：单列集合，用来存储一个一个的对象
 *       /---List接口(JDK1.2)：存储有序的，可重复的数据。  -->“动态”数组，替换原有的数组（因为原来的数组一旦确定长度不可变化，这个不确定长度直接添加元素即可）
 *           /---ArrayList(JDK1.2)：作为List接口的主要实现类,线程不安全，效率高；底层使用Object[] elementData数组
 *           /---LinkedList(JDK1.2)：对于频繁的插入、删除操作，使用此类比Array list高；底层使用的是双向链表存储
 *           /---Vector(JDK1.0)：作为List接口的古老实现类，线程安全的，效率低；底层使用Object[] elementData数组
 *
 *
 *2. ArrayList的源码分析：
 * 2.1 JDK 7 情况下：
 *    ArrayList list=new ArrayList();//底层创建了长度是10的Object[] 数组elementDate
 *    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]
 *    ...
 *    后续的添加和扩容操作与JDK7 无异。
 *2.3 小结：
 *    jdk 7中的ArrayList的对象的创建类似于单例模式的饿汉式，而JDK8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
 *
 *
 *
 * 3. LinkedList的源码分析：
 *    LinkedList list=new LisnkedList();内部声明了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倍。
 *
 *     面试题：ArrayList、LinkedList、Vector三者的异同？
 *     同：这三个类都实现了List接口，存储数据的特点形同：存储有序的、可重复的数据
 *     不同点：上面！！
 * 5. 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位置的元素，并返回此元素
 * Object set(int index, Object ele):设置指定index位置的元素为ele
 * List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
 *
 * 常用方法总结：
 * 增：add(Object obj)
 * 删：remove(int index):自己定义 / remove(Object obj)Collection集合中的
 * 改：set(int index,Object ele)
 * 查：get(int index)
 * 插：add(int index,Object ele)
 * 长度：size()
 * 遍历：①Iterator迭代器；②增强for循环；③普通循环（用索引）
 *
 *
 * @author WZ
 * @create 2021-06-24 22:48
 */
public class ListTest {

    /*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位置的元素，并返回此元素
   Object set(int index, Object ele):设置指定index位置的元素为ele
   List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
     */
    @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));
        }


    }
    @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
        int index = list.indexOf(456);
        System.out.println(index);//若有，返回相应的位置，若没有则返回-1；

        //方法五：int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置；如果不存在返回-1
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);//4

        //方法六：Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);//把第一个元素给删除，这个是用的索引位置删除，还有直接删除里面的元素方法。所以remove有两个特别注意！！！
        System.out.println(obj);//123；删除之后后面的往前移
        System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456]

        //方法七：Object set(int index, Object ele):设置指定index位置的元素为ele,并返回此元素
        list.set(1, "CC");//和上面remove一样，并返回此元素
        System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]

        //方法八：List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合；（左闭右开区间）

        List list1 = list.subList(2, 4);
        List list2 = list.subList(1, 3);
        System.out.println(list1);
        System.out.println(list2);


    }

    @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);//[123, 456, AA, Person{name='Tom', age=12}, 456] ;调用了内部重写的toString方法

        //方法1：void add(int index, Object ele):在index位置插入ele元素
        list.add(1,789);//一个一个往后移。789插入到1的位置
        System.out.println(list);//[123, 789, 456, AA, Person{name='Tom', age=12}, 456]

        //方法2：boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        boolean  b = list.addAll(list1);//没有指定索引位置的话默认在最后面添加
        System.out.println(b);//true
        //list.add(list1);//这个也不报错，但是这个是把上面的1，2，3 当成一个元素来进行添加了
        System.out.println(list.size());//9
        System.out.println(list);//[123, 789, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]

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


    }






}

3.1增强for循环

package com.atgugui.java;

import org.junit.Test;

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

/**
 * JDK 5.0 新增了foreach循环，用于遍历集合、数组
 *
 * @author WZ
 * @create 2021-06-24 22:09
 */
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(集合中元素的类型 局部变量：集合对象)---集和对象（coll)的元素就是object类型，所以前面是Object，类型得一致
        //其实内部调用的还是迭代器iterator 只是形式上是这样写的
        for (Object obj : coll) {// coll 会自动的取第一个元素，然后赋值给 obj这个类型的变量，然后打印obj,然后再去coll中的第二个元素。。。。。。。等等

            System.out.println(obj);
        }


    }

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

        }
    }

    @Test
    public void test3() {
        String[] arr = new String[]{"MM", "MM", "MM"};
        //方式一：普通for赋值
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = "GG";
//            System.out.println(arr[i]);//GG----这种方式是拿着数组的本身的元素做修改
//        }

        //方式二：增强for循环
        for (String s : arr) {
            s="GG";
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//MM---这个只是把值赋值给s，s把值给改了，但是数组本身是不变的
        }


    }

}

3.2迭代器interator

package com.atgugui.java;

import org.junit.Test;

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

/**
 * 集合元素的遍历操作，使用迭代器Interator接口
 * 1.内部的方法：hasNext() 和 next()
 * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
 * 3.内部定义了remove()方法，可以在遍历的时候删除集合中的元素。此方法不同于集合直接调用remove()
 * @author WZ
 * @create 2021-06-22 21:23
 */
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对象的时候可以理解为当前就有一个指针指在第一个添加值的上面，这里就是指在123的上面但是没有指着123
        //当调用iterator.next()方法时，先指针下移指着第一个元素（123），然后把下移以后的元素（123）返回；依次循环直到元素调完为止。

        //方式一：开发中不用
//        System.out.println(iterator.next());//123
//        System.out.println(iterator.next());//456
//        System.out.println(iterator.next());//Person{name='Jerry', age=20}
//        System.out.println(iterator.next());//Tom
//        System.out.println(iterator.next());//false

//        System.out.println(iterator.next());//NoSuchElementException 没有这个元素，就报异常，相当于数组的角标越界

        //方式二：使用for循环+interator.next(); 开发中也不推荐这样写
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }
        //方式三：推荐 使用iterator.hasNext() 与 iterator.Next() 这两个分别搭配使用
        while (iterator.hasNext()) {         //iterator.hasNext()调用这个方法表示判断iterator里面是否还有元素，有元素就进去，没有元素就不进去。
            //next():a.指针下移；b.将下移以后的集合位置上的元素返回
            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());//结果会跳着输出
//        }
        //错误方式二：只要一进循环都会返回一个新的迭代器的对象，所以相当于每次指针都是复位。
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()) {
            System.out.println(coll.iterator().next());//123死循环，因为每调用一次iterator()方法就会返回一个新的迭代器iterator对象，在这里相当于指针复位。
        }

    }

    //测试Iterator中的remove()
    //如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException,remove跟着next指针走
    @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();
            if ("Tom".equals(obj)) {
                iterator.remove();
//                iterator.remove();出错，现在指针指着的是已经删除的元素，现在也么有元素。
            }
        }

        //遍历集合中的元素
        Iterator iterator1 = coll.iterator();//特别注意：不能拿上面的iterator进行再次遍历因为上面的指针已经指到最后一个了。所以得重新造一个
        //iterator = coll.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());//输出的结果没有Tom
        }
    }
}

3.3List

package com.atgugui.java;

import org.junit.Test;

import java.util.*;

/**
 ** 1. /----Collection接口：单列集合，用来存储一个一个的对象
 *       /---List接口(JDK1.2)：存储有序的，可重复的数据。  -->“动态”数组，替换原有的数组（因为原来的数组一旦确定长度不可变化，这个不确定长度直接添加元素即可）
 *           /---ArrayList(JDK1.2)：作为List接口的主要实现类,线程不安全，效率高；底层使用Object[] elementData数组
 *           /---LinkedList(JDK1.2)：对于频繁的插入、删除操作，使用此类比Array list高；底层使用的是双向链表存储
 *           /---Vector(JDK1.0)：作为List接口的古老实现类，线程安全的，效率低；底层使用Object[] elementData数组
 *
 *
 *2. ArrayList的源码分析：
 * 2.1 JDK 7 情况下：
 *    ArrayList list=new ArrayList();//底层创建了长度是10的Object[] 数组elementDate
 *    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]
 *    ...
 *    后续的添加和扩容操作与JDK7 无异。
 *2.3 小结：
 *    jdk 7中的ArrayList的对象的创建类似于单例模式的饿汉式，而JDK8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
 *
 *
 *
 * 3. LinkedList的源码分析：
 *    LinkedList list=new LisnkedList();内部声明了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倍。
 *
 *     面试题：ArrayList、LinkedList、Vector三者的异同？
 *     同：这三个类都实现了List接口，存储数据的特点形同：存储有序的、可重复的数据
 *     不同点：上面！！
 * 5. 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位置的元素，并返回此元素
 * Object set(int index, Object ele):设置指定index位置的元素为ele
 * List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
 *
 * 常用方法总结：
 * 增：add(Object obj)
 * 删：remove(int index):自己定义 / remove(Object obj)Collection集合中的
 * 改：set(int index,Object ele)
 * 查：get(int index)
 * 插：add(int index,Object ele)
 * 长度：size()
 * 遍历：①Iterator迭代器；②增强for循环；③普通循环（用索引）
 *
 *
 * @author WZ
 * @create 2021-06-24 22:48
 */
public class ListTest {

    /*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位置的元素，并返回此元素
   Object set(int index, Object ele):设置指定index位置的元素为ele
   List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
     */
    @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));
        }


    }
    @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
        int index = list.indexOf(456);
        System.out.println(index);//若有，返回相应的位置，若没有则返回-1；

        //方法五：int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置；如果不存在返回-1
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);//4

        //方法六：Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);//把第一个元素给删除，这个是用的索引位置删除，还有直接删除里面的元素方法。所以remove有两个特别注意！！！
        System.out.println(obj);//123；删除之后后面的往前移
        System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456]

        //方法七：Object set(int index, Object ele):设置指定index位置的元素为ele,并返回此元素
        list.set(1, "CC");//和上面remove一样，并返回此元素
        System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]

        //方法八：List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合；（左闭右开区间）

        List list1 = list.subList(2, 4);
        List list2 = list.subList(1, 3);
        System.out.println(list1);
        System.out.println(list2);


    }

    @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);//[123, 456, AA, Person{name='Tom', age=12}, 456] ;调用了内部重写的toString方法

        //方法1：void add(int index, Object ele):在index位置插入ele元素
        list.add(1,789);//一个一个往后移。789插入到1的位置
        System.out.println(list);//[123, 789, 456, AA, Person{name='Tom', age=12}, 456]

        //方法2：boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        boolean  b = list.addAll(list1);//没有指定索引位置的话默认在最后面添加
        System.out.println(b);//true
        //list.add(list1);//这个也不报错，但是这个是把上面的1，2，3 当成一个元素来进行添加了
        System.out.println(list.size());//9
        System.out.println(list);//[123, 789, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]

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


    }






}

3.4Person

package com.atgugui.java;

import java.util.Objects;

/**
 * @author WZ
 * @create 2021-06-20 17:48
 */
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 int getAge() {
        return age;
    }

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

    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()...");
        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);
    }
}