Java 集合-List

集合主要分为两组(单列集合, 双列集合)

• Connection 接口有两个重要的子接口LIst 和 Set, 它们的实现子类都是单列集合,

• Map 接口的实现子类是双列集合, 存放的是 K-V

Connection 接口

Collection 接口和常用方法

下面以 ArrayList 演示一下

• add: 添加单个元素
• remove: 删除指定元素
• contains: 查找某个元素是否存在
• size: 获取元素个数
• isEmpty: 判断是否为空
• clear: 清空
• addAll: 添加多个元素
• containsAll: 查找多个元素是否都存在
• removeAll: 删除多个元素

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList();
        // add: 添加单个元素
        list.add("aaa");
        list.add(111);
        list.add(true);
        System.out.println(list);

        // remove: 删除指定元素
        list.remove(0); // 删除第一个元素
        list.remove(true); // 删除指定元素
        System.out.println(list);

        // contains: 查找元素是否存在
        System.out.println((list.contains("aaa"))); // false
        list.add("aaa");
        System.out.println((list.contains("aaa"))); // true

        // size: 获取元素个数
        System.out.println(list.size());  // 2
        list.add("aaa");
        list.add("aaa");
        System.out.println(list.size());  // 4

        // isEmpty: 判断是否为空
        System.out.println(list.isEmpty());  // false

        // clear: 清空
        list.clear();
        System.out.println(list); // 慎重使用

        // addAll: 添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("三国演义");
        list2.add("红楼梦");
        list.addAll(list2);
        System.out.println(list);

        // containsAll: 查找多个元素是否存在
        System.out.println(list.containsAll(list2));  // true

        // removeAll 删除多个元素
        list.add("水浒传");
        list.removeAll(list2);
        System.out.println(list);   // 水浒传
    }
}

迭代器使用

1. 先得到需要遍历的对象的迭代器
2. 使用 while 循环遍历
3. 当退出 while 循环时, 这时 iterator 迭代器是指向最后元素的. 如果再执行 iterator.next(); 会抛出异常.
4. 如果 需要再次遍历, 需要重置 迭代器.iterator = mylist.iterator();

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

public class IteratorExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        ArrayList<String> myList = new ArrayList<>();

        // 向ArrayList中添加一些元素
        myList.add("苹果");
        myList.add("香蕉");
        myList.add("橙子");
        myList.add("葡萄");
        myList.add("梨");

        // 获取ArrayList的迭代器
        Iterator<String> iterator = myList.iterator();

        // 使用迭代器遍历ArrayList中的元素
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
        }
    }
}

for 循环增强

增强for循环, 可以代替 iterator 迭代器, 也就是简化版的 iterator , 本质是一样的.

import java.util.ArrayList;

public class EnhancedForLoopExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        ArrayList<String> myList = new ArrayList<>();

        // 向ArrayList中添加一些元素
        myList.add("苹果");
        myList.add("香蕉");
        myList.add("橙子");
        myList.add("葡萄");
        myList.add("梨");

        // 使用增强型for循环遍历ArrayList中的元素
        for (String fruit : myList) {
            System.out.println(fruit);
        }
    }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ConnectionIterator {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("小黑",2));
        list.add(new Dog("大黄",3));
        list.add(new Dog("大黑",6));
        list.add(new Dog("大毛",8));

        // 使用 for 增强
        for (Object dog : list) {
            System.out.println(dog);
        }

        System.out.println("-----------------------");
        // 使用迭代器
        // 1. 先拿到迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object dog = iterator.next();
            System.out.println(dog);
        }

    }





}

class Dog {
    private String name;
    private int 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;
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

List 接口和常见方法

• List 集合类中元素有序(添加顺序和取出顺序是一致的), 而且是可重复的.

import java.util.ArrayList;
import java.util.List;

public class List_ {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        System.out.println(list);
    }
}

• List 集合中的每个元素都有其对应的索引, 也就是支持索引.
  这里我们要注意 索引是从 0 开始的

import java.util.ArrayList;
import java.util.List;

public class List_ {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("ddd");
        list.add("ddd");
        System.out.println(list);
        // 下面我们通过索引取出 第三个元素
        System.out.println(list.get(2));   // ccc
    }
}

List 常用的方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListOperationsExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        List<String> myList = new ArrayList<>(Arrays.asList("苹果", "香蕉", "橙子", "苹果", "梨"));

        // 在指定位置插入元素
        myList.add(2, "葡萄");
        System.out.println("在索引为2的位置插入元素后的列表：" + myList);

        // 创建另一个集合
        List<String> anotherList = Arrays.asList("西瓜", "菠萝");

        // 在指定位置加入另一个集合的所有元素
        myList.addAll(4, anotherList);
        System.out.println("在索引为4的位置加入另一个集合的所有元素后的列表：" + myList);

        // 获取指定位置的元素
        String element = myList.get(3);
        System.out.println("索引为3的元素：" + element);

        // 返回某个元素首次出现的位置
        int firstIndex = myList.indexOf("苹果");
        System.out.println("苹果首次出现的位置：" + firstIndex);

        // 返回某个元素最后出现的位置
        int lastIndex = myList.lastIndexOf("苹果");
        System.out.println("苹果最后出现的位置：" + lastIndex);

        // 移除指定位置的元素，并返回此元素
        String removedElement = myList.remove(1);
        System.out.println("移除索引为1的元素：" + removedElement);

        // 替换指定位置的元素
        myList.set(0, "芒果");
        System.out.println("替换索引为0的元素后的列表：" + myList);

        // 返回子序列
        List<String> subList = myList.subList(1, 4);
        System.out.println("子序列：" + subList);
    }
}

ArrayList 底层结构

1. ArrayList 中维护了一个Object类型的数组elementData

2. 当创建了一个ArrayList对象时, 如果使用的是无参构造器, 则elementData容量为0, 第一次添加, 则扩容elementData为10, 再次扩容, 则为原大小的1.5倍.

   ArrayList list = new ArrayList();

看源码, 可以只带这里创建了一个空的 elementData 数组

下面我们进行添加操作

list.add(1);

执行list.add

(1)首先会确定是否要扩容

(2)然后再执行赋值操作

这个方法确定, minCapacity

第一次扩容为10

(1) modCount++ 记录集合被修改的次数

(2) 如果elementData的大小不够, 就调用 grow() 去扩容

(1) 进行扩容

(2) 使用扩容机制来确定要扩容到多大

(3) 第一次newCapacity=10

(4) 再次扩容即按照1.5倍扩容

(5) 扩容使用的是 Arrays.copyOf() , 因为要保留之前的数据

3. 如果使用的是指定大小的构造器, 则初始elementData为指定大小, 再次扩容则为原来大小的1.5倍.

   ArrayList list = new ArrayList[8];

创建一个指定大小 elementData 数组.

Vector 底层实现

1. Vector 类的定义说明

2. Vector 底层也是一个对象数组, protected Object[] elementData;
3. Vector 是线程同步的, 就是说它是线程安全的, Vector 类的操作方法都带有 synchronized
4. 在开发中, 需要线程同步安全时, 考虑使用Vector

Vector 和 ArrayList 的比较

LinkedList 底层结构

1. LinkedList 底层实现了双向链表和和双端队列特点
2. 可以添加任意元素(元素可以重复), 包括 null
3. 线程不安全, 没有同步实现