Java学习路线：day23 集合

绝地灬酷狼 2023-03-13 12:19 2阅读 0赞

### 文章目录 ###

*  转载自atguigu.com视频
 *  第11章Java集合
 *   *  Java 集合框架概述
     *   *  集合框架与数组的对比及概述
         *  集合框架涉及到的API
     *  Collection接口方法
     *   *  Collection接口中的常用方法1
         *  Collection接口中的常用方法2
         *  Collection接口中的常用方法3
         *  Collection接口中的常用方法4
     *  Iterator迭代器接口
     *   *  使用Iterator遍历Collection
         *  迭代器Iterator的执行原理
         *  Iterator遍历集合的两种错误写法
         *  Iterator迭代器remove()的使用
         *  新特性foreach循环遍历集合或数组
     *  Collection子接口之一：List接口
     *   *  List接口常用实现类的对比
         *  ArrayList的源码分析
         *  LinkedList的源码分析
         *  Vector的源码分析
         *  List接口中的常用方法测试
         *  List的一个面试小题

> 全部源码：https://github.com/name365/JavaSE-30Day

# 转载自atguigu.com视频 #

# 第11章Java集合 #

## Java 集合框架概述 ##

### 集合框架与数组的对比及概述 ###

/** * 一、集合的框架 * * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 * 说明；此时的存储，主要是指能存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中） * * 2.1数组在存储多个数据封面的特点： * 》一旦初始化以后，它的长度就确定了。 * 》数组一旦定义好，它的数据类型也就确定了。我们就只能操作指定类型的数据了。 * 比如：String[] arr;int[] str; * 2.2数组在存储多个数据方面的特点： * 》一旦初始化以后，其长度就不可修改。 * 》数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。 * 》获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用 * 》数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。 * * @author subei * @create 2020-05-11 16:23 */

*  集合的使用场景

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]

### 集合框架涉及到的API ###

*  Java 集合可分为Collection 和Map 两种体系
    
     *  Collection接口：单列数据，定义了存取一组对象的方法的集合
        
         *  List：元素有序、可重复的集合
         *  Set：元素无序、不可重复的集合
     *  Map接口：双列数据，保存具有映射关系“key-value对”的集合
 *  **Collection接口继承树**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]

*  **Map接口继承树**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]

/** * * 二、集合框架 * &---Collection接口：单列集合，用来存储一个一个的对象 * &---List接口：存储有序的、可重复的数据。 -->“动态”数组 * &---ArrayList、LinkedList、Vector * * &---Set接口：存储无序的、不可重复的数据 -->高中讲的“集合” * &---HashSet、LinkedHashSet、TreeSet * * &---Map接口：双列集合，用来存储一对(key - value)一对的数据 -->高中函数：y = f(x) * &---HashMap、LinkedHashMap、TreeMap、Hashtable、Properties * * @author subei * @create 2020-05-11 16:23 */

## Collection接口方法 ##

*  Collection 接口是List、Set 和Queue 接口的父接口，该接口里定义的方法既可用于操作Set 集合，也可用于操作List 和Queue 集合。
 *  JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
 *  在Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成Object 类型处理；从JDK 5.0 增加了**泛型**以后，Java 集合可以记住容器中对象的数据类型。

### Collection接口中的常用方法1 ###

1.  添加
    
     *  add(Objectobj)
     *  addAll(Collectioncoll)
2.  获取有效元素的个数
    
     *  intsize()
3.  清空集合
    
     *  voidclear()
4.  是否是空集合
    
     *  boolean isEmpty()
5.  是否包含某个元素
    
     *  booleancontains(Objectobj)：是通过元素的equals方法来判断是否是同一个对象
     *  booleancontainsAll(Collectionc)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
6.  删除
    
     *  boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
     *  boolean removeAll(Collection coll)：取当前集合的差集
7.  取两个集合的交集
    
     *  boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c
8.  集合是否相等
    
     *  boolean equals(Object obj)
9.  转成对象数组
    
     *  Object\[\] toArray()
10. 获取集合对象的哈希值
    
     *  hashCode()
11. 遍历
    
     *  iterator()：返回迭代器对象，用于集合遍历

import org.junit.Test;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    
    /**
     *
     * 三、Collection接口中的方法的使用
     *
     *
     *
     * @author subei
     * @create 2020-05-11 16:23
     */
    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);
    
            //clear():清空集合元素
            coll.clear();
    
            //isEmpty():判断当前集合是否为空
            System.out.println(coll.isEmpty());
        }
    }

### Collection接口中的常用方法2 ###

*  Person类

import java.util.Objects;
    
    /** * @author subei * @create 2020-05-12 10:11 */
    public class Person { 
    
        private String name;
        private int age;
    
        public Person() { 
            super();
        }
    
        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()....");
            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);
        }
    }

*  测试类

### Collection接口中的常用方法3 ###

*  Person类

*  测试类

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    
    /** * Collection接口中声明的方法的测试 * * 结论： * 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals(). * * @author subei * @create 2020-05-12 10:06 */
    public class CollectinoTest { 
    
        @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);
            System.out.println(coll);
    
            coll.remove(new Person("Jerry",20));
            System.out.println(coll);
    
            //4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
            Collection coll1 = Arrays.asList(123,456);
            coll.removeAll(coll1);
            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);
    
            //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
            Collection coll1 = new ArrayList();
            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));
        }
    
    }

### Collection接口中的常用方法4 ###

*  Person类

*  测试类

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    
    /** * Collection接口中声明的方法的测试 * * 结论： * 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals(). * * @author subei * @create 2020-05-12 10:06 */
    public class CollectinoTest { 
    
        @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():返回当前对象的哈希值
            System.out.println(coll.hashCode());
    
            //8.集合 --->数组：toArray()
            Object[] arr = coll.toArray();
            for(int i = 0;i < arr.length;i++){ 
                System.out.println(arr[i]);
            }
    
            //拓展：数组 --->集合:调用Arrays类的静态方法asList()
            List<String> list = Arrays.asList(new String[]{ "AA", "BB", "CC"});
            System.out.println(list);
    
            List arr1 = Arrays.asList(123, 456);
            System.out.println(arr1);//[123, 456]
    
            List arr2 = Arrays.asList(new int[]{ 123, 456});
            System.out.println(arr2.size());//1
    
            List arr3 = Arrays.asList(new Integer[]{ 123, 456});
            System.out.println(arr3.size());//2
    
            //9.iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
        }
    }

## Iterator迭代器接口 ##

*  Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection 集合中的元素。
 *  GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。**迭代器模式，就是为容器而生**。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
 *  Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
 *  **Iterator 仅用于遍历集合**，Iterator本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
 *  **集合对象每次调用iterator()方法都得到一个全新的迭代器对象**，默认游标都在集合的第一个元素之前。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]

### 使用Iterator遍历Collection ###

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /** * 集合元素的遍历操作，使用迭代器Iterator接口 * 内部的方法：hasNext()和 next() * * @author subei * @create 2020-05-12 12:22 */
    public class IteratorTest { 
    
        @Test
        public void test(){ 
            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();
    
            //方式一：
    // 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
    // //因为：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
    // System.out.println(iterator.next());
    
            //方式二：不推荐
    // for(int i = 0;i < coll.size();i++){ 
    // System.out.println(iterator.next());
    // }
    
            //方式三：推荐
            while(iterator.hasNext()){ 
                System.out.println(iterator.next());
            }
        }
    }

### 迭代器Iterator的执行原理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]

### Iterator遍历集合的两种错误写法 ###

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /** * 集合元素的遍历操作，使用迭代器Iterator接口 * 1.内部的方法：hasNext()和 next() * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。 * * @author subei * @create 2020-05-12 12:22 */
    public class IteratorTest { 
    
        @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());
            }
        }
    }

### Iterator迭代器remove()的使用 ###

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /** * 集合元素的遍历操作，使用迭代器Iterator接口 * 1.内部的方法：hasNext()和 next() * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。 * 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove() * * @author subei * @create 2020-05-12 12:22 */
    public class IteratorTest { 
    
        //测试Iterator中的remove()方法
        @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”
            //如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
            // 再调用remove都会报IllegalStateException。
            Iterator iterator = coll.iterator();
            while(iterator.hasNext()){ 
    // iterator.remove();
                Object obj = iterator.next();
                if("Tom".equals(obj)){ 
                    iterator.remove();
    // iterator.remove(); 
                }
            }
    
            //遍历集合
            iterator = coll.iterator();
            while(iterator.hasNext()){ 
                System.out.println(iterator.next());
            }
    
        }
    }

*  注意：
    
     *  Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
     *  **如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException**。

### 新特性foreach循环遍历集合或数组 ###

*  Java 5.0 提供了foreach循环迭代访问Collection和数组。
 *  遍历操作不需获取Collection或数组的长度，无需使用索引访问元素。
 *  遍历集合的底层调用Iterator完成操作。
 *  foreach还可以用来遍历数组。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /** * jdk 5.0 新增了foreach循环，用于遍历集合、数组 * * @author subei * @create 2020-05-12 16:08 */
    public class ForTest { 
    
        @Test
        public void test(){ 
            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 obj : coll){ 
                System.out.println(obj);
            }
        }
    
        @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[]{ "SS","KK","RR"};
    
    // //方式一：普通for赋值
    // for(int i = 0;i < arr.length;i++){ 
    // arr[i] = "HH";
    // }
    
            //方式二：增强for循环
            for(String s : arr){ 
                s = "HH";
            }
    
            for(int i = 0;i < arr.length;i++){ 
                System.out.println(arr[i]);
            }
        }
    }

## Collection子接口之一：List接口 ##

*  鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
 *  List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
 *  List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
 *  JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

### List接口常用实现类的对比 ###

/** * 1. List接口框架 * * |----Collection接口：单列集合，用来存储一个一个的对象 * |----List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组 * |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储 * |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储 * |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储 * * * 面试题：比较ArrayList、LinkedList、Vector三者的异同？ * 同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据 * 不同：见上 * * @author subei * @create 2020-05-12 20:54 */

### ArrayList的源码分析 ###

*  ArrayList是List 接口的典型实现类、主要实现类
 *  本质上，ArrayList是对象引用的一个”变长”数组

>     /** * 2.ArrayList的源码分析： * 2.1 jdk 7情况下 * ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData * 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的对象 * 的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。 * */

### LinkedList的源码分析 ###

*  对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
 *  LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]

>     /** * 3.LinkedList的源码分析： * 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; //next变量记录下一个元素的位置 * this.prev = prev; //prev变量记录前一个元素的位置 * } * } */

### Vector的源码分析 ###

*  Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。
 *  在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

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

### List接口中的常用方法测试 ###

*  List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法。
    
     *  void add(intindex, 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位置的子集合

import org.junit.Test;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Iterator;
    import java.util.List;
    
    /** * * 5.List接口的常用方法 * * * @author subei * @create 2020-05-12 20:54 */
    public class ListTest { 
        /** * * 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) * 改：set(int index, Object ele) * 查：get(int index) * 插：add(int index, Object ele) * 长度：size() * 遍历：① Iterator迭代器方式 * ② 增强for循环 * ③ 普通的循环 * */
    
        @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 tets2(){ 
            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(4567);
            System.out.println(index);
    
            //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
            System.out.println(list.lastIndexOf(456));
    
            //Object remove(int index):移除指定index位置的元素，并返回此元素
            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 test(){ 
            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元素
            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);
            System.out.println(list.size());//9
    
            //Object get(int index):获取指定index位置的元素
            System.out.println(list.get(2));
    
        }
    }

### List的一个面试小题 ###

*  面试题1

> 请问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ArrayList底层是什么？扩容机制？Vector和ArrayList的最大区别?

/** * 请问ArrayList/LinkedList/Vector的异同？谈谈你的理解？ * ArrayList底层是什么？扩容机制？Vector和ArrayList的最大区别? * * ArrayList和LinkedList的异同二者都线程不安全，相对线程安全的Vector，执行效率高。 * 此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 * 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 * 对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。 * * ArrayList和Vector的区别Vector和ArrayList几乎是完全相同的, * 唯一的区别在于Vector是同步类(synchronized)，属于强同步类。 * 因此开销就比ArrayList要大，访问要慢。正常情况下, * 大多数的Java程序员使用ArrayList而不是Vector, * 因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间， * 而ArrayList是1.5倍。Vector还有一个子类Stack。 */

*  面试题2

import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author subei * @create 2020-05-12 23:07 */
    public class ListEver { 
        /** * 区分List中remove(int index)和remove(Object obj) */
    
        @Test
        public void testListRemove() { 
            List list = new ArrayList();
            list.add(1);
            list.add(2);
            list.add(3);
            updateList(list);
            System.out.println(list);//
        }
    
        private void updateList(List list) { 
    // list.remove(2);
            list.remove(new Integer(2));
        }
    }

> 整个Java全栈系列都是笔者自己敲的笔记。写作不易，如果可以，点个赞呗！✌

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20230312/133f194183d34ba5bd828d373ea4fa28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230312/88daa49e64884d6aae1c21b31f4ddfe3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200513101242452.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200513101251295.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200513101321850.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200513101331340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20200513101342457.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20200513101354248.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2MTUzOTQ5,size_16,color_FFFFFF,t_70#pic_center