Java入门-12、List集合及其子类

List集合：

java.util.List 接口是Collection接口下的一个子接口。List集合是存储引用类型的容器。

特点：

1. 它是一个存储有顺序的集合
2. 带有索引的集合，可以根据索引找到相应位置的元素
3. 集合中可以存在相同的元素

List继承了Collection的全部方法外，还有自己特定的方法：

public void add(int index, E element) :在指定位置下，存储元素

public E get(int index) : 获取指定位置上的元素

public E remove(int index) : 移除列表中指定位置的元素 , 返回的是被移除的元素

public E set(int index, E element) : 用指定元素替换集合中指定位置的元素 , 返回值的原来的元素

 

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

public class ListDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //添加数据
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //在指定位置添加元素
        list.add(1,"1");
        System.out.println(list);

        //返回指定位置下的元素
        list.get(2);

        //移除指定位置下的元素
        list.remove(2);
        System.out.println(list);

        //指定位置下替换元素
        list.set(2,"b");
        System.out.println(list);
    }
}

List集合中的的三个子类：ArrayList、LinkedList、Vector

ArrayList集合

特点：底层通过数组的方式存储元素，不同步、不安全、效率高、查询快、增删慢

使用无参构造函数时，Object数组默认的容量是10，当长度不够时，自动增长0.5倍

常见方法：
public boolean add(E e) ： 把给定的对象添加到当前集合中 。
public void clear() :  清空集合中所有的元素。
public boolean remove(E e) : 把给定的对象在当前集合中删除。
public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public Object[] toArray() : 把集合中的元素，存储到数组中

import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("aa");
        arrayList.add("bb");
        arrayList.add("cc");
        arrayList.add("dd");
        arrayList.add("ee");
        //添加数据   add(int index, E element)
        //          将指定的元素插入此列表中的指定位置。
        arrayList.add(2,"22");
        System.out.println(arrayList);


        //size()返回此列表中的元素数
        int size = arrayList.size();
        System.out.println(size);


        //remove() 移除给定的元素并返回
        arrayList.remove("dd");
        System.out.println(arrayList);

        //判断是否包含给定对象
        boolean ee = arrayList.contains("ee");
        System.out.println(ee);

        //判断集合是否为空
        boolean empty = arrayList.isEmpty();
        System.out.println(empty);


        String[] str = arrayList.toArray(new String[0]);
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }

        //clear() 移除此列表中的所有元素。
        arrayList.clear();
        System.out.println(arrayList);
    }
}

LinkedList集合

特点：底层通过链表实现、查询慢、增删快、不安全、不同步、执行效率高。

常见方法：

public void addFirst(E e) : 将指定元素插入此列表的开头。

public void addLast(E e) : 将指定元素添加到此列表的结尾。

public E getFirst() : 返回此列表的第一个元素。

public E getLast() : 返回此列表的最后一个元素。

public E removeFirst() : 移除并返回此列表的第一个元素。

public E removeLast() : 移除并返回此列表的最后一个元素。

public E pop() : 从此列表所表示的堆栈处弹出一个元素。

public void push(E e) : 将元素推入此列表所表示的堆栈。

public boolean isEmpty() ：如果列表不包含元素，则返回 true。

 

import java.util.LinkedList;

public class LinkedListDemo01 {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("aa");
        linkedList.add("bb");
        linkedList.add("cc");
        linkedList.add("dd");
        linkedList.add("ee");
        System.out.println(linkedList);

        //指定元素插入列表开头
        linkedList.addFirst("first");
        //指定元素插入列表结尾
        linkedList.addLast("last");
        System.out.println(linkedList);

        //返回列表第一个对象
        System.out.println(linkedList.getFirst());
        //返回列表结尾对象
        System.out.println(linkedList.getLast());

        //移除并返回此列表的第一个元素。
        String s = linkedList.removeFirst();
        //移除并返回此列表的最后一个元素。
        String s1 = linkedList.removeLast();
        System.out.println(linkedList);

        // 将元素推入此列表所表示的堆栈。
        linkedList.push("first");
        System.out.println(linkedList);
        // 从此列表所表示的堆栈处弹出一个元素。
        String pop = linkedList.pop();
        System.out.println(pop);
        //如果列表不包含元素，则返回true。
        boolean empty = linkedList.isEmpty();
        System.out.println(empty);

    }
}

 

 

Vector集合

特点：通过数组实现元素的存储，长度可变，更安全，保证同步，效率低

特有方法:
void addElement(Object obj)将指定的元素添加到此向量的末尾

Enumeration elements()返回此向量的枚举，结合Enumeration接口使用，相当于迭代器。

 boolean hasMoreElements()相当于迭代器里面的hasNext()。

 Object nextElement()相当于next()方法。
 

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo01 {
    public static void main(String[] args) {
        Vector<String> vector =new Vector<>();
        //添加元素
        vector.add("aa");
        vector.add("bb");
        vector.add("cc");
        vector.add("dd");
        vector.add("ee");

        //将指定的元素添加到此向量的末尾
        vector.addElement("last");
        System.out.println(vector);

       /* Enumeration elements()返回此向量的枚举，结合Enumeration接口使用，相当于迭代器。
       boolean hasMoreElements()相当于迭代器里面的hasNext()。
       Object nextElement()相当于next()方法。*/
        Enumeration<String> it = vector.elements();
        while(it.hasMoreElements()){
            String s = it.nextElement();
            System.out.println(s);
        }
    }
}