集合恍然大明白

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

二、集合框架结构

|----Collection接口：单列集合，用来存储一个一个的对象。

　　|----List接口：存储有序的、可重复的数据。       “动态”数组。

　　　　|----ArrayList、LinkedList、Vector

　　|----Set接口：存储无序的、不可重复的数据。      类似高中学的“集合”，无序性、确定性、互异行

　　　　|----HashSet、LinkedHashSet、TreeSet

|----Map接口：双列集合，用来存储一对一对(key - value)的数据      类似高中学的函数：y = f(x) y相当于value，一个key不能对应多个value，一个value可以对应多个ket

　　　　|----HashMap、LinkedHashMachinep、TreeMap、Hashtable、Properties

三、Collection接口中的方法的使用

15个abstract方法一一展示

public class CollectionTest {

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

        //1.add(Object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add("123");
        coll.add(new Date());

        //2.size()
        System.out.println(coll.size());//4

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

        //4.clear():清空集合元素
        coll1.clear();

        //5.isEmpty():判断当前集合是否为空
        System.out.println(coll1.size());
        System.out.println(coll1.isEmpty());

    }

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

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


        //contains(Object obj):判断当前集合是否包含obj
        //在判断时，会去调用obj所在类的equals方法。通常要求自定义类重写equals方法。
        boolean contains = coll.contains(123); //true
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));//true 判断的是内容
        //System.out.println(coll.contains(p));
        System.out.println(coll.contains(new Person("Jerry",20))); //对比的是equals方法

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

    }

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

        boolean remove = coll.remove(1234);
        System.out.println(remove);
        System.out.println(coll);

        coll.remove(new Person("Jerry",20));
        System.out.println(coll);

        //4.removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素【相当于移除共有的，取差集】
        Collection coll1 = Arrays.asList(123,4567);
        coll.remove(coll1); //修改了当前集合
        System.out.println(coll);
    }

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

        //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(123);
        coll1.add(456); //注意List是有序的，顺序不一样返回false
        coll1.add(new String("Tom"));
        coll1.add(false);
        coll1.add(new Person("Jerry",20));

        System.out.println(coll.equals(coll1));

    }

    @Test
    public void test5(){
        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); //[AA, BB, CC]

        List<int[]> list1 = Arrays.asList(new int[]{123, 456});
        System.out.println(list1); //[[I@722c41f4] ,一个元素 ，注意此小知识点

//        List list2 = Arrays.asList(123, 456);
//        System.out.println(list2); //[123, 456]

        List list3 = Arrays.asList(new Integer[]{123,456}); //包装类的对象
        System.out.println(list3); //[123, 456]

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

集合元素的遍历操作，使用Iterator接口 【迭代器】

/**
 * 集合元素的遍历操作，
 * 内部方法:hasNext()和Next()
 * @author ldbstart
 * @create 2021-03-13 17:39
 */
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();

        //方式一：演示
//        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()); //报异常java.util.NoSuchElementException

        //方式二：
//        for (int i =0 ;i < coll.size(); i ++){
//            System.out.println(iterator.next());
//        }
        
        //方式三：【推荐用法】
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

迭代器的执行原理：

当创建Iterator对象的时候，指针就存在于集合元素最上面。

Iterator遍历集合两种错误写法

 @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，java.util.NoSuchElementException
//        }

        //错误二：
        while (coll.iterator().hasNext()){ //每当调用iterator()方法都会返回一个新的Iterator对象，默认游标都在集合第一个元素之前
            System.out.println(coll.iterator().next()); //死循环，不断地输出123
        }
    }

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”数据
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            if ("Tom".equals(obj)){
                iterator.remove();
            }
        }

        iterator = coll.iterator();
        //重新遍历
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

注意：

Iterator 可以删除集合的元素 但是是遍历过程中通过迭代器对象的 remove 方法 不是集合对象的 remove 方法 。

如果还未调用 next() 或在上一次调用 next 方法之后已经调用了 remove 方法再调用 remove 都会报IllegalStateException。

增强for循环

jdk5.0新增了foreach循环，用于遍历集合、数组

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 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[]{"MM","MM","MM"};

        //方式一：普通for循环
//        for (int i = 0; i < arr.length; i++){
//            arr[i] = "GG"; //拿着本身的元素做修改
//        }

        //方式二：增强for循环
        for (String s : arr){
            s = "GG"; //s是新的变量，相当于把arr[i]赋值给s
        }

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

    }
}

List接口      “动态”数组

 不用关心长度够不够，直接往里添元素。避免了角标越界异常。

* Collection接口：单列集合，用来存储一个一个的对象。
* |----List存储有序的，可重复的数据。
　　 |----ArrayList：作为List接口的主要实现类，jdk1.2；线程不安全，效率高；底层使用Object[ ] elementData存储。
　　 |----LinkedList：jdk1.2，对于频繁的插入和删除操作，使用此类效率比ArrayList高；底层使用的是双向链表存储。
　　 |----Vector：作为List接口的古老实现类jdk1.0，线程安全，效率低；底层也是使用Object[ ] elementData存储

ArrayList源码分析：jdk7情况下

* 1.Collection接口：单列集合，用来存储一个一个的对象。
* |----List存储有序的，可重复的数据。
* 　　 |----ArrayList：作为List接口的主要实现类，jdk1.2；线程不安全，效率高；底层使用Object[ ] elementData存储。
* 　　 |----LinkedList：jdk1.2，对于频繁的插入和删除操作，使用此类效率比ArrayList高；底层使用的是双向链表存储。
* 　　 |----Vector：作为List接口的古老实现类jdk1.0，线程安全，效率低；底层也是使用Object[ ] elementData存储
*
* 2.ArrayList源码分析：
* 2.1jdk7
* 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 jdk8中的变化：
* ArrayList list = new ArrayList(); //底层Object [] elementData初始化为{},并没有帮我们创建长度为10的数组
*
* list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementDate[]
* ...
* 后续和jdk7一样
*
* 小结:jdk7中的ArrayList对象的创建，类似于单例的饿汉式，一上来就给我们造好数组了，而jdk8中的ArrayList的对象的
* 创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。

* 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> prev){
*　　　　 this.item = element;
* 　　　　 this.next = next;
* 　　　　 this.prev = prev;
* 　　 }
* }

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

面试题：比较ArrayList、LinkedList、Vector三者的异同?

同：三各类都实现了List接口，存储数据的特点相同：有序、可重复

不同：见上。

List接口中常用方法：List 除了从 Collection 集合继承的方法外， 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位置的子集合

public class ListTest {

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

        //首次出现的位置
        int index = list.indexOf(456);
        System.out.println(index);

        //int lastIndexOf(Object obj)：返回obj在当前集合末次出现的位置
        System.out.println(list.lastIndexOf(456));

        //Object remove(int index):删除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);//返回删除的元素

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

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
        List list1 = list.subList(2, 4);
        System.out.println(list1);


    }

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

        System.out.println(list);

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB"); //在1的位置插入“BB”，后面的元素往后移
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中所有的元素添加
        List list1 = Arrays.asList(1,2,3);

        list.addAll(list1);
        System.out.println(list.size()); //9

        //Object get(int index):获取指定index位置的元素
        Object o = list.get(1);
        System.out.println(o);
        //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(new Person("Jerry",20));
        list.add(new String("Tom"));
        list.add(false);

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

        //方式二
        for (Object object : list){
            System.out.println(object);
        }

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

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

总结常用方法：

增：add(Object obj)往末尾添加

删：remove(int index)【List接口自己的】  /  remove(Object obj)【Collection里的】 注意区分

改：set(int index, Object ele)

查：get(int index)

插：add(int index, Object ele)

长度：size()

遍历：①Iterator迭代器方式  ②增强for循环  ③普通的for循环