List集合

集合

为了保存数量不确定的数组，以及保存具有映射关系的数据。Java提供了集合类。集合类主要负责保存、盛装其他数据。因此集合也被称为容器类。
集合和数组的区别：
1.数组可以保存基本数据类型也可以保存引用数据类型，集合只能保存引用数据类型。
2.数组的长度是固定的而集合的长度是可变的
3.数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
Java的集合主要由两个接口派生：Collection和Map，这两个时Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。下图显示了Collection体系。

Collection常用方法
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
void clear():移除所有元素
oolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 如果没有交集元素 则删除失败 返回false
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
ean isEmpty()：判断集合是否为空
Iterator iterator()(重点)
nt size():元素的个数
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集
Object[] toArray()
下面给出常用方法的使用

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDeom {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("School");
        collection.add("Home");
        System.out.println(collection);
        Collection collection1 = new ArrayList();
        collection1.add("Libiary");
        collection1.add("restaurant");
        System.out.println(collection);
        collection1.addAll(collection);
        System.out.println(collection1);
        collection1.removeAll(collection);
        System.out.println(collection);
        System.out.println(collection.contains("school"));
        System.out.println(collection.isEmpty());
        System.out.println(collection.size());
    }
}

集合的遍历
方法1.
将集合转化为数组然后遍历输出每个元素

public class CollectionDeom {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("School");
        collection.add("Home");
        collection.add("Library");
        collection.add("restaurant");
        Object [] o = collection.toArray();
        for(Object obj: o){
            System.out.println((String)obj);
        }

    }
}

方法2.

public class CollectionDeom {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("School");
        collection.add("Home");
        collection.add("Library");
        collection.add("restaurant");
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            Object o = iterator.next();
            System.out.println((String)o);
        }

    }
}

List

元素有序,并且每一个元素都存在一个索引.元素可以重复。
List常用方法
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素

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

public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1,1);
        list.add(1,2);
        list.add(3,3);
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
        int i = (int)list.get(0);
        System.out.println(i);
        list.set(1,100);
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
    }
    }

List遍历
方法1.
使用size和ge’t

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

public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(0,1);
        list.add(1,2);
        list.add(2,3);
        
        for(int i = 0;i < list.size();i++){
            Object o = list.get(i);
            System.out.println((int)o);
        }
    }
}

方法2.
利用ListIterator

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

public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(0,1);
        list.add(1,2);
        list.add(2,3);

        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
            Object o = listIterator.next();
            System.out.println((int)o);
        }

    }
}

List子类
List的三个子类的特点
ArrayList:底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
Vector:底层数据结构是数组，查询快，增删慢。线程安全，效率低。
LinkedList:底层数据结构是链表，查询慢，增删快。线程不安全，效率高。
我们可以根据需求，灵活选取需要的集合

ArrayList

ArrayList 是实现 List 接口的动态数组，所谓动态就是它的大小是可变的。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个 ArrayList 实例都有一个容量，该容量是指用来存储列表元素的数组的大小。默认初始容量为 10。随着 ArrayList 中元素的增加，它的容量也会不断的自动增长。在每次添加新的元素时，ArrayList 都会检查是否需要进行扩容操作，扩容操作带来数据向新数组的重新拷贝，所以如果我们知道具体业务数据量，在构造 ArrayList 时可以给 ArrayList 指定一个初始容量，这样就会减少扩容时数据的拷贝问题。当然在添加大量元素前，应用程序也可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量，这可以减少递增式再分配的数量。

注意，ArrayList 实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。所以为了保证同步，最好的办法是在创建时完成，以防止意外对列表进行不同步的访问：
构造函数
ArrayList 提供了三个构造函数：
ArrayList()：默认构造函数，提供初始容量为 10 的空列表。
ArrayList(int initialCapacity)：构造一个具有指定初始容量的空列表。
ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

import java.util.*;
public class Test {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
	}
}

基本方法

方法	作用	内部实现
boolean contains(Object o)	返回列表中包含指定的元素	内部调用indexOf()方法进行判断，遍历列表进行查询，需要注意的是需要实现equals方法比较对象是否相等
E get(int index)	返回此列表中指定位置上的元素	内部主要两步，首先检查索引，然后获取数组对象索引的元素
E set(int index, E element)	用指定元素替代指定位置上的元素	需要注意的是该方法还会返回老的元素的值，内部主要三步，首先检查索引，然后获取老的元素，赋值并返回
E remove(int index)	删除指定位置上的元素	内部实现步骤为 1.检查索引 2.获取老的元素 3.将index后的元素向前移动 4.最后一个元素置为null并返回老的元素
boolean remove(Object o)	删除列表中首次出现指定元素（如果存在）	内部实现为 1.判断为NULL，若是则遍历并删除 2.若不是则遍历并删除

import java.util.*;
public class Test {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		boolean b = list.contains(2);
		int i = list.get(2);
		list.set(0,0);
		list.remove(1);
	}
}

遍历ArrayList
方法1.for循环

for (int i = 0; i < arrayList.size(); i++) {
    System.out.println(arrayList.get(i));
}

方法2.迭代器

Iterator<Integer> ite = arrayList.listIterator();
while (ite.hasNext()){
    System.out.println(ite.next());
}

Vector

Vector 可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。不过，Vector 的大小是可以增加或者减小的，以便适应创建 Vector 后进行添加或者删除操作。

Vector 实现 List 接口，继承 AbstractList 类，所以我们可以将其看做队列，支持相关的添加、删除、修改、遍历等功能。
基本方法
public void addElement(E obj) //向集合中添加一个元素
public E elementAt(int index)//获取索引位置的集合
public Enumeration elements()//迭代器

        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
  
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);

        }

遍历Vector
1.随机访问

    for(int i = 0 ; i < vec.size() ; i++){
           value = vec.get(i);
        }

2、迭代器

    Iterator it = vec.iterator();
        while(it.hasNext()){
            value = it.next();
            //do something
        }

3、for 循环

    for(Integer value:vec){
            //do something
        }

3Enumeration 循环

    Vector vec = new Vector<>();
        Enumeration enu = vec.elements();
        while (enu.hasMoreElements()) {
            value = (Integer)enu.nextElement();
        }

LinkedList

LinkedList 与 ArrayList 一样实现 List 接口，只是 ArrayList 是 List 接口的大小可变数组的实现，LinkedList 是 List 接口链表的实现。基于链表实现的方式使得 LinkedList 在插入和删除时更优于 ArrayList，而随机访问则比 ArrayList 逊色些。
LinkedList 实现所有可选的列表操作，并允许所有的元素包括 null。
构造方法
在源码中，LinkedList主要提供了两个构造方法，
1.public LinkedList() ：空的构造方法，啥事情都没有做
2.public LinkedList(Collection<? extends E> c) : 将一个元素集合添加到LinkedList中
增添方法
add(E e): 将指定元素添加到此列表的结尾
add(int index, E element)：在此列表中指定的位置插入指定的元素。
addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表。
addFirst(E e): 将指定元素插入此列表的开头。
addLast(E e): 将指定元素添加到此列表的结尾。
删除方法
remove(Object o)：从此列表中移除首次出现的指定元素（如果存在）。
clear()： 从此列表中移除所有元素。
remove()：获取并移除此列表的头（第一个元素）。
remove(int index)：移除此列表中指定位置处的元素。
remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。
removeFirst()：移除并返回此列表的第一个元素。
removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
removeLast()：移除并返回此列表的最后一个元素。
removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
查找方法
get(int index)：返回此列表中指定位置处的元素。
getFirst()：返回此列表的第一个元素。
getLast()：返回此列表的最后一个元素。
indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1