List的概述及其方法使用

List集合

List集合允许出现重复值，而且存储的元素有序（和存储的顺序一致）初始容量为10。

List接口是public interface List extends Collection ，其实现类有ArrayList、LinkedList、Vector

这些类都直接继承自AbstractList

List基本方法

• 集合转数组，集合和数组是形影不离的，而且集合可以理解为是数组的升级版。

需要注意的是集合中只能存储引用类型。而数组中既可以存储引用类型，也可以存储基本类型。

    public static void main(String[] args) {

        List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("b");

        // 集合转数组   toArray()方法，通过Object接收
        Object[] obj = list.toArray();
        System.out.println(Arrays.toString(obj));

        List<String> l = new ArrayList<String>();
            l.add("a");
            l.add("b");
            l.add("c");

        // 集合转数组   toArray()方法，需要强制类型转换 通过Object接收
        String[] o = (String[]) l.toArray(new String[l.size()]);
        System.out.println(Arrays.toString(o));
    }

运行结果

[a, b, c, b]
[a, b, c]

• 可变参数

    public static void main(String[] args) {
        // 测试可变参数,参数中只能存在一个可变参数，当多个参数时，可变参数只能放在最后一个
        test("1",2,3,4);

        // 数组转集合
        Integer[] array = new Integer[]{1,2,3,4};
        List<Integer> li = Arrays.asList(array);// 传入一个可变参数
        System.out.println(li);
    }

 	/**
     * 测试可变参数
     * @param a
     * @param b
     */
    public static void test(String a,int...b){
        System.out.println(a);
        System.out.println(Arrays.toString(b));
    }

运行结果

1
[2, 3, 4]
[1, 2, 3, 4]

• 自定义集合排序

我们知道List集合存储的元素是按照我们存储的顺序存储，所以我们可以通过自己定义排序顺序进行排序。

排序类

import java.util.Comparator;

/**
 * 字符串比较类,实现Comparator接口
 */
public class StrnigComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
}

测试类

public static void main(String[] args) {

        List list = new ArrayList();
            list.add("f");
            list.add("b");
            list.add("a");
            list.add("c");
            list.add("b");

            // 自定义排序
            list.sort(new StrnigComparator());
        System.out.println(list);

        // 条件删除，删除集合中所有满足条件的元素
        list.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                return o.equals("b");
            }
        });

        System.out.println(list);


        System.out.println(list.get(2));// 通过索引获得集合中元素
        System.out.println(list.indexOf("c"));// 通过元素值获得其在集合中的索引值
    	list.set(1,"t");// 直接替换掉原来集合中的元素
        System.out.println(list);
    }

运行结果

[a, b, b, c, f]
[a, c, f]
f
1
[a, t, f]

ArrayList实现类

• ArrayList初始容量为10，增长倍数为1.5倍.
• 底层数据结构是:数组
• 一定要观察其API，由于ArrayList中removeRange方法时受保护的，所以必须继承自ArrayList的类才能访问到该方法，不要大意。

package com.wenhua.project.Day1120;

import java.util.ArrayList;

/**
 * 调用ArrayList中的受保护方法removeRange
 */
public class RemoveRangeDemo extends ArrayList {

    public static void main(String[] args) {

        RemoveRangeDemo rd = new RemoveRangeDemo();
        rd.add("a");
        rd.add("b");
        rd.add("b");
        rd.add("d");
        rd.add("e");
        rd.add("f");
        rd.add("g");
        System.out.println(rd);
        rd.removeRange(1,3);// 直接修改原集合
        System.out.println(rd);
        System.out.println(rd.subList(2,4));// 从原集合中截取，但是原集合不变
        System.out.println(rd);
    }
}

运行结果

[a, b, b, d, e, f, g]
[a, d, e, f, g]
[e, f]
[a, d, e, f, g]

LinkedList集合

    public static void main(String[] args) {

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

        link.add("Java");

        link.add("JDK");

        link.add("JRE");

        link.add("JVM");

        // 由于LinkedList底层是双向链表,所以可以调用一下的方法
        System.out.println(link.getFirst());// 获得链表的第一个元素
        System.out.println(link.lastIndexOf("JDK"));// 获得指定对象的索引值,从零开始
        System.out.println(link.getLast());// 获得链表的最后一个元素
        System.out.println(link.get(2));// 通过索引值获得对象
    }

运行结果

java
1
JVM
JRE

集合遍历

public static void main(String[] args) {

        List list = new ArrayList();

        list.add("a");
        list.add("c");
        list.add("b");
        list.add("d");

        // for循环遍历
        for(int i = 0 ; i < list.size() ; i++){
            System.out.print(list.get(i));
        }

        System.out.println();
        // 增强for循环，不能操作只能遍历
        for (Object obj :list) {
            System.out.print(obj);
        }

        // Iterator迭代器遍历
        Iterator iter = list.iterator();
        while(iter.hasNext()){
            System.out.print(iter.next());
        }
    	
    	// ListIterator迭代器遍历:这种遍历只针对List集合
    	ListIterator<Integer> Liter = list.listIterator();
        while(Liter.hasNext()){
            System.out.println(Liter.next());
        }
}