容器【基本使用、索引操作、并集、交集、差集】(二)-全面详解（学习总结---从入门到深化）

Dear 丶 2023-10-13 15:41 38阅读 0赞

## ![c00fc95dd3c44a7c9bb0d82418b281e7.gif][] ##

![b47fa73687324748924990d1494cbc27.png][]

**目录**

泛型中的通配符

统配符的上下限定 统配符的上限限定

通配符的下限限定

泛型局限性和常见错误

List接口介绍

ArrayList容器的基本使用

ArrayList容器的索引操作

ArrayList的并集、交集、差集

判断数组是否扩容

Vector容器的基本使用

Vector源码分析

--------------------

## 泛型中的通配符 ##

![afaa9e3f75cd4e39af3069774d6fb08b.png][]

###  **无界通配符**   “?”表示类型通配符，用于代替具体的类型。它只能在“<>”中使用。可以解决当具体类型不确定的问题。 ###

语法结构

public void showFlag(Generic<?> generic){  }

示例

public class Generic<T> {
    
      private T  flag;
    
      public void setFlag(T flag){
        this.flag = flag;
     }
    
      public T getFlag(){
        return this.flag;
      }
    }
    
    
    public class ShowMsg {
      public void showFlag(Generic<?> generic){
      
      System.out.println(generic.getFlag());
     }
    }
    
    
    public class Test3 {
      public static void main(String[] args) {
    
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new  Generic<>();
        generic.setFlag(20);
        showMsg.showFlag(generic);
    
        Generic<Number> generic1 = new  Generic<>();
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
    
        Generic<String> generic2 = new Generic<>();
        generic2.setFlag("old");
        showMsg.showFlag(generic2);
     }
    }

> 实时效果反馈  
> 1.在泛型中，无界通配符使用什么符号来表示？  
> A ！  
> B ？  
> C \#  
> D \*
> 
> 答案  
> 1=>B

##  **统配符的上下限定   统配符的上限限定** ##

![3fbb9940c0c545709e1a569c20643c7b.png][]

对通配符的上限的限定：<？ extends 类型> ？实际类型可以是上限限定中所约定的类型，也可以是约定类型的子类型；

语法结构

public void showFlag(Generic<? extends Number> generic){ }

示例

public class ShowMsg {
    
      public void showFlag(Generic<? extends Number> generic){
    
            System.out.println(generic.getFlag());
      }
    }
    
    
    public class Test4 {
    
      public static void main(String[] args) {
    
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new  Generic<>();
        generic.setFlag(20);
    
        showMsg.showFlag(generic);
        Generic<Number> generic1 = new  Generic<>();
    
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
     }
    }

> 实时效果反馈  
> 1.对通配符的上限的限定是指  
> A 实际类型只能是上限限定中所约定的类型；  
> B 实际类型只能是上限限定中所约定类型的子类型；
> 
> C 实际类型可以是上限限定中所约定的类型，也可以是约定类型的子类型；  
> D 实际类型可以是上限限定中所约定的类型，也可以是约定类型的父类型；
> 
> 答案  
> 1=>C

## 通配符的下限限定 ##

![c89b4ecd05c54404b3db82d143e06892.png][]

对通配符的下限的限定：<？ super 类型> ？实际类型可以是下限限定中所约定的类型，也可以是约定类型的父类型；

语法结构

public void showFlag(Generic<? super Integer> generic){ }

示例

public class ShowMsg {
    
      public void showFlag(Generic<? super Integer> generic){
      
         System.out.println(generic.getFlag());
       }
    }
    
    
    public class Test6 {
    
      public static void main(String[] args) {
    
        ShowMsg showMsg = new ShowMsg();
        Generic<Integer> generic = new Generic<>();
        generic.setFlag(20);
        showMsg.showFlag(generic);
    
        Generic<Number> generic1 = new Generic<>();
        generic1.setFlag(50);
        showMsg.showFlag(generic1);
     }
    }

实时效果反馈

> 1.对通配符的下限的限定是指  
> A 实际类型只能是下限限定中所约定的类型；  
> B 实际类型只能是下限限定中所约定类型的子类型；  
> C 实际类型可以是下限限定中所约定的类型，也可以是约定类型的子类型；  
> D 实际类型可以是下限限定中所约定的类型，也可以是约定类型的父类型；
> 
> 答案
> 
> 1=>D

## 泛型局限性和常见错误 ##

![e93b42f5f35f417b932e5bcdfe5fda7c.png][]

泛型主要用于编译阶段，编译后生成的字节码class文件不包含泛型中的类型信息。 类型参数在编译后会被替换成Object，运行时虚拟机并不知道泛型。因此，使用泛型时，如下几种情况是错的：

![b18a53b4604a46909d176d01386d7d56.png][]

实时效果反馈

>   
> 1.如下哪个选项是错误的使用泛型?  
> A Generic  
> B Generic  
> C Generic  
> D Generic
> 
> 答案  
> 1=>D

# 二、容器介绍 #

## 容器简介 ##

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

![532c22ec84f1400284129172e9fb183e.png][]

程序中的“容器”也有类似的功能，用来容纳和管理数据。比如，如下新闻网站的新闻列表、教育网站的课程列表就是用“容器”来管理：

> 开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。 我们一般通过“容器”来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以在其中  
> 放置对象或基本类型数据。  
> **数组的优势**：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从查询效率和类型检查的角度讲，数组是最好的。  
> **数组的劣势**：不灵活。容量需要事先定义好，不能随着需求的变化而扩容。比如：我们在一个用户管理系统中，要把今天注册的所有用户取出来，那么这样的用户有多少个？我们在写程序时是无法确定的。因此，在这里就不能使用数组。

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

实时效果反馈

> 1.Java中容器的作用是什么?  
> A 容纳数据  
> B 处理数据  
> C 生产数据  
> D 销毁数据
> 
> 答案  
> 1=>A

## 容器的结构 ##

### **结构图** ###

![e2f86885e7514e8fa7b7ee0053fd0bf3.png][]

###  **单例集合** ###

![dc915b924ec74dfb92e62870bc4704ba.png][]

###  **双例集合** ###

![0497fc1b90434791a4b9342802ba3d10.png][]

实时效果反馈

> 1.如下哪个接口不是容器接口?  
> A List  
> B Set  
> C Map  
> D Comparable
> 
> 答案  
> 1=>D

### 单例集合 ###

**Collection接口介绍**

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

![229876e3a15947f79ccc13feb7d3594a.png][]

Collection接口中定义的方法

<table> 
 <tbody> 
  <tr> 
   <td>方法&nbsp;</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>boolean add(Object element)</td> 
   <td>增加元素到容器中</td> 
  </tr> 
  <tr> 
   <td>boolean remove(Object element)</td> 
   <td>从容器中移除元素</td> 
  </tr> 
  <tr> 
   <td>boolean contains(Object element)</td> 
   <td>容器中是否包含该元素</td> 
  </tr> 
  <tr> 
   <td>int size()</td> 
   <td>容器中元素的数量</td> 
  </tr> 
  <tr> 
   <td>boolean isEmpty()</td> 
   <td>容器是否为空</td> 
  </tr> 
  <tr> 
   <td>void clear()</td> 
   <td>清空容器中所有元素</td> 
  </tr> 
  <tr> 
   <td>Iterator iterator()</td> 
   <td>获得迭代器，用于遍历所有元素</td> 
  </tr> 
  <tr> 
   <td>boolean containsAll(Collection c)</td> 
   <td>本容器是否包含c容器中的所有元素</td> 
  </tr> 
  <tr> 
   <td>boolean addAll(Collection c)</td> 
   <td>将容器c中所有元素增加到本容器</td> 
  </tr> 
  <tr> 
   <td>boolean removeAll(Collection c)</td> 
   <td>移除本容器和容器c中都包含的元素</td> 
  </tr> 
  <tr> 
   <td>boolean retainAll(Collection c)</td> 
   <td>取本容器和容器c中都包含的元素，移除非交集元素</td> 
  </tr> 
  <tr> 
   <td>Object[] toArray()</td> 
   <td>转化成Object数组</td> 
  </tr> 
 </tbody> 
</table>

> 由于List、Set是Collection的子接口，意味着所有List、Set的实现类都有上面的方法。
> 
> JDK8之后，Collection接口新增的方法（将在JDK新特性和函数式编程中介绍）：
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td>新增方法&nbsp;</td> 
>    <td>说明</td> 
>   </tr> 
>   <tr> 
>    <td>removeIf</td> 
>    <td>作用是删除容器中所有满足filter指定条件的元素</td> 
>   </tr> 
>   <tr> 
>    <td>stream<br> parallelStream</td> 
>    <td>stream和parallelStream 分别返回该容器的Stream视图表示，不同之处在于parallelStream()返回并行的Stream，Stream是Java函数式编程的核心类</td> 
>   </tr> 
>   <tr> 
>    <td>spliterator</td> 
>    <td>可分割的迭代器，不同以往的iterator需要顺序迭代，Spliterator可以分割为若干个小的迭代器进行并行操作，可以实现多线程操作提高效率</td> 
>   </tr> 
>  </tbody> 
> </table>

实时效果反馈

> 1.如下哪个接口不是Collection接口的子接口?  
> A List  
> B Set  
> C Map  
> D Queue
> 
> 答案  
> 1=>C

## List接口介绍 ##

![8f36ee4008b24e1d915851c58656e859.png][]

>  **List接口特点**
> 
> List是有序、可重复的容器。
> 
> **有序**：有序(元素存入集合的顺序和取出的顺序一致)。List中每个元 素都有索引标记。可以根据元素的索引标记（在List中的位置）访问 元素，从而精确控制这些元素。
> 
> **可重复**：List允许加入重复的元素。更确切地讲，List通常允许满足 e1.equals(e2) 的元素重复加入容器。
> 
> **List接口中的常用方法**
> 
> 除了Collection接口中的方法，List多了一些跟顺序(索引)有关的方 法，参见下表：

![2a372c7a69dd43d8bf3056b0ef51ab43.png][]

## ArrayList容器的基本使用 ##

![f9e78f194373475dafbaf0f572027242.png][]

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

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"+flag3+"\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();
            Object[] objects1 = list.toArray();
            System.out.println(Arrays.toString(objects1));
       }
    }

## ArrayList容器的索引操作 ##

![7b97a41e9f434077803ab34f5cf969e5.png][]

public class ArrayListTest2 {
        public static void main(String[] args) {
            //实例化容器
            List<String> list = new ArrayList<>();
    
            //添加元素
            list.add("oldlu");
            list.add("itbz");
    
            //向指定位置添加元素
            list.add(0,"sxt");
            System.out.println("获取元素");
            String value1 = list.get(0);
            System.out.println(value1);
            System.out.println("获取所有元素方式一");
    
            //使用普通for循环
            for(int i=0;i<list.size();i++){
                System.out.println(list.get(i));
             }
            System.out.println("获取所有元素方式二");
    
            //使用Foreach循环
            for(String str:list){
                System.out.println(str);
           }
           System.out.println("元素替换");
            list.set(1,"kevin");
            for(String str:list){
                System.out.println(str);
           }
            System.out.println("根据索引位置删除元素);
            String value2 = list.remove(1);
            System.out.println(value2);
            System.out.println("----------------");
            for(String str:list){
                System.out.println(str);
           }
            System.out.println("查找元素第一次出现的位置");
            int value3 = list.indexOf("sxt");
            System.out.println(value3);
            System.out.println("查找元素最后一次出现的位置");
            list.add("sxt");
            for(String str:list){
                System.out.println(str);
           }
            int value4 = list.lastIndexOf("sxt");
            System.out.println(value4);
       }
    }

##  **ArrayList的并集、交集、差集** ##

### 并集 ###

//并集操作：将另一个容器中的元素添加到当前容器中
            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);
           }

### 交集 ###

//交集操作：保留相同的，删除不同的
            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);
           }

### 差集 ###

//差集操作：保留不同的，删除相同的
            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源码分析 ##

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

### 成员变量 ###

/**
    * Default initial capacity.
    */
       private static final int DEFAULT_CAPACITY = 10;
    /**
    * The array buffer into which the elements of the ArrayList are stored.
    /**
    * The array buffer into which the elements of the ArrayList are stored.
    * The capacity of the ArrayList is the length of this array buffer. Any
    * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    * will be expanded to DEFAULT_CAPACITY when the first element is added.
    */
    
    transient Object[] elementData; // nonprivate to simplify nested class access
    
    
    /**
    * The size of the ArrayList (the number of elements it contains).
    *
    * @serial
    */
    
    private int size;

> 数组初始大小

/**
    * Default initial capacity.
    */
    private static final int DEFAULT_CAPACITY = 10;

### 添加元素 ###

/**
    * Appends the specified element to the end of this list.
    *
    * @param e element to be appended to this list
    * @return <tt>true</tt> (as specified by {@link Collection#add})
    */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //Increments modCount!!
        elementData[size++] = e;
        return true;
    }

## 判断数组是否扩容 ##

//容量检查
    private void ensureCapacityInternal(int minCapacity) {  
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    //容量确认
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //判断是否需要扩容，数组中的元素个数-数组长度，如果大于0表明需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

### **数组扩容** ###

/**
    * Increases the capacity to ensure that it can hold at least the
    * number of elements specified by the minimum capacity argument.
    *
    * @param minCapacity the desired minimum capacity
    */
    private void grow(int minCapacity) {
      // overflow-conscious code
        int oldCapacity = elementData.length;
      //扩容1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        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);
    }

## **Vector容器的基本使用** ##

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

![a263a80775de441b8297a521a127c44a.png][]

###  **Vector的使用** ###

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

public class VectorTest {
        public static void main(String[] args) {
            //实例化Vector
            List<String> v = new Vector<>();
            v.add("a");
            v.add("b");
            v.add("a");
            for(int i=0;i<v.size();i++){
                System.out.println(v.get(i));
           }
            System.out.println("----------------------");
            for(String str:v){
                System.out.println(str);
           }
       }
    }

## Vector源码分析 ##

### 成员变量 ###

/**
    * The array buffer into which the components of the vector are
    * stored. The capacity of the vector is the length of this array buffer,
    * and is at least large enough to contain all the vector's elements.
    *
    * <p>Any array elements following the last element in the Vector are null.
    *
    * @serial
    */
    
    protected Object[] elementData;
    
        /**
         * The number of valid components in this {@code Vector} object.
         * Components {@code elementData[0]} through
         * {@code elementData[elementCount-1]} are the actual items.
         *
         * @serial
         */
    
    protected int elementCount;
        
        /**
         * The amount by which the capacity of the vector is automatically
         * incremented when its size becomes greater than its capacity. If
         * the capacity increment is less than or equal to zero, the capacity
         * of the vector is doubled each time it needs to grow.
         *
         * @serial
         */
    protected int capacityIncrement;

### **构造方法** ###

public Vector() {
        this(10);
    }

### 添加元素 ###

/**
    * Appends the specified element to the end of this Vector.
    *
    * @param e element to be appended to this Vector
    * @return {@code true} (as specified by {@link Collection#add})
    * @since 1.2
    */
    
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

### 数组扩容 ###

/**
    * This implements the unsynchronized semantics of ensureCapacity.
    * Synchronized methods in this class can internally call this
    * method for ensuring capacity without incurring the cost of an
    * extra synchronization.
    *
    * @see #ensureCapacity(int)
    */
    
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
       //判断是否需要扩容，数组中的元素个数-数组长度，如果大于0表明需要扩容
        
    if (minCapacity - elementData.length >0)
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
    
       //扩容2倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
    
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

##  ##

[c00fc95dd3c44a7c9bb0d82418b281e7.gif]: https://img-blog.csdnimg.cn/c00fc95dd3c44a7c9bb0d82418b281e7.gif
[b47fa73687324748924990d1494cbc27.png]: https://img-blog.csdnimg.cn/b47fa73687324748924990d1494cbc27.png
[afaa9e3f75cd4e39af3069774d6fb08b.png]: https://img-blog.csdnimg.cn/afaa9e3f75cd4e39af3069774d6fb08b.png
[3fbb9940c0c545709e1a569c20643c7b.png]: https://img-blog.csdnimg.cn/3fbb9940c0c545709e1a569c20643c7b.png
[c89b4ecd05c54404b3db82d143e06892.png]: https://img-blog.csdnimg.cn/c89b4ecd05c54404b3db82d143e06892.png
[e93b42f5f35f417b932e5bcdfe5fda7c.png]: https://img-blog.csdnimg.cn/e93b42f5f35f417b932e5bcdfe5fda7c.png
[b18a53b4604a46909d176d01386d7d56.png]: https://img-blog.csdnimg.cn/b18a53b4604a46909d176d01386d7d56.png
[532c22ec84f1400284129172e9fb183e.png]: https://img-blog.csdnimg.cn/532c22ec84f1400284129172e9fb183e.png
[e2f86885e7514e8fa7b7ee0053fd0bf3.png]: https://img-blog.csdnimg.cn/e2f86885e7514e8fa7b7ee0053fd0bf3.png
[dc915b924ec74dfb92e62870bc4704ba.png]: https://img-blog.csdnimg.cn/dc915b924ec74dfb92e62870bc4704ba.png
[0497fc1b90434791a4b9342802ba3d10.png]: https://img-blog.csdnimg.cn/0497fc1b90434791a4b9342802ba3d10.png
[229876e3a15947f79ccc13feb7d3594a.png]: https://img-blog.csdnimg.cn/229876e3a15947f79ccc13feb7d3594a.png
[8f36ee4008b24e1d915851c58656e859.png]: https://img-blog.csdnimg.cn/8f36ee4008b24e1d915851c58656e859.png
[2a372c7a69dd43d8bf3056b0ef51ab43.png]: https://img-blog.csdnimg.cn/2a372c7a69dd43d8bf3056b0ef51ab43.png
[f9e78f194373475dafbaf0f572027242.png]: https://img-blog.csdnimg.cn/f9e78f194373475dafbaf0f572027242.png
[7b97a41e9f434077803ab34f5cf969e5.png]: https://img-blog.csdnimg.cn/7b97a41e9f434077803ab34f5cf969e5.png
[a263a80775de441b8297a521a127c44a.png]: https://img-blog.csdnimg.cn/a263a80775de441b8297a521a127c44a.png