Java 集合 List

List集合表明一个元素有序、可重复的集合，集合中每一个元素都有其对应的顺序索引。List集合能够经过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引。

Java8改进的List接口和ListIterator接口

普通方法

List是有序集合，所以List集合里增长了一些根据索引来操做集合元素的方法

• void add(int index, Object element)：将元素element插入到List集合的index处

• boolean addAll(int index, Collection c)：将集合c所包含的全部元素都插入到List集合的index处

• Object get(int index)：返回集合index索引处的元素

• int indexOf(Object o)：返回对象o在List集合中第一次出现的位置索引

• int lastIndexOf(Object o)：返回对象o在List集合中最后一次出现的位置索引

• Object remove(int index)：删除并返回index索引处的元素

• Object set(int index, Object element)：将index索引处的元素替换成element对象，返回被替换的旧元素

• List subList(int fromIndex, int toIndex)：返回从索引fromIndex（包含）到索引toIndex（不包含）处全部集合元素组成的子集合

import java.util.*;

public class ListTest3 
{
    public static void main(String[] args) 
    {
        List teams = new ArrayList();
        //向teams集合中添加三个元素
        teams.add(new String("克利夫兰骑士"));
        teams.add(new String("金州勇士"));
        teams.add(new String("俄克拉荷马雷霆"));
        System.out.println(teams);
        //将新字符串对象插入在第二个位置
        teams.add(1, new String("费城76人"));        
        for (int i = 0 ; i < teams.size() ; i++ )
        {
            System.out.println(teams.get(i));
        }
        //删除第3个元素
        teams.remove(2);
        System.out.println(teams);
        //判断指定元素在List集合中的位置：输出1，代表位于第二位
        System.out.println(teams.indexOf(new String("费城76人")));        ①
        //将第二个元素替换成新的字符串对象
        teams.set(1, new String("洛杉矶快船"));
        System.out.println(teams);
        //将teams集合的第二个元素（包括）
        //到第三个元素（不包括）截取成子集合
        System.out.println(teams.subList(1, 2));
    }
}

[克利夫兰骑士, 金州勇士, 俄克拉荷马雷霆]
克利夫兰骑士
费城76人
金州勇士
俄克拉荷马雷霆
[克利夫兰骑士, 费城76人, 俄克拉荷马雷霆]
1
[克利夫兰骑士, 洛杉矶快船, 俄克拉荷马雷霆]
[洛杉矶快船]

从代码①处可知，List判断两个对象相等的标准只要equals()方法返回true便可

默认方法

• void replaceAll(UnaryOperator operator)：根据operator指定的计算规则从新设置List集合的全部元素

• void sort(Comparator c)：根据Comparator参数对List集合的元素排序

import java.util.*;

public class ListTest3
{
    public static void main(String[] args)
    {
        List teams = new ArrayList();
        // 向books集合中添加4个元素
        teams.add(new String("克利夫兰骑士"));
        teams.add(new String("金州勇士"));
        teams.add(new String("俄克拉荷马雷霆"));
        teams.add(new String("费城76人"));
        // 使用目标类型为Comparator的Lambda表达式对List集合排序
        teams.sort((o1, o2)->((String)o1).length() - ((String)o2).length());
        System.out.println(teams);
        // 使用目标类型为UnaryOperator的Lambda表达式来替换集合中全部元素
        // 该Lambda表达式控制使用每一个字符串的长度做为新的集合元素
        teams.replaceAll(ele->((String)ele).length());
        System.out.println(teams); // 输出[4, 5, 6, 7]
    }
}

ListIterator方法

ListIterator()方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操做List的方法，ListIterator接口在Iterator接口基础上增长了以下方法

• boolean hasPrevious()：返回该迭代器相关的集合是否还有上一个元素

• Object previous()：返回该迭代器的上一个元素

• void add(Object o)：在指定位置插入一个元素

ListIterator与Iterator对比

• ListIterator增长了向前迭代的功能，Iterator只能向后迭代

• ListIterator能够经过add()方法向List集合中添加元素，Iterator只能删除元素

import java.util.*;
public class ListIteratorTest
{
    public static void main(String[] args)
    {
        String[] teams = {
            "金州勇士", "俄克拉荷马雷霆",
            "克利夫兰骑士"
        };
        List teamList = new ArrayList();
        for (int i = 0; i < teams.length ; i++ )
        {
            teamList.add(teams[i]);
        }
        ListIterator lit = teamList.listIterator();
        while (lit.hasNext())
        {
            System.out.println(lit.next());
            lit.add("-------分隔符-------");
        }
        System.out.println("=======下面开始反向迭代=======");
        while(lit.hasPrevious())
        {
            System.out.println(lit.previous());
        }
    }
}

金州勇士
俄克拉荷马雷霆
克利夫兰骑士
=======下面开始反向迭代=======
-------分隔符-------
克利夫兰骑士
-------分隔符-------
俄克拉荷马雷霆
-------分隔符-------
金州勇士

ArrayList和Vector实现类

ArrayList和Vector都是基于数组实现的List类，因此ArrayList和Vector类封装了一个动态的、容许再分配的Object[]数组。initialCapacity参数用来设置该数组的长度，若是向ArrayList和Vector添加大量元素时，可以使用ensureCapacity(int minCapacity)方法一次性增长initialCapacity。减小重分配次数，提供性能

建立空的ArrayList和Vector集合时不指定initialCapacity参数，则Object[]数组的长度默认为10

从新分配Object[]数组的方法

• void ensureCapacity(int minCapacity)：将ArrayList和Vector集合的长度增长大于或大于minCapacity值

• void trimToSize()：调整ArrayList和Vector集合的Object[]数组长度为当前元素的个数。调用该方法可减小ArrayList和Vector集合对象占用的存储空间

Vector的系列方法名长，具备不少缺点，一般尽可能少用Vector实现类

ArrayList和Vector的区别

• ArrayList是线程不安全，当多个线程访问同一个ArrayList集合时，若是有超过一个线程修改了ArrayList集合，则程序必须手动保证该集合的同步性

• Vector是线程安全，无须程序保证该集合的特别想，也由于线程安全，Vector的性能比ArrayList的性能低

• Collections工具类能够将一个ArrayList变成线程安全，所以依然不推荐Vector实现类

固定长度的List

操做数组的工具类：Arrays，该工具类提供了asList(Object.. a)方法，能够把一个数组或者指定个数的对象转换成一个List集合，这个List集合既不是ArrayList实现类的实例，也不是Vector实现类的实例，而是Arrays的内部类ArrayList的实例

Arrays.ArrayList是一个固定长度的List集合，程序只能遍历访问该集合里的元素，不可增长、删除该集合里的元素

import java.util.*;

public class FixedSizeList
{
    public static void main(String[] args)
    {
        List fixedList = Arrays.asList("克利夫兰骑士", "金州勇士");
        // 获取fixedList的实现类，将输出Arrays$ArrayList
        System.out.println(fixedList.getClass());
        // 使用方法引用遍历集合元素
        fixedList.forEach(System.out::println);
        // 试图增长、删除元素都会引起UnsupportedOperationException异常
        fixedList.add("俄克拉荷马雷霆");
        fixedList.remove("金州勇士");
    }
}