java.util.List相关实现类

 一.ArrayList

1.1 定义

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

1.2 示例

package s19;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public class ArrayListTest {
    public static void main(String[] args) {
        /*构造函数
          ArrayList()，空list，容量10
          ArrayList(Collection<? extends E> c)，构建对象时添加元素
          ArrayList(int initialCapacity)，指定初始容量
          非线程安全的
          自动扩容a+a/2倍
          允许null
        */
        ArrayList<String> list1 = new ArrayList<String>();
        //	add(E e)，返回boolean，判断是否成功
        list1.add("abc"); //appends elements
        ArrayList<String> list2 = new ArrayList<String>(list1);
        //add(int index, E element),在指定位置插入元素，0-size
        list2.add(0,"zxc");  //[zxc, abc]
        ArrayList<String> list3 = new ArrayList<String>(20);
        /*将指定集合全部加入当前list
        addAll(Collection<? extends E> c)
        addAll(int index, Collection<? extends E> c)
         */
        list3.addAll(list2);
        //	contains(Object o)，判断是否包含指定元素
        System.out.println(list3.contains("abc"));  //true

        /*迭代处理
        forEach(Consumer<? super E> action)
        Iterable
         */
        list3.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //	get(int index) 根据索引获取元素
        System.out.println(list3.get(0));  //zxc
        //int	indexOf(Object o)，返回指定元素的索引，为查到返回-1
        System.out.println(list3.indexOf("abc")); //1
        //int	lastIndexOf(Object o)，返回最后一个指定元素
        System.out.println(list3.lastIndexOf("zxc")); //0
        /*迭代器
          Iterator<E>	iterator()
          ListIterator<E>	listIterator()
          ListIterator<E>	listIterator(int index) 从指定位置开始
         */
        Iterator<String> iterator = list3.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());
        ListIterator<String> iterator1 = list3.listIterator(1);
        while(iterator1.hasNext())
            System.out.println(iterator1.next());

        /*移除
        E	remove(int index)  指定位置
        boolean	remove(Object o)  指定元素，第一个
        boolean	removeAll(Collection<?> c) //指定集合中所有
        boolean	removeIf(Predicate<? super E> filter)  //条件
        removeRange(int fromIndex, int toIndex)
         */
        list3.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if(s.contains("z"))
                    return true;
                return false;
            }
        });

        /*替换
        void	replaceAll(UnaryOperator<E> operator)
         */
        list3.replaceAll(new UnaryOperator<String>() {
            @Override
            public String apply(String s) {
                if(s.contains("a"))
                    return s.replaceAll("a","z");
                return s;
            }
        });
        System.out.println(list3); //[zbc]
        /*修改元素，返回原值
        E	set(int index, E element)
         */
        list3.set(0,"zxc");

        /* 只保留指定集合中包含的元素
        boolean	retainAll(Collection<?> c)
         */

        System.out.println(list3.size()); //获取元素个数

        /*转换成Array
        Object[]	toArray()
        <T> T[]	toArray(T[] a)
         */
        Object[] oList = list3.toArray();
        String[] sList = list3.toArray(new String[0]);

        /*
        Spliterator<E>	spliterator()
         */
        Spliterator<String> spliterator = list3.spliterator();
        
        /*排序
        void	sort(Comparator<? super E> c)
         */
        list3.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        //容量设置成当前size
        list3.trimToSize();

        list3.clear(); //清空
        System.out.println(list3.isEmpty());//true，判断是否为空

    }

}

 二.Vector

2.1 定义

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

 实现了一个可增长的数组对象。与数组一样，可使用索引进行访问。

2.2 说明

1. 方法与ArrayList类基本相同；
2. Vector是线程安全的，但是当程序中存在分步逻辑时可能会产生问题，需要综合考虑；
3. 允许null元素；

三.Stack

3.1 定义

public class Stack<E>
extends Vector<E>

创建一共后进先出的队列

3.2 示例

import java.util.ArrayList;
import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {

        //无参构造
        Stack<ArrayList<String>> stack = new Stack<>();

        ArrayList<String> array1 = new ArrayList<>();
        array1.add("a");
        array1.add("b");
        ArrayList<String> array2 = new ArrayList<>();
        array2.add("1");
        array2.add("2");
        //E	push(E item)进站
        stack.push(array1);
        stack.push(array2);
        ArrayList<String> top = new ArrayList<>();
        //E	peek()返回栈顶元素，但是不弹出
        top = stack.peek();
        System.out.println(top);  //[1, 2]
        //int	search(Object o)，查找元素位置
        System.out.println(stack.search(top));  //1

        ArrayList<String> out = new ArrayList<>();
        //boolean	empty() 判断是否为空
        if(!stack.empty())
            //E	pop() 出站
            out = stack.pop();
        System.out.println(out);  //[1, 2]

    }
}

四.LinkedList

4.1 定义

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

 同时实现List/Deque接口，创建双向链表。

与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。

 4.2 示例

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        /*构造函数
        LinkedList()
        LinkedList(Collection<? extends E> c)
         */
        LinkedList<Integer> list = new LinkedList<>();

        /*添加元素
        以下与ArrayList基本相同
        boolean	add(E e)
        void	add(int index, E element)
        boolean	addAll(Collection<? extends E> c)
        boolean	addAll(int index, Collection<? extends E> c)
        来自Deque接口的方法
        void	addFirst(E e) 在第一个位置插入元素
        void	addLast(E e) 在最后添加元素
         */
        list.addLast(2);
        list.addFirst(1);

        /*逆序遍历
        Iterator<E>	descendingIterator()
         */
        Iterator<Integer> iterator = list.descendingIterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());  //2 1

        /*获取第一个元最后一个元素，不移除
        E	element()  最后一个元素
        E	getFirst() 第一个元素
        E	getLast()  最后一个元素
        E	peek() 第一个元素
        E	peekFirst() 第一个元素
        E	peekLast() 最后一个元素
         */
        System.out.println(list.element());  //1

        /*
        boolean	offer(E e)  最后添加元素
        boolean	offerFirst(E e)  第一个位置插入元素
        boolean	offerLast(E e) 最后添加元素
         */
        list.offer(3);
        list.offerFirst(0);
        list.offerLast(4);

        System.out.println(list); //[0, 1, 2, 3, 4]

        /*提取并移除首尾元素
        E	poll()  移除第一个元素
        E	pollFirst()  移除第一个元素
        E	pollLast()  移除最后一个元素
         */
        System.out.println(list.poll()); //0
        System.out.println(list.pollLast()); //4
        System.out.println(list);  //[1, 2, 3]

        /*后进先出
        E	pop() 第一个元素出栈
        void	push(E e) 进站，放到第一个元素
         */
        System.out.println(list.pop()); //1
        list.push(4);
        System.out.println(list);  //[4, 2, 3]

        /*移除
        E	remove()  第一个元素
        E	remove(int index)  指定位置
        boolean	remove(Object o) 指定元素，第一个
        E	removeFirst()
        boolean	removeFirstOccurrence(Object o) 指定元素，第一个
        E	removeLast()
        boolean	removeLastOccurrence(Object o) 指定元素，最后一个
         */
        /*其他
        void	clear()
        Object	clone()
        boolean	contains(Object o)
        E	get(int index)
        int	indexOf(Object o)
        int	lastIndexOf(Object o)
        ListIterator<E>	listIterator(int index)
        E	set(int index, E element)
        int	size()
        Spliterator<E>	spliterator()
        Object[]	toArray()
        <T> T[]	toArray(T[] a)
         */
    }
}