12.List*

目录

1.集合

1.1 Collection简单结构：

1.2collection接口

1.3 迭代器接口（Iterator）：

1.3.1 原理

2. List接口

2.1 ArrayList类

 2.1.1 性质

2.1.2 底层容量更新机制，源码分析：

2.2 Vector类

 2.2.1 Vector 和 ArrayList 的比较

2.3 LinkedList类

2.3.2 链表类型数据

3.List 及其子类的继承

---

1.集合

对比与数组：

1.动态保存任意多个对象，且数据类型不限制

2.一系列方便的操作对象的方法

3.添加删除新元素很简洁

1.1 Collection简单结构：

        List是有序的可以重复的，这一点体现在可以按序列下角标进行操作，而Set大多是无序的（不是绝对的）且不能重复的。List可以用一个数组刻画，而Set像是数学中的集合概念，将一个集合和另一个集合进行并集运算，相同元素只会留下一个。

1. 集合主要是单列集合和双列集合
2. collection接口有两个子接口 list ，set，实现子类都是单列集合

1.2collection接口

1. 可以存放多个元素，可以是object
2. 有些类可以重复元素，有些不可以
3. 有些有序有些无序
4. 常用方法：

          a.add(0) // 添加
          a.remove(0) //删除
          a.contains(0) //查找元素是否存在
          a.size() //返回数组元素个数
          a.isEmpty() //判断是否为空
          a.clear() //清空
          a.addAll(a) //添加数组
          a.containsAll(0) //判断多个元素
          a.removeAll(a) //删除多个元素
   

5. 所有方法：

Modifier and Type	Method and Description
boolean	add(E e) 确保此集合包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合（可选操作）。
void	clear() 从此集合中删除所有元素（可选操作）。
boolean	contains(Object o) 如果此集合包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c) 如果此集合包含指定 集合中的所有元素，则返回true。
boolean	equals(Object o) 将指定的对象与此集合进行比较以获得相等性。
int	hashCode() 返回此集合的哈希码值。
boolean	isEmpty() 如果此集合不包含元素，则返回 true 。
Iterator<E>	iterator() 返回此集合中的元素的迭代器。
default Stream<E>	parallelStream() 返回可能并行的 Stream与此集合作为其来源。
boolean	remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c) 删除指定集合中包含的所有此集合的元素（可选操作）。
default boolean	removeIf(Predicate<? super E> filter) 删除满足给定谓词的此集合的所有元素。
boolean	retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
int	size() 返回此集合中的元素数。
default Spliterator<E>	spliterator() 创建一个Spliterator在这个集合中的元素。
default Stream<E>	stream() 返回以此集合作为源的顺序 Stream 。
Object[]	toArray() 返回一个包含此集合中所有元素的数组。
<T> T[]	toArray(T[] a) 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

1.3 迭代器接口（Iterator<E>）：

1. 迭代器对象主要用于遍历c接口实现对象,每一个实现collection接口对象都有迭代器方法，用以返回一个迭代器对象
2. 迭代器仅用于遍历集合

3. default void	forEachRemaining(Consumer<? super E> action) 对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。
   boolean	hasNext() 如果迭代具有更多元素，则返回 true 。
   E	next() 返回迭代中的下一个元素。
   default void	remove()

1.3.1 原理

1. 通过集合实例创建迭代器

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

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

        Collection collection = new ArrayList(10);
        Iterator iterator = collection.iterator();


    }
}

2.在使用迭代器遍历集合的时候 hasNext() 要作为while的判断条件，用next（）方法来获取数组元素内容，并下移指针（不使用hasNext() 判断则下一条记录无效，next（）方法会抛出NoSuchElementException异常）快捷键itit+enter生成迭代器遍历while模板

        ArrayList<Object> list = new ArrayList<>();
        list.add(1);
        list.add("string");
        Iterator<Object> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }

3.遍历完一次就要初始化指针

iterator = collection.iterator();

4.也可以使用增强for 循环进行遍历（底层还是迭代器） I+enter

        ArrayList<Object> list = new ArrayList<>();
        list.add(1);
        list.add("string");
        for (Object next : list) {
            System.out.println(next);
        }

（ctrl+j 显示所有快捷键）

2. List接口

1.有序的（添加顺序取出顺序一致），可以重复的

2.每个元素都有对应的顺序索引（底层是数组）从0开始的

3.常用方法：

1) void add(int index, Object ele):在index位置插入ele元素
2) boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
3) Object get(int index):获取指定index位置的元素
4) int indexOf(Object obj)：返回obj在集合中首次出现的位置
5) int lastlndexOf(Object obj)：返回obj在当前集合中末次出现的位置
6) Object remove(int index):移除指定index位置的元素，并返回此元素
7) Object set(int index, Object ele):设置指定index位置的元素为ele相当于是替换.
8) List subList(int fromIndex, int toIndex):返回从fromlndex到tolndex位置的子集合

2.1 ArrayList类

    public static void main(String[] args) {


        List arraylist = new ArrayList(10);
        //添加元素(有序，可以重复)
        arraylist.add("nam3");
        arraylist.add(10);
        arraylist.add(10);
        arraylist.add('c');
        arraylist.add(null);
        arraylist.add(null);
        //若要删除10元素：
        arraylist.remove((Integer)10);
        
        // 方法一，迭代器遍历，生成迭代器（相当于一个指针）
        Iterator ptr = arraylist.iterator();
        //hasnext方法：用于判断是否还有下一个元素
        //快捷键 (itit+enter) 生成while循环模板
        while(ptr.hasNext()){
            //指针下移
            System.out.println(ptr.next()); //返回下一个元素的value
        }        /*
         nam3
         10
         c
         null
         null
         * */
        // 迭代器指针初始化，为下一次迭代器遍历做准备
        ptr = arraylist.iterator();

        //方法2，增强for循环输出：（快捷键I+enter）
        for(Object o:arraylist){
            System.out.println(o);
        }/*
        nam3
        10
        c
        null
        null
        * */
        System.out.println(arraylist.toString()); //[nam3, 10, c, null]

    }

 2.1.1 性质

1.可以放null，

2.底层是数组实现的

3.基本等同于vector ，但arraylist线程不安全的（没有synchronize），但效率高，多线程不建议使用

2.1.2 底层容量更新机制，源码分析：

1. 维护了一个object数组elementData[]，transient Object[] elementData;
2. 创建arraylist对象时，如使用无参构造器，则数组容量为0 ，第一次添加数据，则扩容为10容量，如需要再次扩容，则容量变为原来的1.5倍
3. 如果第一次使用的指定容量构造器，则以后再次扩容则直接按照1.5倍扩容。

2.2 Vector类

1.底层也是一个对象数组

2.线程同步，线程安全

 2.2.1 Vector 和 ArrayList 的比较

Vector 和 ArrayList 的比较

	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组	JDK1.2	不安全，效率高	有参1.5倍， 无参先10，第二次以后1.5倍
Vector		JDK1.0	安全，效率不高	有参2倍 无参第一次10，以后2倍

2.3 LinkedList类

2.3.1 性质

1.底层实现双向链表和双端队列特点；

2.可以添加任意数据包括null

3.无线程安全

2.3.2 链表类型数据

1. first指向链表第一个节点，last指向最后一个节点，链表里存放了一个Node内部类
2. 每个节点，里面维护了三个属性，其中prev指向前一个，next指向后一个，实现双向链表，
3. 所以LinkedList的添加和删除不是通过数组完成，通过改变next和prev的指向来实现链表节点的增删；

 

3.List 及其子类的继承

        由于他们都没有final修饰符，是可以进行继承的，用于其重写方法。