java 集合（三）【Collection（二）【List接口】】

2.2List接口（列表）

有序集合（也称为序列 ）。 该集合用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

List 通常允许重复的元素、允许 null 元素

方法名	返回值类型	描述
add(int index, E element)	void	将指定的元素插入此列表中的指定位置
addAll(int index, Collection<? extends E> c)	boolean	将指定集合中的所有元素插入到此列表中的指定位置
get(int index)	E	返回此列表中指定位置的元素
indexOf(Object o)	int	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回 -1
lastIndexOf(Object o)	int	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回 -1
remove(int index)	E	删除该列表中指定位置的元素，返回被删除的元素
set(int index, E element)	E	用指定的元素（可选操作）替换此列表中指定位置的元素，返回被替换的值
subList(int fromIndex, int toIndex)	List	返回此列表中指定的 fromIndex （含）和 toIndex之间的元素集合
default sort(Comparator c)	void	按照 c 比较器进行自然排序 (JDK 8)
static copyOf(Collection coll)	List	按照迭代顺序返回一个不可修改的 List (JDK 10)
static of()	List	返回包含任意数量元素的不可修改列表 (JDK 9)

示例：

import java.util.List;
import java.util.Scanner;

public class ListTest {
    public static void main(String[] args) {
        // List不可修改
        List com = List.of("水蜜桃", "火龙果", "橘子", "柚子", "香蕉");
        Scanner input = new Scanner(System.in);
        System.out.println("请输入你要查询的商品信息");
        String str = input.next();

        if (com.contains(str)) {
            String information = (String) com.get(com.indexOf(str));
            System.out.println(information);
        } else {
            System.out.println("暂时没有这个商品");
        }
    }

}

2.2.1 Vector 类动态储存数据

Vector 类是一种动态数组，它可以自动扩展和缩小数组的大小，实现了 List 接口，且所有的方法都是同步的（线程安全的），适用于多线程环境中的操作。
Vector 类的特点：

1. 动态数组：Vector的大小可以根据需要自动增长或减小。当添加元素超过当前容量时，Vector会自动重新分配内部数组的大小以容纳更多的元素。默认大小为10，扩容为*2。
2. 线程安全：Vector是线程安全的，意味着多个线程可以同时对Vector进行读取和写入操作，而不会导致数据不一致的问题。Vector中的方法都使用了同步关键字来确保线程安全性。
3. 支持随机访问：Vector类支持通过索引值来访问集合在的元素，具有常数时间度的随机访问特性。
4. 可以包含重复元素
5. 可以插入 null

示例：

public class Exar3  {
    //创建一个List集合表示学生列表。添加10个学生并设计方法实现根据学生成绩排序
    // 和计算平均成绩功能
    public static void main(String[] args) {
        List list = List.of(
                new Student1("张1",7.0),
                new Student1("张2",757.0),
                new Student1("张3",47.0),
                new Student1("张4",77.0),
        );
        //List转成Vector
        Vector l = new Vector(list);
        //按照成绩排序
        Sort(l, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Student1 stu1 && o2 instanceof  Student1 stu2){
                    return (int) (stu1.getScore() - stu2.getScore());
                }
                else {
                    throw new RuntimeException("错误");
                }
            }
        });

        System.out.println(list);
        System.out.println(l);
       
    public static void Sort(Vector l,Comparator comparator){
        for(int i = 0;i < l.size()-1;i++){
            for(int j = 0;j < l.size()-i-1;j++){
                int result = comparator.compare(l.get(j),l.get(j+1));
                if(result > 0){
                    Object temp = l.get(j);
                    l.set(j,l.get(j+1));
                    l.set(j+1,temp);
                }
            }
        }
    }
}

2.2.2 Stack 类动态存储数据

Stack 类代表后进先出（LIFO） 堆栈的对象， Stack 继承自 Vector 所以它有所有 Vector 中的方法。

 public class Stack<E> extends Vector<E>

方法名	返回值类型	描述
empty()	boolean	判断此堆栈是否为空
peek()	E	返回此堆栈顶部的对象，而不从堆栈中删除它
pop()	E	返回并删除此堆栈顶部的对象
push(E item)	E	将指定对象添加到堆栈的顶部
search(Object o)	int	返回对象在此堆栈上的从1开始的位置，如果对象不在堆栈中，则返回 -1

示例：

public class StackTest {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        // 向Stack添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        // Stack 弹出元素
        System.out.println(stack.pop());  // 4
        // Stack 查看但不弹出
        System.out.println(stack.peek());  // 3
        // 判断是否为空
        System.out.println(stack.isEmpty());  // false
        // 查找元素所在位置
        System.out.println(3);  // 3
        System.out.println(stack);  // [1, 2, 3]
    }

}

2.2.3ArrayList类动态存储数据

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList 是 Java 编程语言中的一个类，位于 java.util 包中。它是一个动态数组，可以根据需要自动调整大小。ArrayList 通过插入和删除元素来维护内部数组的大小，并提供了许多有用的方法来操作列表数据。可以存 null。

以下是ArrayList的一些主要特点和常用方法：

1. 动态大小：ArrayList可以根据需要动态增加或减少其大小，无需手动管理数组的大小。
2. 允许重复元素：ArrayList可以包含重复的元素。
3. 随机访问：可以使用索引访问ArrayList中的元素，通过get(index)方法获取指定位置的元素。
4. 增删操作：可以使用add(element)方法在列表末尾添加元素，使用remove(index)方法删除指定位置的元素。
5. 数组转换：可以使用toArray()方法将ArrayList转换为数组，或者使用Arrays.asList(array)方法将数组转换为ArrayList。

public class ArrayList1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("c");
        list.add("d");
        for(String str :list){
            if("c".equals(str)){
                list.remove(str);
            }
        }
        System.out.println(list);
    }
}

ArrayList 是非线程安全的，默认容量为10，默认每次扩容为1.5倍。

常用方法

返回值	方法名	说明
void	add(int index, E element)	在列表的指定位置插入指定的元素。
boolean	add(E e)	将指定的元素追加到列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到列表中的指定位置，从指定位置开始。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素按照指定集合的迭代器返回顺序追加到列表的末尾。
void	clear()	从列表中移除所有元素。
Object	clone()	返回此 ArrayList 实例的浅拷贝。
boolean	contains(Object o)	如果列表包含指定的元素，则返回 true。
void	ensureCapacity(int minCapacity)	如果需要，增加此 ArrayList 实例的容量，以确保它至少可以容纳由最小容量参数指定的元素个数。
boolean	equals(Object o)	将指定对象与此列表进行比较，判断是否相等。
void	forEach(Consumer<? super E> action)	对 Iterable 中的每个元素执行给定的操作，直到所有元素都已处理完或操作引发异常。
E	get(int index)	返回列表中指定位置的元素。
int	hashCode()	返回此列表的哈希码值。
int	indexOf(Object o)	返回指定元素在列表中首次出现的索引，如果列表不包含该元素，则返回 -1。
boolean	isEmpty()	如果列表不包含任何元素，则返回 true。
Iterator	iterator()	返回在列表中的元素上进行迭代的迭代器。
int	lastIndexOf(Object o)	返回指定元素在列表中最后一次出现的索引，如果列表不包含该元素，则返回 -1。
ListIterator	listIterator()	返回列表中元素的列表迭代器（按适当的顺序）。
ListIterator	listIterator(int index)	返回列表中元素的列表迭代器（按适当的顺序），从列表中的指定位置开始。
E	remove(int index)	移除列表中指定位置的元素。
boolean	remove(Object o)	如果列表中存在指定的元素，则移除列表中首次出现的该元素（可选操作）。
boolean	removeAll(Collection<?> c)	移除列表中那些包含在指定集合中的所有元素（可选操作）。
boolean	removeIf(Predicate<? super E> filter)	移除满足给定谓词的此集合中的所有元素。
protected void	removeRange(int fromIndex, int toIndex)	移除列表中索引位于 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
boolean	retainAll(Collection<?> c)	仅保留列表中包含在指定集合中的元素（可选操作）。
E	set(int index, E element)	用指定的元素替换列表中指定位置的元素。
int	size()	返回列表中的元素数。
Spliterator	spliterator()	创建一个后期绑定和快速失败的 Spliterator，它在列表中的元素上进行遍历。
Spliterator	spliterator()	在此列表中的元素上创建一个延迟绑定和快速失败的Spliterator。
List	subList(int fromIndex, int toIndex)	返回此列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()	返回一个包含列表中所有元素（按正确顺序，从第一个元素到最后一个元素）的数组。
T[]	toArray(T[] a)	返回一个包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void	trimToSize()	将此 ArrayList 实例的容量调整为列表的当前大小。

public class ArrayListFunction {
    public static void main(String[] args) {
        ArrayList<String> list3 = new ArrayList();
        System.out.println("****截取*****");
        list3.add(null);
        list3.add("a");
        list3.add("b");
        list3.add("c");
        list3.add("d");
        list3.add("e");
        list3.add("c");

        //截取2-4
        List<String> strings =list3.subList(2,5);
        System.out.println(strings);
        System.out.println("删除子串的会删除原来集合的，这是视图");
        strings.remove("c");
        System.out.println(strings);
        System.out.println(list3);
        System.out.println("子串添加元素");
        strings.add("6");
        System.out.println(strings);
        System.out.println(list3);
        System.out.println("子串换元素");
        strings.set(0,"8");
        System.out.println(strings);
        System.out.println(list3);


        //删除list3所有元素
        list3.clear();
        System.out.println(list3);
    }
}

构造方法

ArrayList类提供了多种构造方法来创建ArrayList对象。以下是一些常用的构造方法：

1. ArrayList()：创建一个空的ArrayList对象，默认初始容量为10。

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

2. ArrayList(int initialCapacity)：创建一个具有指定初始容量的ArrayList对象。

   ArrayList<String> list = new ArrayList<>(20);
   
   

3. ArrayList(Collection<? extends E> c)：创建一个包含指定集合中的元素的ArrayList对象。

   List<String> collection = Arrays.asList("Apple", "Banana", "Orange");
   ArrayList<String> list = new ArrayList<>(collection);
   
   

4. ArrayList<E>(ArrayList<? extends E> c)：创建一个包含指定ArrayList中的元素的ArrayList对象。

   ArrayList<String> originalList = new ArrayList<>();
   originalList.add("Apple");
   originalList.add("Banana");
   originalList.add("Orange");
   
   ArrayList<String> newList = new ArrayList<>(originalList);
   
   

   这些构造方法允许你根据不同的需求来创建ArrayList对象。你可以选择根据默认大小创建一个空列表，指定初始容量，或者使用现有的集合来初始化列表。

   需要注意的是，尖括号中的类型参数E表示ArrayList中元素的类型。在实际使用时，根据需要替换为实际的类型。

2.2.4 LinkedList 类动态存储数据

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

LinkedList 是一个双向链表，允许存储 null ，此实现不同步（非线程安全的）

实例化

//实例化
LinkedList list = new LinkedList();
LinkedList list1 = new LinkedList(list);

常用方法

修饰符和类型	方法	描述
void	add(int index, E element)	在列表的指定位置插入指定的元素。
boolean	add(E e)	将指定的元素追加到列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素插入到列表中。
boolean	addAll(Collection<? extends E> c)	将指定集合中的所有元素按照其迭代器返回的顺序追加到列表的末尾。
void	addFirst(E e)	在列表的开头插入指定的元素。
void	addLast(E e)	将指定的元素追加到列表的末尾。
void	clear()	从列表中移除所有元素。
Object	clone()	返回此 LinkedList 的浅表副本。
boolean	contains(Object o)	如果列表包含指定的元素，则返回 true。
Iterator	descendingIterator()	返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element()	检索但不删除此列表的头（第一个元素）。
E	get(int index)	返回列表中指定位置的元素。
E	getFirst()	返回此列表的第一个元素。
E	getLast()	返回此列表的最后一个元素。
int	indexOf(Object o)	返回指定元素在此列表中首次出现的索引，如果此列表不包含该元素，则返回 -1。
int	lastIndexOf(Object o)	返回指定元素在此列表中最后一次出现的索引，如果此列表不包含该元素，则返回 -1。
ListIterator	listIterator(int index)	返回此列表中元素的列表迭代器（按适当的顺序），从列表的指定位置开始。
boolean	offer(E e)	将指定元素作为列表的尾部（最后一个元素）添加。
boolean	offerFirst(E e)	在列表的前面插入指定的元素。
boolean	offerLast(E e)	在列表的末尾插入指定的元素。
E	peek()	检索但不删除此列表的头（第一个元素）。
E	peekFirst()	检索但不删除此列表的第一个元素，如果此列表为空，则返回 null。
E	peekLast()	检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null。
E	poll()	检索并删除此列表的头（第一个元素）。
E	pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回 null。
E	pollLast()	检索并删除此列表的最后一个元素，如果此列表为空，则返回 null。
E	pop()	从由此列表表示的堆栈中弹出一个元素。
void	push(E e)	将一个元素推送到由此列表表示的堆栈上。
E	remove()	检索并删除此列表的头（第一个元素）。
E	remove(int index)	删除列表中指定位置的元素。
boolean	remove(Object o)	如果列表中存在指定的元素，则将其从列表中删除（仅删除第一个出现的元素）。
E	removeFirst()	移除并返回此列表的第一个元素。
boolean	removeFirstOccurrence(Object o)	从列表中移除第一次出现的指定元素（从头到尾遍历列表时）。
E	removeLast()	移除并返回此列表的最后一个元素。
boolean	removeLastOccurrence(Object o)	从列表中移除最后一次出现的指定元素（从头到尾遍历列表时）。
E	set(int index, E element)	使用指定的元素替换列表中指定位置的元素。
int	size()	返回列表中的元素数。
Spliterator	spliterator()	在此列表中的元素上创建一个延迟绑定和快速失败的Spliterator。
Object[]	toArray()	返回一个包含列表中所有元素（按正确顺序，从第一个元素到最后一个元素）的数组。
T[]	toArray(T[] a)	返回一个包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

构造方法

LinkedList类提供了以下几个构造方法：

1. LinkedList()：创建一个空的LinkedList对象。

   // 创建一个空的LinkedList对象
   LinkedList<String> emptyList = new LinkedList<>();
   System.out.println("Empty List: " + emptyList); // 输出：Empty List: []
   
   

2. LinkedList(Collection<? extends E> c)：创建一个包含指定集合中的元素的LinkedList对象，元素按照集合的迭代器返回顺序添加到列表的末尾。

   // 创建一个包含指定集合中的元素的LinkedList对象
   LinkedList<Integer> numbers = new LinkedList<>(List.of(1, 2, 3, 4, 5));
   System.out.println("Numbers: " + numbers); // 输出：Numbers: [1, 2, 3, 4, 5]
   
   

2.2.5ArrayList /LinkedList 区别

都实现了 List 接口,都是有序的、可以重复的、可以存null值得集合，可以使用下标访问元素

• LinkedList的删除/新增操作效率高
• ArrayList 在随机访问（获取元素时）效率比 LinkedList 高
• ArrayList 底层实现是数组, 默认容量是 10 …
• LinkedList 底层实现的链表(双向链表)
• 在添加元素到末尾时，两个集合效率差不多
• 在任意位置添加元素时， LinkedList 效率更高
• 在任意位置删除元素时， LinkedList 效率高
• 内存， ArrayList 使用的是连续空间