百无聊赖之JavaEE从入门到放弃（十九）容器之List

一.容器简介容器，是用来容纳物体、管理物体。生活中我们会用到各种各样的容器。如锅碗瓢盆、箱子和包等。程序中的容器也有类似的功能，用来容纳和管理数据。开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。我们一般通过容器来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以在其中放置对象或基本类型数据。数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果

深海鱼肝油ya

1392人浏览 · 2024-02-03 12:01:12

深海鱼肝油ya · 2024-02-03 12:01:12 发布

一.容器简介

容器，是用来容纳物体、管理物体。生活中 , 我们会用到各种各样的容器。如锅碗瓢盆、箱子和包等。

程序中的 “ 容器 ” 也有类似的功能，用来容纳和管理数据。

开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。我们一般通过 “ 容器 ” 来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以在其中

放置对象或基本类型数据。

数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从查询效率和类型检查的角度讲，数组是最好的。

数组的劣势：不灵活。容量需要事先定义好，不能随着需求的变化而扩容。比如：我们在一个用户管理系统中，要把今天注册的所有用户取出来，那么这样的用户有多少个？我们在写程序时是无法确定的。因此，在这里就不能使用数组。

基于数组并不能满足我们对于 “ 管理和组织数据的需求 ” ，所以我们需要一种更强大、更灵活、容量随时可扩的容器来装载我们的对象。这就是我们今天要学习的容器，也叫集合 (Collection) 。

二.容器的结构

单例集合：

双例集合：

三.Collection接口介绍

Collection 表示一组对象，它是集中、收集的意思。 Collection 接口的两个子接口是 List 、 Set 接口。

Collection 接口中定义的方法:

由于 List 、 Set 是 Collection 的子接口，意味着所有 List 、 Set 的实现类都有上面的方法。

JDK8 之后， Collection 接口新增的方法（将在 JDK 新特性和函数式编程中介绍）：

四.List接口介绍

List 接口特点

List 是有序、可重复的容器。

有序： 有序 ( 元素存入集合的顺序和取出的顺序一致 ) 。 List 中每个元素都有索引标记。可以根据元素的索引标记（在 List 中的位置）访问元素，从而精确控制这些元素。

可重复： List 允许加入重复的元素。更确切地讲， List 通常允许满足e1.equals(e2) 的元素重复加入容器。

List 接口中的常用方法

除了 Collection 接口中的方法， List 多了一些跟顺序 ( 索引 ) 有关的方法，参见下表：

五.ArrayList

ArrayList 是 List 接口的实现类。是 List 存储特征的具体实现。

ArrayList 底层是用数组实现的存储。特点：查询效率高，增删效率低，线程不安全。

1.基本操作

public class ArrayListTest {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> list  =new ArrayList<>();
        //添加元素
        boolean flag1=list.add("oldlu");
        boolean flag2=list.add("itbz");
        boolean flag3=list.add("sxt");
        boolean flag4=list.add("sxt");
        System.out.println(flag1+"\t"+flag2+"\t"+fl ag3+"\t"+flag4);
        //删除元素
        boolean flag4=list.remove("oldlu");
        System.out.println(flag4);
        //获取容器中元素的个数
        int size=list.size();
        System.out.println(size);
        //判断容器是否为空
        boolean empty=list.isEmpty();        
        System.out.println(empty);
        //容器中是否包含指定的元素
        boolean value=list.contains("itbz");
        System.out.println(value);        
        //清空容器
        list.clear();
        //将ArrayList转换为数组
        Object[] objects1=list.toArray();      
        System.out.println(Arrays.toString(objects1));
    }
}

2.索引操作

ArrayList可以根据索引位置操作元素。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayListTest2 {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> list  = new ArrayList<>();

        //添加元素
        list.add("oldlu");
        list.add("itbz");
        //向指定位置添加元素
        list.add(0,"sxt");

        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));

        System.out.println("获取元素");
        String s = list.get(1);
        System.out.println(s);

        System.out.println("获取所有元素方式一");
        //使用普通for循环
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("获取所有元素方式二");
        for(String str: list){
            System.out.println(str);
        }

        System.out.println("元素替换");
        String k = list.set(1, "kevin");
        System.out.println(k);

        System.out.println("根据索引的位置删除元素");
        String remove = list.remove(1);
        System.out.println(remove);

        System.out.println("查找元素在容器中第一次出现的位置");
        int sxt = list.indexOf("sxt");
        System.out.println(sxt);

        System.out.println("查找元素在容器中最后一次出现的位置");
        list.add("sxt");
        int sxt1 = list.lastIndexOf("sxt");
        System.out.println(sxt1);
    }
}

3.ArrayList的并集、交集、差集

import java.util.ArrayList;
import java.util.List;

public class ArrayListTest3 {
    public static void main(String[] args) {
        //并集操作：将另一个容器中的元素添加到当前容器中
        List<String> a  = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");

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

        //a并集b
        a.addAll(b);
        for(String str :a){
            System.out.println(str);
        }
        System.out.println("------------------");
        //交集操作：保留相同的，删除不同的
        List<String> a1  = new ArrayList<>();
        a1.add("a");
        a1.add("b");
        a1.add("c");

        List<String> b1 = new ArrayList<>();
        b1.add("a");
        b1.add("d");
        b1.add("e");
        //交集操作
        a1.retainAll(b1);
        for(String str :a1){
            System.out.println(str);
        }
        System.out.println("-------------");
        //差集操作：保留不同的，删除相同的
        List<String> a2  = new ArrayList<>();
        a2.add("a");
        a2.add("b");
        a2.add("c");

        List<String> b2= new ArrayList<>();
        b2.add("b");
        b2.add("c");
        b2.add("d");
        a2.removeAll(b2);
        for(String str :a2){
            System.out.println(str);
        }
    }
}

ArrayList底层是用数组实现的存储。

六.Vector容器

Vector 容器的基本使用

Vector 底层是用数组实现的，相关的方法都加了同步检查，因此 “ 线程安全 , 效率低 ” 。比如， indexOf 方法就增加了 synchronized 同步标记。

Vector 的使用

Vector 的使用与 ArrayList 是相同的，因为他们都实现了 List 接口，对 List 接口中的抽象方法做了具体实现。

import java.util.List;
import java.util.Vector;

public class VectorTest {
    public static void main(String[] args) {
        //实例化Vector容器
        List<String> v = new Vector<>();
        //添加
        v.add("a");
        v.add("b");
        v.add("c");
        v.add("a");

        //遍历Vector容器
        for(int i=0;i<v.size();i++){
            System.out.println(v.get(i));
        }
    }
}

七.LinkedList

容器介绍

LinkedList 底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。

双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。

LinkedList 的存储结构图

每个节点都应该有 3 部分内容：

如何选用 ArrayList 、 LinkedList 、 Vector?

需要线程安全时，用Vector。

不存在线程安全问题时，并且查找较多用ArrayList（一般使用它）

不存在线程安全问题时，增加或删除元素较多用LinkedList

LinkedList 容器的使用（ List 标准）

LinkedList 实现了 List 接口，所以 LinkedList 是具备 List 的存储特征的( 有序，元素有重复 ) 。

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

public class LinkedListTest {
    public static void main(String[] args) {
        //实例化LinkedList容器
        List<String> list = new LinkedList<>();

        //添加元素
        boolean a = list.add("a");
        boolean b = list.add("b");
        boolean c = list.add("c");
        list.add(3,"a");
        System.out.println(a+"\t"+b+"\t"+c);

        //获取容器中的所有元素
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

LinkedList容器的使用（非List标准）

import java.util.LinkedList;

public class LinkedListTest2 {
    public static void main(String[] args) {
        //示例化LinkedList容器
        LinkedList<String> list = new LinkedList<>();

        //将指定元素插入到开头
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");

        for(String str:list){
            System.out.println(str);
        }
        System.out.println("--------------------");
        //将指定元素插入到结尾
        LinkedList<String> list2 = new LinkedList<>();
        list2.addLast("a");
        list2.addLast("b");
        list2.addLast("c");

        for(String str:list2){
            System.out.println(str);
        }
        System.out.println("--------------------");
        //返回此链表的第一个元素
        System.out.println(list2.getFirst());
        //返回此链表的最后一个元素
        System.out.println(list2.getLast());
        System.out.println("--------------------");

        //移除此链表中的第一个元素，并返回这个元素
        /*String s = list2.removeFirst();
        System.out.println(s+" S");*/
        //从此链表所表示的堆栈处弹出一个元素,等效于removeFirst
        System.out.println(list2.pop()+" S");
        //移除此链表中的最后一个元素，并返回这个元素
        String s1 = list2.removeLast();
        System.out.println(s1+" S1");

        //将元素推入此链表所表示的堆栈  这个等效于addFisrt(E e)
        list2.push("e");
        for(String str:list2){
            System.out.println(str);
        }
    }
}