码迷，mamicode.com
首页 > 其他好文 > 详细

20、集合（List接口补充）

时间：2020-05-12 20:42:59      阅读：71      评论：0      收藏：0      [点我收藏+]

标签：情况下   dex   count   first   集合   tca   etl   大数   ansi   

List接口

List接口：元素有序，可重复，集合中每个元素都有其对应的索引。

常用实现类有：ArrayList、LinkedList、Vector。

ArrayList源码

JDK 1.7情况下：

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

使用空参构造器创建集合，底层创建了长度为10的Object类型数组elementData。

扩容机制：

int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
//扩容为原来的1.5倍
elementData = Arrays.copyOf(elementData, newCapacity);

Arrays数组工具类的copyOf()拷贝原数组，底层会根据newCapacity创建一个新的数组，然后

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

这样，返回的copy数组是一个大数组，其余元素均为0。

JDK 1.8情况下：

通过空参构造器创建集合

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

通过有参构造器创建集合

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}
transient Object[] elementData;
private static final Object[] EMPTY_ELEMENTDATA = {};

当使用add()方法向空参创建的集合中添加元素时：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

首先确保内部容量，ensureCapacityInternal(1)，先看内部的容量是否大于1，

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

首先计算容量，

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

if的条件表达式返回true，return Math.max(10, 1)；所以返回10。

private static final int DEFAULT_CAPACITY = 10;

计算完容量后，执行ensureExplicitCapacity(10)方法；

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

if的条件表达式返回true（minCapacity = 10），执行扩容。

扩容机制和JDK 1.7一致。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //0
    if (newCapacity - minCapacity < 0)
        //0 - 10 < 0
        newCapacity = minCapacity;
    	//newCapacity = 10
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
    //elementData = Arrays.copyOf(elementData, 10);
}

方法弹栈，继续执行add(E e)方法。

elementData[size++] = e;
return true;

elementData[0] = e，size = 1;

结论：JDK 1.7是饿汉式创建elementData，而JDK 1.8是懒汉式创建elementData，在第一次add添加时再扩容。

并发修改异常

Java容器有一种保护机制，能够防止多个进程同时修改同一个容器的内容。如果你在迭代遍历某个容器的过程中，另一个进程介入其中，并且插入，删除或修改此容器的某个对象，就会立刻抛出ConcurrentModificationException。

使用迭代器删除集合元素

package org.westos.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

/**
 * @author lwj
 * @date 2020/5/12 14:23
 */
public class MyTest {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaa");
        strings.add("bbb");
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            iterator.remove();
        }
        //删除集合中的元素
        //增强for不能在遍历途中修改集合，要想在遍历过程中修改集合，只能使用迭代器或者普通for循环
        System.out.println(strings);
        //[]
    }
}

LinkedList源码

LinkedList，泛型类，继承泛型抽象类，泛型接口，暂不声明类型，等到创建对象时声明类型。

LinkedList<String> strings = new LinkedList<>();

将参数"String"传递给E类型，即Node节点的值域存储字符串类型。当传递自定义类型时，

LinkedList<Student> students = new LinkedList<>();

Node节点的值域就存储Student类型数据。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    transient int size = 0;
    transient Node<E> first;
    //第一个节点node的指针
    transient Node<E> last;
    //最后一个节点的指针
}

Node是LinkedList的静态内部泛型类，和LinkedList共用一个类型，定义了一个节点类，包含item域，next后驱节点，prev前驱结点。

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

当使用add(E e)方法向链表中增加元素时，

public boolean add(E e) {
    linkLast(e);
    return true;
}
//linkLast(e) 链接e作为最后一个元素
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    //prev = l, item = e, next = null
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

方法addLast(E e)和add(E e)逻辑相同，但是返回值为void；

public void addLast(E e) {
    linkLast(e);
}

方法addFirst(E e)底层调用linkFirst(E e)；

public void addFirst(E e) {
    linkFirst(e);
}

private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

方法add(int index, E e)底层：

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

插入节点，首先调用node(index)找到待插入位置的节点。

删除节点

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

package org.westos.demo;

import java.util.LinkedList;

/**
 * @author lwj
 * @date 2020/5/12 15:44
 */
public class MyTest2 {
    public static void main(String[] args) {
        LinkedList<String> strings = new LinkedList<>();
        strings.add("aaa");
        strings.addLast("bbb");
        strings.addFirst("ccc");

        System.out.println(strings);
        //[ccc, aaa, bbb]

        strings.add(1, "ddd");

        System.out.println(strings);
        //[ccc, ddd, aaa, bbb]

        String remove = strings.remove(3);
        System.out.println(remove);
        //bbb
        System.out.println(strings);
        //[ccc, ddd, aaa]
    }
}

List接口的常用方法

LinkedList，双向链表，内部没有声明数组（不是数组实现），而是定义了Node<E>类型的first和last，用于记录首尾元素。同时，定义内部类Node<E>，作为LinkedList中保存数据的基本结构。

List接口除了从Collection接口继承的方法外，List接口添加了一些根据索引来操作集合元素的方法。

方法名 描述
void add(int index, E element) 将指定元素插入此列表的指定位置
void addAll(int index, Collection<? extends E> c) 将指定集合插入此列表的指定位置
E get(int index) 返回此列表中指定位置的元素
int indexOf(Object o) 返回此列表中指定元素第一次出现的索引
int lastIndexOf(Object o) 返回此列表中指定元素最后一个出现的索引
E remove(int index) 删除此列表中指定位置的元素
E set(int index , E element) 用指定的元素替换此列表中指定位置的元素
List<E> subList(int fromIndex, int toIndex) 返回此列表中指定的fromIndex到toIndex的元素集合 
package org.westos.demo;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
 * @author lwj
 * @date 2020/5/12 18:56
 */
public class MyTest3 {
    public static void main(String[] args) {
        LinkedList<String> strings = new LinkedList<>();
        strings.add(0, "aaa");
        strings.add(1, "bbb");
        strings.add(2, "ccc");
        strings.addFirst("AAA");
        strings.addLast("CCC");
        System.out.println(strings);
        //[AAA, aaa, bbb, ccc, CCC]

        strings.addAll(5, Arrays.asList("ddd", "DDD"));
        System.out.println(strings);
        //[AAA, aaa, bbb, ccc, CCC, ddd, DDD]

        String remove = strings.remove(0);
        //删除指定索引的元素
        System.out.println(remove);
        //AAA
        System.out.println(strings);
        //[aaa, bbb, ccc, CCC, ddd, DDD]
        //strings.removeFirst();
        //strings.removeLast();

        String s = strings.get(0);
        //根据索引返回元素
        System.out.println(s);
        //aaa
        String first = strings.getFirst();
        System.out.println(first);
        //aaa
        String last = strings.getLast();
        System.out.println(last);
        //DDD


        int bbb = strings.indexOf("bbb");
        System.out.println(bbb);
        //1
        int ccc = strings.lastIndexOf("ccc");
        System.out.println(ccc);
        //2

        String aaa = strings.set(0, "AAA");
        System.out.println(aaa);
        //aaa
        System.out.println(strings);
        //[AAA, bbb, ccc, CCC, ddd, DDD]

        List<String> strings1 = strings.subList(0, 3);
        System.out.println(strings1);
        //[AAA, bbb, ccc]
        System.out.println(strings);
        //[AAA, bbb, ccc, CCC, ddd, DDD]
    }
}

总结：

增：add(Object obj)/add(int index, E e)/addFirst(E e)/addLast(E e)/addAll(Collection c)/addAll(int index, Collection c)

删：remove(Object obj)/remove(int index)/removeFirst()/removeLast()

改：set(int index, E element)

查：get(int index)/getFirst()/getLast()

List的遍历方法

除了普通for循环+size()方法、增强for循环、Iterator接口外，新增了一个ListIterator接口。

package org.westos.demo;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/**
 * @author lwj
 * @date 2020/5/12 19:30
 */
public class MyTest4 {
    public static void main(String[] args) {
        LinkedList<String> strings = new LinkedList<>(Arrays.asList("aaa", "bbb", "ccc"));
        //1、普通for循环 + size()
        for (int i = 0; i < strings.size(); i++) {
            System.out.println(strings.get(i));
        }
        //2、增强for循环
        for (String string : strings) {
            System.out.println(string);
        }
        //3、Iterator
        Iterator<String> iterator = strings.iterator();
        /*
        public Iterator<E> iterator() {
            return listIterator();
        }
         */
        System.out.println(iterator);
        //java.util.LinkedList$ListItr@1b6d3586
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //4、ListIterator
        ListIterator<String> stringListIterator = strings.listIterator();
        System.out.println(stringListIterator);
        //java.util.LinkedList$ListItr@4554617c
        //private class ListItr implements ListIterator<E> {}
        while (stringListIterator.hasNext()) {
            System.out.println(stringListIterator.next());
        }
        //5、ListIterator从后向前遍历
        ListIterator<String> stringListIterator1 = strings.listIterator(strings.size());
        while (stringListIterator1.hasPrevious()) {
            System.out.println(stringListIterator1.previous());
        }
    }
}

练习题

remove(int index)和remove(Object o)

package org.westos.demo;

import java.util.Arrays;
import java.util.LinkedList;

/**
 * @author lwj
 * @date 2020/5/12 19:42
 */
public class MyTest5 {
    public static void main(String[] args) {
        LinkedList<Integer> integers = new LinkedList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
        Integer remove = integers.remove(2);
        //删除集合中索引为2的元素
        System.out.println(remove);
        //3
        //根据索引删除，返回原索引位置的值

        //如果想要删除值为2的元素呢
        boolean remove1 = integers.remove(Integer.valueOf(2));
        System.out.println(remove1);
        //true
        //删除值，返回boolean类型

        System.out.println(integers);
        //[1, 4, 5, 6]
    }
}

20、集合（List接口补充）

标签：情况下   dex   count   first   集合   tca   etl   大数   ansi   

原文地址：https://www.cnblogs.com/shawnyue-08/p/12878241.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！