Java 基础学习之类集框架一（Collection、List）

矫情吗；* 2024-04-17 06:03 34阅读 0赞

# 1.认识类集 #

## 1.1 基本概念 ##

1.  所谓类集就是一个动态的对象数组，是对一些实现好的数据结构进行了包装，这样在使用时就会非常方便，而且最重要的是类集框架本身不受对象数组长度的限制。
2.  类集框架被设计成拥有以下几个特性：  
    （1）这种框架是高性能的。对基本类集（动态数组、链接表、树和散列表）的实现是高校的。所以一般很少需要人工去对这些 “数据引擎” 编写代码。  
    （2）框架必须允许不同类型的类集以相同的方式和高度互操作方式。  
    （3）类集必须是容易扩展和修改的。为了实现这一目标，类集框架被设计成包含了一组标准接口。  
    **提示：关于相同方式及高度的解释**

在类集的操作中因为是使用类的形式实现动态对象数组，所以对于任何对象的所有的操作形式都是一样的，例如：只要想向集合中增加内容，则一定使用 add() 方法，高度一般指的是类集中的元素类型都是统一的 ，即一个集合中要么都是 A 类对象，要么全是 B 类对象。

## 1.2 类集框架主要接口 ##

1.在整个 Java 类集中最常使用的类集接口是：Collection、List、Set、Map、Iterator、ListIterator、Enumeration、SortedSet、SortedMap、Queue、Map.Entry。  
2. 这些接口的具体特点如表：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>接口</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>Collection</td> 
   <td>是存放一组单值的最大接口，所谓的单值是指集合中的每个元素都是一个对象。一般很少直接使用此接口进行操作。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>List</td> 
   <td>是Collection 接口的子接口，也是最常用接口，此接口对 Collection 接口进行了大量的扩充，里面的内容是允许重复的。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>Set</td> 
   <td>是Collection 接口的子接口，没有对 Collection 接口进行扩充，里面的内容不允许重复。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Map</td> 
   <td>Map 是存放一对值的最大接口，即接口中的每个元素都是一对，以 Key —&gt; Value 的形式存放。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>Iterator</td> 
   <td>集合的输出接口，用于输出集合中的内容，只能进行从前到后的单向输出。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>ListIterator</td> 
   <td>集合 Iterator 的子接口，可以进行双向输出。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>Enumeration</td> 
   <td>是最早的输出接口，用于输出指定集合中的内容。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>SortedSet</td> 
   <td>单值的排序接口，实现此接口的集合类，里面的内容是可以排序的，使用比较器排序。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>SortedMap</td> 
   <td>存放一对值的排序接口，实现此接口的集合类，里面的内容按照 key 值排序，使用比较器排序。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>Queue</td> 
   <td>队列接口，此接口的子类可以实现队列操作。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>Map.Entry</td> 
   <td>Map.Entry 的内部接口，每个 Map.Entry 对象都保存着一对 Key —&gt; Value 的内容，每个 Map 接口中都保存多个 Map.Entry 实例。</td> 
  </tr> 
 </tbody> 
</table>

###### 接口的继承关系 ######

Collection

List

Set

Queue

SortedSet

Map

SortedMap

###### 小提示：在 Java 类集中凡是以 Sorted 开头的接口全部是排序接口，如 SortedSet、SortedMap。 ######

# 2. Collection 接口 #

## 2.1 基本概念 ##

1.  Collection 接口定义：`public interface Collection<E> extends Iterable<E>` ,从接口中可以发现，此接口使用了泛型的定义，在操作的时候必须指出具体的操作类型。这样可以保证类集操作的安全性，避免发生 “ClassCastException” 异常。
2.  在一般的开发中，往往很少直接去使用 Collection 接口进行开发，而基本都是使用其子接口，子接口主要有 List、Set、Queue和 SortedSet。 很少直接去使用 Collection 是因为这样会使操作意义不明确。

## 2.2 Collection 子接口定义 ##

1.  List 接口: 可以存放重复内容。
2.  Set 接口：不能存放重复内容，所有的重复内容是靠 hashCode() 和 equals() 两个方法区别的。
3.  Queue: 队列接口。
4.  SortedSet 接口：可以对集合中的数据进行排序。

# 3. List 接口 #

List 接口是 Collection 中最为常用的一个子接口，其本身也对 Collection 的方法进行了扩充。

## 3.1 List 接口的定义 ##

1.  List 接口定义：`public interface List<E> extends Collection`,与 Collection 不同的是，在 List 接口中大量地扩充了 Collection 接口，拥有比 Collection 接口中更多的方法定义。而且这些方法操作起来很方便。但是如果想要使用此接口，则肯定需要通过其子类进行实例化。

## 3.2 List 接口的常用子类 ##

1.  在实际开发中 List 子接口有 ArrayList、Vector和 LinkedList 3个常用子类。

### 3.3 新的子类：ArrayList ###

1.  ArrayList 是 List 子类，可以直接通过对象的多态性为 List 接口实例化。

#### 3.3.1 List 接口中的主要方法实例 ####

1.  ###### 向集合中增加元素 ######

要想完成此类操作，可以直接使用 Collection 接口中定义的两个方法:  
   (1) 增加一个元素：`public boolean add(E o)` 。  
   (2) 增加一组元素：`public boolean addAll(Collection<? extends E> e )` 。  
   也可以使用 List 扩充的 add() 方法,在指定位置处增加元素:`在public void add(int index , E element)`。

###### 实例1代码： ######

package self.learn.listdemo;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    
    public class ArrayListDemo01 { 
    
    	public static void main(String[] args) { 
    		List<String> allList = null;               // 定义 List 对象
    		Collection<String> allCollection = null;   // 定义 Collection 对象
    		allList = new ArrayList<String>();         // 实例化 List 对象，只能是 String 类型
    		allCollection = new ArrayList<String>();   // 实例化 Collection 对象，只能是 String 类型
    		allList.add("Hello");                      // 从 Collection 中继承的方法
    		allList.add(0, "World");                   // 此方法为 List 扩充方法
    		System.out.println(allList);               // 输出集合中内容
    		allCollection.add("Java Language");        // 增加数据
    		allCollection.add("is interesting!");
    		allList.addAll(allCollection);             // 增加一组对象
    		allList.addAll(0, allCollection);          // 输出对象，调用 toString() 方法
    		System.out.println(allList);
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190826173107531.png]

###### 2. 删除元素 ######

Collection 和 List 接口都分别定义了删除数据的方法。  
 (1) Collection 定义的方法：  
    每次删除一个对象：`public boolean remove( Object o)` 。  
    每次删除一组对象：`public boolean removeAll( Collection<?> o)` 。  
 (2) List 扩展的方法  
    删除指定位置的元素：`public E remove( int index)`。

###### 实例2代码： ######

###### 运行结果截图： ######

![在这里插入图片描述][2019082709093997.png]  
    在集合中添加完数据后，可以通过下标或者对象对集合的方式直接对集合中的元素激进行删除。

###### 提示：关于使用 remove(Object o) 方法删除对象的说明 ######

在集合中可以插入任意类型的对象，在本程序中是以 String 类的对象为例，所以在使用 remove(Object o) 方法删除时可以直接删除；而对于自定义的类如果要想通过此方式删除，则必须在类中覆写 Object 类的 equals() 及 hashCode() 方法。

###### 3. 输出 List 中的内容 ######

###### 实例3代码： ######

package self.learn.listdemo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayListDemo01 { 
    
    	public static void main(String[] args) { 
    		List<String> allList = null;               // 定义 List 对象 
    		allList = new ArrayList<String>();         // 实例化 List 对象，只能是 String 类型 
    		allList.add("Hello");                      // 从 Collection 中继承的方法
    		allList.add(0, "World");                   // 此方法为 List 扩充方法
    		allList.add("MLDN");                       // 增加元素
    		allList.add("www.mldn.cn"); 
    	    System.out.print("由前向后输出:");           
    	    for(int i = 0; i < allList.size(); i++) {   // 循环输出集合中的内容
    	    	System.out.print(allList.get(i)+"、");    // 通过下标取的集合中的内容
    	    }
    	    System.out.print("\n由前向后输出:");
    	    for(int i = allList.size()-1; i >= 0 ; i--) {   // 循环输出集合中的内容
    	    	System.out.print(allList.get(i)+"、");    // 通过下标取的集合中的内容
    	    }
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190827092745238.png]  
    在 List 集合中数据增加的顺序就是输出后的顺序，本身不会发生改变。

###### 4. 将集合变为对象数组 ######

在 Collection 中定义了 toArray() 方法，此方法可以将集合变为对象数组，但是由于在类型声明时已经通过泛型指定了集合中的元素类型，所以在接收的时候要使用泛型指定的类型。

###### 实例4代码： ######

package self.learn.listdemo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayListDemo01 { 
    
    	public static void main(String[] args) { 
    		List<String> allList = null;               // 定义 List 对象 
    		allList = new ArrayList<String>();         // 实例化 List 对象，只能是 String 类型 
    		allList.add("Hello");                      // 从 Collection 中继承的方法
    		allList.add(0, "World");                   // 此方法为 List 扩充方法
    		allList.add("MLDN");                       // 增加元素
    		allList.add("www.mldn.cn"); 
    	    String str[] = allList.toArray(new String[] { }); // 指定的泛型类型
    	    System.out.print("指定数组类型:");
    	    for(int i = 0; i < str.length; i++) {        // 输出字符串数组中的内容
    	    	System.out.print(str[i]+"、");
    	    }
    	    System.out.print("\n返回对象数组:");
    	    Object obj[] = allList.toArray();           // 直接返回对象数组
    	    for(int i = 0; i < obj.length; i++) {        // 循环输出对象数组的内容
    	    	String temp = (String)obj[i];           // 每一个对象数组都是 String 类型
    	    	System.out.print(temp+"、");             // 输出每一个元素
    	    }	    
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][20190827094656750.png]

###### 5. 集合的其他相关操作 ######

在 List 中还存在截取集合、查找元素位置、判断元素是否存在、集合是否为空等操作。下面直接测试以上的操作。

###### 实例5代码： ######

package self.learn.listdemo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ArrayListDemo01 { 
    
    	public static void main(String[] args) { 
    		List<String> allList = null;               // 定义 List 对象 
    		allList = new ArrayList<String>();         // 实例化 List 对象，只能是 String 类型 
    		System.out.println("集合操作前是否为空 ?"+allList.isEmpty());
    		allList.add("Hello");                      // 从 Collection 中继承的方法
    		allList.add(0, "World");                   // 此方法为 List 扩充方法
    		allList.add("MLDN");                       // 增加元素
    		allList.add("www.mldn.cn"); 
    		System.out.println(allList.contains("Hello")?"\"Hello\"字符串存在":"\"Hello\"字符串不存在");
    		List<String> allSub = allList.subList(1, 3);   // 取出里面的部分集合
    		System.out.print("集合截取:");
    	    for(int i = 0; i < allSub.size(); i++) {        // 截取部分集合
    	    	System.out.print(allSub.get(i)+"、");
    	    }
    	   System.out.println();
    	   System.out.println("MLDN 字符串的位置: "+allList.indexOf("MLDN"));
    	   System.out.println("集合操作后是否为空 ? "+allList.isEmpty());
    	    
    	}
    }

###### 运行结果截图： ######

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]  
    在程序中使用 contains() 方法判断集合中是否存在指定的元素。在集合中也可以使用 subList() 方法取出指定的子集。使用 isEmpty() 判断一个集合是否为空。

[20190826173107531.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/803fed6683114c2997563ea24c88fa33.png
[2019082709093997.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/a463bede1aad4ae197c6c54649b2d38d.png
[20190827092745238.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/05b8e5f2408040a5bf86fc0a4967f62a.png
[20190827094656750.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/1b35042bd4c548f09c3f20aec2d12005.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDkxNjY0MQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/6ec2f90225d24efd91f9d9c8f14a6ccd.png