Java List

最新推荐文章于 2024-07-13 13:55:40 发布

Wait Together

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量105

点赞数

分类专栏： Java基础文章标签： java jvm 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_65030141/article/details/129211742

版权

Java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

一、集合框架体系

集合：用来存储多个数据的一种容器。与数组不同的是……

集合体系

主要学习Collection，ArrayList，LinkedList……

二、Collection

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

方法：每个都很常见，很重要

// Collection是接口，演示时需要创建子类对象ArrayList
        Collection collection = new ArrayList();
        System.out.println(collection);

        // boolean add(Object obj);添加1个元素
        collection.add("集合");
        collection.add(new Date());
        collection.add(111);// 自动装箱成Integer，Integer赋值给Obj
        System.out.println(collection);

        // boolean addAll(Collection c);将参数集合中的所有元素，全部添加到当前集合
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");

        Collection c2 = new ArrayList();
        c2.add(1);
        c2.add(2);

        c2.add(c1);// 这是将集合当作1个元素放进去
        System.out.println(c2);

        c2.addAll(c1);// 这是将集合中的元素取出，一个一个放进去
        System.out.println(c2);
        System.out.println(c2.size());

        Collection c3 = new ArrayList();
        c3.add("a");
        c3.add("b");

        // boolean remove(Object obj);
        System.out.println(c3.remove(1));
        System.out.println(c3.remove("a"));

        // boolean removeAll(Collection c);
        Collection c4 = new ArrayList();
        c4.add("a");
        c4.add("b");

        Collection c5 = new ArrayList();
        c5.add("b");

        // 删除的是两个集合中有交集的部分元素
        System.out.println(c4.removeAll(c5));
        System.out.println(c4);

public static void main(String[] args) {

    Collection c1 = new ArrayList();
    c1.add("a");
    c1.add("b");

    Collection c2 = new ArrayList();
    c2.add("a");

    // retainAll(Collection c);保留指定元素，删除其他元素
    // 两个集合交集部分全部保留，其他删除
    c1.retainAll(c2);
    System.out.println(c1);

    // 判断是否包含
    Collection c3 = new ArrayList();
    c3.add("a");
    c3.add("b");
    System.out.println(c3.contains("c"));
    System.out.println(c3.contains("a"));

    System.out.println(c3.size());
    // 判断是否为空
    System.out.println(c3.isEmpty());

    // clear() 清空集合
    c3.clear();
    System.out.println(c3);
    System.out.println(c3.size());
}

三、泛型

泛型就是一种比较广泛的类型定义，是一种抽象的类型。
今天使用泛型的主要目的：为了消除强制类型转换

泛型使用
在类或方法参数定义使用泛型字母来取代之前固定数据类型
add(Object obj) --> add(E e)
Collection --> Collection

常见的泛型字母：E(element) T(target) K(key) V(value) ?(未知)

// Collection<String> c1 = new ArrayList<String>();
        // 一旦设置泛型，就约束了集合只能存储该类型数据
        Collection<String> c1 = new ArrayList<>();
        // 目的：为了消除强制类型转换！
        c1.add("a");
        // 不能加入其他类型的元素
//        c1.add(1);
//        c1.add(new Object());

四、迭代【重要】

迭代（遍历），将集合元素迭代，目的是取出元素

Collection根接口，提供了一个迭代器规范，iterator()，调用该方法会返回一个集合元素上的迭代器，通过这个迭代器可以获得集合元素。

Collection<String> c = new ArrayList<>();
c.add("a");
c.add("b");
c.add("c");
c.add("d");

// 获得迭代器（这个迭代器里面就会拥有所有的元素）
Iterator<String> iterator = c.iterator();
// 判断有没有下一个
while (iterator.hasNext()) {
    // 取出下一个元素
    String e = iterator.next();
    System.out.println(e);
    System.out.println(iterator.next());
}

// 现在不使用泛型。
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Iterator iterator1 = c1.iterator();
// 了解泛型会消除强制类型转换
while (iterator1.hasNext()){
    // 强转
    String e = (String) iterator1.next();
    System.out.println(e);
}

迭代其使用注意事项：
1、迭代器迭代完成之后，迭代器的位置在最后⼀位。所以迭代器只能迭代⼀次
2、迭代器在迭代的时候，不要调⽤多次next⽅法，可能会出错 NoSuchElementException
3、在迭代器迭代的时候，不能向集合中添加或者删除元素 ,否则报错 ConcurrentModificationException (除非使用迭代器自己的方法进行删除/添加)

增强for循环(foreach)

// 语法
for (数据类型 变量名:要遍历的集合/数组) {
    // ……
}
// 左侧的数据类型 变量名要根据集合/数组来定，变量是每次循环都代表一个集合或者数组元素

Collection<String> c = new ArrayList<>();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        // 迭代简化版
        for (String s:c) {
            System.out.print(s + " ");
        }

        // 练习：使用foreach遍历数组
        int[] a = {1,2,9,3,4};
        for (int i:a) {
            System.out.print(i + " ");
        }

五、List

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

List接口中的方法大部分与父接口Collection一致，但是除此之外的方法，确实提供了可以通过下标操作元素(CRUD)的方法
void add(int index, Element 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底层是数组，大小可变是指它会扩容（不是真的大小可变）

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)

public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>( );
        // System.out.println(list.size() );
        // System.out.println(list.isEmpty() );    
	// 有序: 遍历和插入顺序一致
    list.add(4);
    list.add(2);
    // 且允许重复
    list.add(4);
    list.add(1);
    list.add(3);
    // 42413
    // E remove(int index); // 根据下标删除,并返回被删除的元素(阅后即焚)
    //Integer e1 = list.remove(2);
    //System.out.println("要删除的元素: " + e1 );
    //System.out.println(list );

    // 通过下标取出元素
    Integer e2 = list.get(2);
    System.out.println("获得下标2的元素"+e2 );
    System.out.println(list );

    // 根据下标插入元素
    list.add(3,5);

    // 根据下标修改元素,返回旧元素
    list.set(3,50);
    System.out.println(list );
    // 遍历
    // for(Integer i: list){
    //     System.out.println(i );
    // }
}

6.2 底层原理

ArrayList底层是使用数组，默认长度是10，但是存储元素多余10时会扩容1.5倍

如何扩容：
但假如元素是，先判断加入后会不会超出默认长度
如果没有超出默认长度
1、add(Object o) 元素直接放最后
2、add(int index, Object o) 先将该位置以后的元素依次往后移动一个，然后再将该元素放入该位置
当加入元素时，判断加入后会不会超出容量，如果超出就要扩容
扩容是将一个新的数组，容量是原来的1.5倍
将原来数组的元素一次拷贝到数组
然后再放入新数组

6.3 特点

ArrayList特点：1）有序；2）重复；3）查询更新效率高；4）删除插入效率低
应用场景：适合查询频率高的地方，且基本大部分场景都是经常查不经常删除和插入的。如果以后没有特殊说明，直接就使用ArrayList！

七、LinkedList

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

7.1 演示方法

LinkedList<Integer> l1 = new LinkedList<>();
l1.add(4);
l1.add(2);
l1.add(3);
l1.add(8);

// 关于下表操作
l1.add(3,5);
System.out.println(l1);

l1.set(3,50);
System.out.println(l1);

Integer i = l1.get(3);
System.out.println(i + "================");

// 获得第一个/最后一个
System.out.println(l1.getFirst());
System.out.println(l1.getLast());

// 向头插入/向尾插入
l1.addFirst(9);
System.out.println(l1);
l1.addLast(7);
System.out.println(l1);

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 );