今日内容

零、复习昨日
一、集合框架体系
二、Collection
三、泛型
四、迭代
五、List
六、ArrayList
七、LinkedList

零、复习昨日

晨考

一、集合框架体系

数组: 是一个容器,用来存放数据的

定长
只能存储同一种数据类型的数据
int[] 可以存储int值,Student[] 可以存储引用类型
只有一个length属性,没有方法,使用时功能简单

集合: 是一个容器,用来存放数据的

不定长
存各种各样类型
只能存储引用类型
提供了操作数据的各种方法

集合体系

今天主要学习Collection,List,ArrayList,LinkedList…

二、Collection

Collection是单列集合层次结构中的根接口
一些集合允许有重复的元素，而另一些则不允许。一些集合是有序的，而另一些则是无序的
Collection下面的一些子实现类有些有重复元素,有些没有,有些可以有序,有些无序

方法: 每个都很常见,很重要

ps: Collection是接口,不能创建对象,为了演示这些API,需要使用子实现类,使用最常用的ArrayList集合来实现方法

package com.qf.col;

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

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 演示Collection接口中的方法
 */
public class TestCollection {

    public static void main(String[] args) {

        Collection col = new ArrayList();
        // 添加元素
        col.add("abc");
        col.add(1);// 1自动装箱成Integer对象1,存入方法
        col.add(new Date());

        System.out.println(col );

        // 添加所有元素
        Collection col2 = new ArrayList();
        col2.add(21);
        col2.add(22);
        col2.add(23);

        col.addAll(col2);

        System.out.println(col );

        // 清空集合
        // col.clear();
        System.out.println(col );

        // 判断是否包含元素
        boolean contains = col.contains(22);
        System.out.println("是否包含22? " + contains );

        Collection col3 = new ArrayList();
        col3.add(21);
        col3.add(22);
        col3.add(24);

        boolean b = col.containsAll(col3);
        System.out.println("是否全部包含? " + b );

        // 判断两个集合是否相等(是指内部元素是否全部相等)
        boolean equals = col2.equals(col3);
        System.out.println("两个集合是否相等: " + equals );

        // 是否为空
        boolean empty = col.isEmpty( );
        System.out.println("是否为空? " + empty );

        // 移除指定元素
        boolean remove = col.remove(22);
        System.out.println("移除22 " + remove );
        System.out.println(col );

        //  boolean removeAll(Collection<?> c)
        //           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
        //  boolean retainAll(Collection<?> c)
        //           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

        // 获得集合元素个数
        System.out.println(col.size() );
    }
}

三、迭代[重要]

迭代 (遍历), 将集合元素迭代,目的是取出元素.

       public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(11);
        col.add(12);
        col.add(13);
        col.add(14);

        // 返回此集合上的迭代器
        // 迭代器内部就有所有元素了
        Iterator iterator = col.iterator();
        // Object next = iterator.next( );
        // 取出下一个元素
        // System.out.println(next );
        //
        // Object next2 = iterator.next( );
        // System.out.println(next2 );

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

增强for循环(foreach)

        // 增强for循环(foreach)
        /**
         * for(遍历出结果的数据类型 变量 :被遍历的集合/数组) {
         * }
         */
        for(Object o : col) {
            System.out.println(o );
        }
        System.out.println("---------------" );
        int[] arr = {1,2,3,4};
        for(int i : arr){
            System.out.println(i );
        }

四、泛型

泛型在集合中主要是用来规定数据类型的.

语法: 设计时 <类型> , 例如<E> <K> ,<K,V> <T>

使用时<类型>,类型只能写引用类型,例如<String> <Integer>

作用:

约束集合存储的数据类型
避免数据类型转换

    public static void main(String[] args) {
        /**
         * 集合允许存储不同类型
         * 但是开发中一般不会存储其他类型,即只会存同一种类型
         * 此时,就可以使用泛型来约束存储的数据类型
         */
        Collection<Integer> col = new ArrayList<>();
        col.add(1);
        // col.add("a");
        // col.add(1.1);
        // col.add(new Date());
        col.add(2);

        Iterator<Integer> iterator = col.iterator();
        // 使用泛型后,可以避免类型转换
        while(iterator.hasNext()) {
            Integer i = iterator.next();
            System.out.println(i );
        }
        System.out.println("----------" );
        for(Integer i : col){
            System.out.println(i );
        }
    }

五、List

List是Collection的子接口
List是有序集合: 有序是指集合迭代顺序和插入顺序一致
List集合允许重复元素!!
List集合提供了可以针对索引(下标)操作元素的方法

List接口中的方法大部分与父接口Collection中一致,
但是除此之外的方法,确实提了可以通过下标操作元素(CRUD)的方法

void add(int index,E e)
E remove(int index)
E get(int index)
E set(int index,E e)

List是接口,没有办法演示其中的方法

List接口有两个常用的实现类:ArrayList和LinkedList

六、ArrayList[重点]

ArrayList实现了List接口,即ArrayList也是有序集合,也允许重复元素,且那些关于下标操作集合的方法ArrayList都有!

ArrayList不保证线程安全

ArrayList底层是数组,大小可变是指它会扩容(不是真正大小可变)

6.1 演示方法

构造方法

ArrayList() 创建空集合,默认创建了一个长度为10的数组
ArrayList(Collection c) 创建一个集合,集合内直接就有指定的参数
ArrayList(int initialCapacity) 创建一个指定初始化容量的数组

 ArrayList<Integer> list = new ArrayList<>( );

方法

其他的方法上午在Collection中已经学过
void add(int index,E e)
E remove(int index)
E get(int index)
E set(int index,E e)

package com.qf.col;

import java.util.ArrayList;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 演示ArrayList的方法
 */
public class TestArrayList {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>( );
        System.out.println(list );

        list.add(11);
        list.add(12);
        list.add(13);

        System.out.println(list );
        ArrayList<Integer> list2 = new ArrayList<>(list);
        System.out.println(list2 );

        // 与Collection接口中一致的方法不再演示
        // 主要演示List特有的方法: 关于下标操作的方法

        // void dd(int index,E e) 在指定下标插入指定元素
        list.add(1,14);
        list.add(1,14);
        System.out.println(list );

        // E get(int index) 根据下标获得指定元素
        Integer i = list.get(1);
        System.out.println(i );

        // E set(int index,E e); 设置指定位置为指定元素,返回旧元素
        Integer old = list.set(2, 15);
        System.out.println(list );
        System.out.println(old );
        
        // E remove(int index); 根据下标删除元素,返回旧元素
        Integer old2 = list.remove(1);
        System.out.println(old2 );
        System.out.println(list );
        // 阅后即焚

        // 迭代/遍历
    }
}

6.2 底层原理

ArrayList底层是使用数组,默认长度是10,但是存储元素多于10时会扩容.

如何扩容的?

当加入元素时,先判断加入后会不会超出默认长度
如果没有超出默认长度
add(Object o) 元素直接放最后
add(int index,Object o) 先将该位置以后的元素依次往后移动一个,然后再将该元素放入该位置

当加入元素时,判断加入后长度会不会超出容量,如果超出就要扩容
扩容是创建一个新的数组,容量是原来的1.5倍
将原来数组的元素依次拷贝到新数组
然后再放入新元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IdrKQEaK-1682069374810)(https://qiushiju-tuchuang.oss-cn-hangzhou.aliyuncs.com/image/image-20230222160227208.png)]

// jdk源码   
 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

6.3 特点[记住]

ArrayList特点: 1) 有序 2) 重复 3) 查询更新效率高 4) 删除插入效率低

应用场景: 适合那些查询频率高的地方. 且基本大部分场景都是经常查不经常删除和插入的,所以呢ArrayList就非常常用!!! 如果以后没有特殊说明,直接就使用ArrayList!!

七、LinkedList

LinkedList是List的实现类,那么LinkedList也是允许重复,有序
且LinkedList集合也有关于下标操作集合的方法,但是还提供了一些关于操作开头和结尾的方法

底层是使用链表实现.

7.1 演示方法

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>( );
        System.out.println(list );
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(1,4);
        System.out.println(list );
        // 其他List集合中关于下标的方法LinkedList都有,不再演示

        // 重点演示,关于头/尾的操作
        list.addFirst(0);
        list.addLast(5);
        System.out.println(list );
        System.out.println("------------------------------" );
        list.removeFirst();
        list.removeLast();
        System.out.println(list );
        System.out.println("------------------------------" );
        Integer pop = list.pop( );
        System.out.println(pop );
        System.out.println(list );

    }

7.2 底层原理

底层是双向链表实现

7.3 特点

有序
允许重复
查找,更新时效率比较低
插入,删除时效率比较高

八、扩展

面试

        // 会出现并发编程问题的
        // Iterator<Integer> iterator = list.iterator( );
        // while(iterator.hasNext()) {
        //     Integer next = iterator.next( );
        //
        //     // 使用集合自己方法进行删除/添加会出现并发修改异常
        //     list.remove(1);
        //
        // }


        System.out.println(list );
        // 不会出现并发编程异常
        ListIterator<Integer> listIterator = list.listIterator( );
        while (listIterator.hasNext()) {
            Integer next = listIterator.next( );

            // 使用迭代器的方法进行对集合内容修改/添加
            //listIterator.remove();
            listIterator.add(100);

        }
        System.out.println(list );

九、总结

记住Collection接口 方法
记住List的特点: 有序,重复
重点是ArrayList的方法,遍历,底层原理,特点
LinkedList熟悉

day18_集合