开发者社区> 弗兰克的猫> 正文

【Java入门提高篇】Day20 Java容器类详解(三)List接口

简介:   今天要说的是Collection族长下的三名大将之一,List,Set,Queue中的List,它们都继承自Collection接口,所以Collection接口的所有操作,它们自然也是有的。   List,Set,Queue,分别是列表,集合,队列的意思,代表着Collection家族下的三种不同的势力,它们各有所长,也各有所短,就像骑兵,步兵和水兵,各有各的优势,并没有谁一定比谁更好的说法,合适的才是最好的。
+关注继续查看

  今天要说的是Collection族长下的三名大将之一,List,Set,Queue中的List,它们都继承自Collection接口,所以Collection接口的所有操作,它们自然也是有的。

  List,Set,Queue,分别是列表,集合,队列的意思,代表着Collection家族下的三种不同的势力,它们各有所长,也各有所短,就像骑兵,步兵和水兵,各有各的优势,并没有谁一定比谁更好的说法,合适的才是最好的。接下来,将会分别介绍这三名大将,从中你也会看到它们各自的特点。

  本篇先来介绍一下List接口。

  我们先来看看List的源码:

public interface List<E> extends Collection<E> {
    // 查询接口

    /**
     * 列表元素个数
     */
    int size();

    /**
     * 是否为空
     */
    boolean isEmpty();

    /**
     * 是否包含某元素
     */
    boolean contains(Object o);

    /**
     * 返回一个List迭代器
     */
    Iterator<E> iterator();

    /**
     * 将List转换为Object数组
     */
    Object[] toArray();

    /**
     * 转换为指定类型数组
     */
    <T> T[] toArray(T[] a);

    // 修改操作

    /**
     * 添加元素,成功返回true
     */
    boolean add(E e);

    /**
     * 移除某一个元素,成功返回true
     */
    boolean remove(Object o);

    // 批量操作

    /**
     * 判断是否包含集合C 中的所有元素
     */
    boolean containsAll(Collection<?> c);

    /**
     * 将集合C 中所有元素添加到列表
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 将集合C 中所有元素添加到列表,添加在序号为index的元素之后
     */
    boolean addAll(int index, Collection<? extends E> c);

    /**
     * 从列表中移除集合C 中所有元素
     */
    boolean removeAll(Collection<?> c);

    /**
     * 从列表中移除所有不在集合C 中的元素
     */
    boolean retainAll(Collection<?> c);

    /**
     * 全部替换
     */
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    /**
     * 根据指定的比较器来排序,如果传入的比较器是null,则元素必须实现Comparable 接口
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    /**
     * 移除所有元素
     */
    void clear();

    // 比较和hash

    boolean equals(Object o);

    int hashCode();

    // 根据序号进行的操作

    /**
     * 获取指定序号的元素
     */
    E get(int index);

    /**
     * 替换指定序号的元素
     */
    E set(int index, E element);

    /**
     * 在指定序号的元素后插入元素
     */
    void add(int index, E element);

    /**
     * 移除指定序号的元素
     */
    E remove(int index);

    // 搜索操作

    /**
     * 返回元素第一次出现的位置,如果未找到则返回-1
     */
    int indexOf(Object o);

    /**
     * 返回元素出现的最后一个位置
     */
    int lastIndexOf(Object o);

    // List迭代器

    /**
     * 返回一个List迭代器
     */
    ListIterator<E> listIterator();

    /**
     * 返回一个序号从Index开始的List迭代器
     */
    ListIterator<E> listIterator(int index);

    // 视图

    /**
     * 返回一个子队列,序列从fromIndex到toIndex,包含fromIndex,不包含toIndex
     * 对子队列的修改会影响原队列
     * 如果原队列修改,那么对子队列的影响是未定义的
     */
    java.util.List<E> subList(int fromIndex, int toIndex);

    /**
     * 创建一个可分割的迭代器(用于并行计算)
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

  其实JDK里的注释已经十分丰富,大家平时有时间可以多看看,为了方便阅读,我这里用简单粗暴的语言进行了精简翻译。

  List即列表,存储的是有序集合,里面的元素有序存储,可以重复,所谓有序集合,顾名思义,就是里面的元素存放是有顺序的,每个插入的元素都对应着一个序号,可以根据序号获取元素。

  List支持的操作也很丰富,最常用的增删改查,批量添加,批量替换,批量删除,还有搜索,排序操作,还支持普通迭代器和可分割式迭代器,前者主要用于遍历,后者则主要用于并行式计算,关于迭代器的知识后面会统一介绍。下面是使用常见操作的一个小栗子:

public class Test {

    public static void main(String[] args){
        test();
    }

    static void test(){
        List<Integer> integers = new ArrayList<>();
        List<Integer> integersA = new ArrayList<>();

        //添加元素
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);

        integersA.add(1);
        integersA.add(2);
        integersA.add(33);
        integersA.add(44);
        System.out.println("列表大小:" + integers.size());
        System.out.println("是否为空:" + integers.isEmpty());
        System.out.println("是否包含某元素:" + integers.contains(2));
        System.out.println("是否包含全部元素:" + integers.containsAll(integersA));

        //转换为数组
        Integer[] integerArray = integers.toArray(new Integer[0]);
        System.out.println("遍历数组:");
        for (int i = 0; i < integerArray.length; i++){
            System.out.println(integerArray[i]);
        }
        System.out.println("当前列表integers:" + integers);

        //批量添加
        System.out.println("批量添加元素");
        integers.addAll(integersA);
        System.out.println("当前列表integers:" + integers);

        //移除元素
        System.out.println("移除元素");
        integers.remove(1);
        System.out.println("当前列表integers:" + integers);

        //批量移除
        System.out.println("批量移除元素");
        integers.removeAll(integersA);
        System.out.println("当前列表integers:" + integers);

        //开始替换
        System.out.println("批量替换元素");
        integers.replaceAll(it -> it + 1);
        System.out.println("当前列表integers:" + integers);

        //从列表中移除所有不在集合integersA中的元素
        integersA.add(2);
        integersA.add(4);
        System.out.println("保留元素");
        integers.retainAll(integersA);
        System.out.println("当前列表integers:" + integers);

        //插入
        System.out.println("开始插入");
        System.out.println("当前列表integersA:" + integersA);
        integersA.add(2,155);
        integersA.add(1,125);
        System.out.println("当前列表integersA:" + integersA);

        //排序
        System.out.println("开始排序——使用内部比较器");
        integersA.sort(null);
        System.out.println("当前列表integersA:" + integersA);

        System.out.println("开始排序——使用外部比较器");
        integersA.sort((itA, itB) -> itB - itA);
        System.out.println("当前列表integersA:" + integersA);

        //序号操作
        Integer a = integersA.get(2);
        System.out.println("integersA第三个元素是:" + a);
        System.out.println("开始替换");
        integersA.set(3, 66);
        System.out.println("当前列表integersA:" + integersA);
        System.out.println("开始移除");
        integersA.remove(3);
        System.out.println("当前列表integersA:" + integersA);

        //搜索操作
        System.out.println("查找元素2(第一次出现)位置:" + integersA.indexOf(2));
        System.out.println("查找元素2(最后一次出现)位置:" + integersA.lastIndexOf(2));

        //子队列操作
        List<Integer> subList = integersA.subList(0, 4);
        System.out.println("子队列:" + subList);
        subList.add(5);
        subList.add(5);
        subList.add(5);
        System.out.println("当前子列表:" + subList);
        System.out.println("当前列表integersA:" + integersA);

        integersA.add(1, 233);
        integersA.add(1, 233);
        integersA.add(1, 233);
        System.out.println("当前列表integersA:" + integersA);
        System.out.println("当前子列表:" + subList);
    }
}

  大家可以先想想结果,再下看面的答案。

  实际输出如下:

列表大小:4
是否为空:false
是否包含某元素:true
是否包含全部元素:false
遍历数组:
1
2
3
4
当前列表integers:[1, 2, 3, 4]
批量添加元素
当前列表integers:[1, 2, 3, 4, 1, 2, 33, 44]
移除元素
当前列表integers:[1, 3, 4, 1, 2, 33, 44]
批量移除元素
当前列表integers:[3, 4]
批量替换元素
当前列表integers:[4, 5]
保留元素
当前列表integers:[4]
开始插入
当前列表integersA:[1, 2, 33, 44, 2, 4]
当前列表integersA:[1, 125, 2, 155, 33, 44, 2, 4]
开始排序——使用内部比较器
当前列表integersA:[1, 2, 2, 4, 33, 44, 125, 155]
开始排序——使用外部比较器
当前列表integersA:[155, 125, 44, 33, 4, 2, 2, 1]
integersA第三个元素是:44
开始替换
当前列表integersA:[155, 125, 44, 66, 4, 2, 2, 1]
开始移除
当前列表integersA:[155, 125, 44, 4, 2, 2, 1]
查找元素33(第一次出现)位置:4
查找元素33(最后一次出现)位置:5
子队列:[155, 125, 44, 4]
当前子列表:[155, 125, 44, 4, 5, 5, 5]
当前列表integersA:[155, 125, 44, 4, 5, 5, 5, 2, 2, 1]
当前列表integersA:[155, 233, 233, 233, 125, 44, 4, 5, 5, 5, 2, 2, 1]
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1239)
    at java.util.ArrayList$SubList.listIterator(ArrayList.java:1099)
    at java.util.AbstractList.listIterator(AbstractList.java:299)
    at java.util.ArrayList$SubList.iterator(ArrayList.java:1095)
    at java.util.AbstractCollection.toString(AbstractCollection.java:454)
    at java.lang.String.valueOf(String.java:2994)
    at java.lang.StringBuilder.append(StringBuilder.java:131)
    at com.frank.chapter20.Test.test(Test.java:115)
    at com.frank.chapter20.Test.main(Test.java:15)

  不知道符不符合你的预期,这里关于内部比较器和外部比较器的知识只一笔带过,Integer类型是实现了Comparable接口的,所以sort方法传入null时会使用Integer的内部比较器进行排序,而使用外部比较器时,使用的是Java8的新特性,lamada表达式,省去了方法名和参数类型,因为函数式接口不存在重载方法,所以编译器可以推断出参数类型,这样就不用再大费周章的用new语法去创建一个比较器(当然,只是语法糖而已,如果不是很理解比较器,可以先行百度,后面的文章里也会有详细介绍)。在最后报出了一个ConcurrentModificationException,因为原队列修改后,子队列视图就被破坏了,所以再次访问子视图时就会报错。

  List是最常用的容器类,List最大的特点便是要求元素有序存储,List跟数组相比,最大的优势在于List大小可以动态扩展,但数组支持随机存取,所以当元素个数的固定的时候,使用数组往往效率更高。(当然,一般情况下还是使用List吧,因为支持的操作更加丰富,比如进行排序时不需要自己写算法)。

  一般来说,对元素没有特殊要求,不需要去重存储,没有先进先出的要求的场景下,List是最好的选择。

  List接口下有多个常用的实现类,每个类都有其特点,具体选择哪种类需要根据实际情况进行选择。

  希望大家能通过这篇文章,了解List的主要方法及其使用方法以及常用场景,关于List的常见具体实现类的讲解将在之后的文章里进行说明和比较。

  本篇到此结束,欢迎大家继续关注。

 

真正重要的东西,用眼睛是看不见的。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Kubernetes容器运行时接口-CRI
Kubernetes提供了多种容器开放接口用于对接不同的后端来提供资源,如提供计算资源的容器运行时接口(Container Runtime Interface, CRI),提供网络资源的容器网络接口(Container Network Interface, CNI),提供提供存储资源的容器存储接口(Container Storage Interface, CSI)。这篇作为这系列的开篇,主要介绍了kubelet的CRI接口实现。
537 0
容器和微服务在Hadoop生态系统中找到一席之地
本文讲的是容器和微服务在Hadoop生态系统中找到一席之地【编者的话】容器和微服务凭借构架上的灵活优势,已经杀进了Hadoop生态系统。分别位于德国和美国两家公司的技术高管对此提出了自己的观点。
1799 0
【云栖号案例 | 教育&科研机构】百家云借助“容器+神龙”三天内实现数十倍扩容
受疫情影响百家云的业务量短时间内增长了数十倍,急需扩容。上云后提供弹性计算的空间与敏捷安全的扩容能力、稳定的服务与优异性能。
3105 0
Java入门 - 面向对象 - 06.接口
接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以 interface 来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。 接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。 接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。 在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。
220 0
谷歌助力,快速实现 Java 应用容器化
原文地址:梁桂钊的博客 博客地址:http://blog.720ui.com 欢迎关注公众号:「服务端思维」。一群同频者,一起成长,一起精进,打破认知的局限性。 Google 在 2018 年下旬开源了一款新的 Java 工具 Jib,可以轻松地将 Java 应用程序容器化。
1243 0
Kubernetes必备知识: 容器接口CRI
每种容器运行时各有所长,许多用户都希望Kubernetes支持更多的运行时。在Kubernetes 1.5发布版里,我们引入了CRI–一个能让kubelet无需编译就可以支持多种容器运行时的插件接口。CRI包含了一组protocol buffers,gRPC API,相关的库,以及在活跃开发下的额外规范和工具。CRI目前是Alpha版本。 支持可替换的容器运行时在Kubernetes中概念中并非首次。在1.3发布版里,我们介绍了rktnetes项目,它可以让rkt容器引擎作为Docker容器运行时的一个备选。然而,不管是Docker还是Rkt都需要通过内部、不太稳定的接口直接集成到kubele
386 0
Kubernetes容器运行时接口-CRI
Kubernetes提供了多种容器开放接口用于对接不同的后端来提供资源,如提供计算资源的容器运行时接口(Container Runtime Interface, CRI),提供网络资源的容器网络接口(Container Network Interface, CNI),提供提供存储资源的容器存储接口(Container Storage Interface, CSI)。
743 0
+关注
弗兰克的猫
真正重要的东西,用眼睛是看不见的。
67
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载