Java当中的集合框架

古城微笑少年丶 2021-09-16 10:34 371阅读 0赞

![标题图][1240]

## Java当中的集合框架 ##

## 01 ##

在我们班里有`50`位同学，就有`50`位对象。

// 简书作者：达叔小生
    Student[] stus = new Student[20];

结果来了一位插班生，该同学因为觉得学`IT`行业好，才要求老师转专业的。可以结果没有多余的空位了，数组里的长度都是安排好的，没有空间了。

为了解决新同学的问题，老师们重新创建一个空间（**重复创建一个新的数组**），为了能够更好的解决问题，老师提供了可以不断扩大空间（**Java提供了集合，当数据多了，个数不稳定时，可以用集合**）。

在`Java`中，数组的长度是不可以改变的，在数组中存储的是同种类型的元素，可以存储基本数据类型值；但是集合的长度是可以改变的，存储的是对象，对象的类型可以不一样，集合是存储对象的，当数据多，即对象多的时候，可以用集合来存储。

> 虽然数组和集合类都是容器  
> 为什么用集合来解决问题，数组难道就不可以吗？

数组也可以存储对象的，但是因为长度的固定，限制了数组，而集合的长度是可以改变的，**在数组中可以用来存储基本数据类型，而在集合中只能用来存储对象，但是可以存的对象可以是不同类型的对象哦~**

> 数组可以存放基本数据类型和对象  
> 集合只能存放对象

在`Java`语言这种面向对象语言中，**对一切事物的体现都可以用对象的形式来表现**，为了对对象进行方便的操作，`Java`就提供了集合这个名词，用来存储对象一种方式。

## 02 ##

## 类集合框架主体 ##

> 集合框架的构成及分类

![类集合框架主体][1240 1]

// 简书作者：达叔小生
    java.util
    类 Vector<E>
    java.lang.Object
     -> java.util.AbstractCollection<E>
      -> java.util.AbstractList<E>
       -> java.util.Vector<E>

// 简书作者：达叔小生
    public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess,Cloneable,Serializable

**类集框架，那么什么是类集框架，集合的种类有哪些，类集框架的基础结构。**

类集框架是一组类和接口的集合，位于java.util包当中，是用来用户存储和管理对象的，**在这个类集合框架中，我们主要学习的为三大类，分别是集合，列表和映射。**

> 集合，列表，映射

类集合框架是`jdk`提供的一类类和接口，主要掌握集合，列表，映射，**集合是无序的，集合中的元素不允许是重复的，列表是有序的，列表中的元素是允许重复的，映射是以键值对的方式来存储数据，键是不可重复的，值是可以重复的。**

其实在`jdk`最早的时候`jdk1.0`版的时候，提供的集合是很少的，但是随着发展，到`jdk1.2`的时候就变多了，为了营造更多的需求，就有了集合框架。

> 所以的根接口为`Collection.`

// 简书作者：达叔小生
    // 集合框架体系
    Iterator
     ->Collection
     -> Map

// 简书作者：达叔小生
    Collection
     -> Set 无序不重复 -> 无序HashSet，需要排序TreeSet
     -> List 有序可重复 -> 查，改ArrayList，增删LinkedList
    
    Map
     -> 无序 HashMap
     -> 排序 TreeMap

## 03 ##

## 顶级Iterator和Collection ##

`Collection`的相关方法，可以去官方下载文档来看哦：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>add(E e)</td> 
   <td>返回的是<code>boolean</code>的类型，确保<code>collection</code>包含指定的元素</td> 
  </tr> 
  <tr> 
   <td>addAll(Collection&lt;? extends E&gt; e)</td> 
   <td>返回的是<code>boolean</code>的类型，将指定<code>collection</code>中的所有元素添加到<code>collection</code>中</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>返回<code>Void</code>，移除此<code>collection</code>中的所有元素</td> 
  </tr> 
  <tr> 
   <td>contains(Object o)</td> 
   <td>返回<code>boolean</code>类型，如果此<code>collection</code>包含指定的元素，则返回<code>true</code></td> 
  </tr> 
  <tr> 
   <td>containsAll(Collection&lt;?&gt; c)</td> 
   <td>返回<code>boolean</code>类型，如果此<code>collection</code>包含指定<code>collection</code>中的所有元素，则返回<code>true</code></td> 
  </tr> 
  <tr> 
   <td>equals(Object o)</td> 
   <td>返回<code>boolean</code>类型，比较<code>collection</code>与指定对象是否相等</td> 
  </tr> 
  <tr> 
   <td>hashCode()</td> 
   <td>返回的是<code>int</code>类型，返回此 <code>collection</code> 的哈希码值</td> 
  </tr> 
  <tr> 
   <td>isEmpty()</td> 
   <td>返回 <code>boolean</code>类型，如果此<code>collection</code>不包含元素，则返回<code>true</code></td> 
  </tr> 
  <tr> 
   <td>iterator()</td> 
   <td>返回<code>Iterater&lt;E&gt;</code>，返回在此<code>collection</code>的元素上进行迭代的迭代器</td> 
  </tr> 
  <tr> 
   <td>size()</td> 
   <td>返回<code>Int</code>类型，返回此<code>collection</code>中的元素数</td> 
  </tr> 
 </tbody> 
</table>

![Collection接口][Collection]

`Collection`接口：它定义了集合体系中最共性的功能

// 简书作者：达叔小生
    java.util
    接口 Collection<E>
    所有超级接口：
    Iterable<E>

// 简书作者：达叔小生
    public interface Collection<E>
    extends Iterable<E>

`Collection`接口为层次结构中的根接口，由上方提供的图片得知，`Collection`表示为一组对象，这些对象称为`Collection`的元素，在这个类集合框架中，我们主要学习的为三大类，分别是集合，列表和映射。

注意一些`collection`允许有重复的元素，有的不允许，有的是有序的，有的是无序的。

这些都跟三大类有关。

在`java`中，`jdk`不提供`Collection`接口的实现，都是由它的子接口进行实现的。

## Collection是List和Set的父类 ##

![如图][1240 2]

`List`和`Set`也都是由再次向下，由它们的子类接口实现的。

// 简书作者：达叔小生
    Set 和 HashSet 为Set的实现类 使用
    Iterator -> Collection -> Set -> HashSet
    Iterator -> Collection -> List -> ArrayList

来解释：一些`collection`允许有重复的元素，有的不允许，有的是有序的，有的是无序的。是因为数据结构的不同。为 `->` 三大类集合，列表，映射

出现了集合框架，有了很多种容器可以完成很多需求，我们区分容器是**靠着每个容器的数据结构不同**，去命名了解的。

## 04 ##

## 三大类集合，列表，映射 ##

`Set`为集合，在集合中的对象是不按照顺序排列的，并且是没有重复的对象的。  
**简单为：无序，无重复。**

![Set][]

`List`为列表，中在列表中的对象是由顺序的排序的，并且是有重复的对象。  
**简单为：有序，有重复。**

![List][]

`Map`为映射，在集合中的每个元素都有一个键对象和一个值对象，在`Map`中键是不可以重复的，值是可以重复的。  
**键不可重复，值可以重复；**

![Map][]

> `Set`为无序集合，无序无重复；  
> `List`为有序集合，有序有重复；  
> `Map`为映射，存储键值对，键不可重复，值可以重复；

## 05 ##

`Collection`是所有集合类的根接口，有人问那么这个呢？  
`Collections`，其实这个是集合操作的工具类。

// 简书作者：达叔小生
    Collection
     -> Set
      -> HashSet
      -> LinkedHashSet
      -> TreeSet
    
     -> List
      -> ArrayList
      -> Vector
      -> LinkedList
    
     -> Queue
      -> LinkedList
      -> PriorityQueue
    
     -> Map
      -> Hashtable
      -> HashMap
      -> TreeMap
      -> LinkedHashMap

![Collection接口][Collection 1]

// 简书作者：达叔小生
    import java.util.List;
    import java.util.ArrayList;
    
    public class Demo{
     public static void main(String args[]){
     // 创建列表的实现类对象
      ArrayList<String> arrayList = new ArrayList<String>();
     // 添加数据
     arrayList.add("a");
     arrayList.add("b");
     arrayList.add("c");
    // 移除
     arrayList.remove(1);
     // 获取数据
     String s = arrayList.get(1);
     System.out.println(s);
     // 获取长度
     int a = arrayList.size();
     // 打印所有元素
     for(int i=0; i<arrayList.size(); i++){
      String s = arrayList.get(i);
      System.out.println(s);
     }
     }
    }

> `Set` 和 `HashSet` 为`Set`的实现类 使用

// 简书作者：达叔小生
    import java.util.Set;
    import java.util.HashSet;
    public class Demo{
     public static void main(String args[]){
      HashSet<String> hashSet = new HashSet<String>();
     Set<String> set = hashSet;
     // 实现类向上转型为接口
     // 同理 Set<String> set = new HashSet<String>();
     // 添加元素
     set.add("a"); 
     set.add("b");
     set.add("c");
     set.add("d");
     // 获取集合中的元素长度
     int a = set.size();
     }
    }

## Iterator 接口 迭代器对象 ##

迭代是`Java`中的用来表示取元素的名称而已，`Iterator` 接口 迭代器对象用来取元素，无论是什么数据结构，最终共性的取出方式，取值是一个一个取的，在之前先要判断是否有值，如果有就取一个，如果没有就`over`，不取。

// 简书作者：达叔小生
    Iterator - > Collection -> Set - > HashSet
    hasNext() next()
    it.hasNext() 是否还有元素
    it.next() 取出元素

> `Iterator -> Collection -> List -> ArrayList`

## Set 和 HashSet 为Set的实现类 使用 ##

// 简书作者：达叔小生
    hasNext() 判断是否还有下一个元素
    next() 取出这个元素，然后把游标移动到下一位

> `Iterator -> Collection -> Set -> HashSet`

// 简书作者：达叔小生
    import java.util.Set;
    import java.util.HashSet;
    import java.util.Iterator;
    public class Demo{
     public static void main(String args[]){
      HashSet<String> hashSet = new HashSet<String>();
     Set<String> set = hashSet;
     // 实现类向上转型为接口
     // 同理 Set<String> set = new HashSet<String>();
     // 添加元素
     set.add("a"); 
     set.add("b");
     set.add("c");
     set.add("d");
     // 迭代器 iterator() 遍历整个set
    // 通过迭代器取出集合中的对象
     Iterator<String> it = set.iterator<String>();
     while(it.hasNext){
      String s = it.next();
      System.out.println(s);
     }
     }
    }

> `Iterator`迭代器 `iterator()`

// 简书作者：达叔小生
    Iterator<E> iterator()
    // 返回在此collection的元素上的迭代效果。

> 接口`Iterable<E>中的iterator`  
> 在此`collection`的元素上进行迭代  
> `iterator()`可以获取具体容器中的迭代器对象  
> 迭代器返回的是`Iterator`接口

**迭代器的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hasNext()</td> 
   <td>返回<code>boolean</code>类型，如果有元素可以迭代（取出），则返回<code>true</code></td> 
  </tr> 
  <tr> 
   <td>next()</td> 
   <td>返回<code>E</code>，返回迭代的下一个元素</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>返回<code>void</code>，从迭代器中移除迭代器返回的最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

> `java.util.NoSuchElementException` 没有这个元素异常  
> `it.next()`

// 简书作者：达叔小生
    public class IteratorDemo{
     public static void mian(String[] args){
      // 创建集合对象
      Collection collection  = new ArrayList();
     // 存储的是对象的引用
     // 集合存储不了基本数据类型
     // collection.add(12); == 内部效果 collection.add(Integer.valueOf(12); // 自动装箱
     // 即在jdk1.5后，存储的是基本数据类型包装类的对象
      collection.add("ab");
      collection.add("bbb");
      collection.add("cbbb");
      collection.add("dbbbb");
      // 获取迭代器 iterator()方法
      Iterator it = collection.iterator();
      while(it.hasNext(){
       System.out.println(it.next());
      }
      // 
       //可以转变为
       // for(Iterator it = collection.iterator(); it.hasNext(); ) {}
      //
      // 每个存储对象的长度
      for(Iterator it = collection.iterator(); it.hasNext(); ){
       // 取出对象
       Object object = it.next();
       // 向下转型，才能使用元素的特殊方法
       String str = (String)object;
       // 打印对象长度
       System.out.println(str.length());
      } 
     }
    }

// 简书作者：达叔小生
    // 可以使用这个，节省内存
    for(java.util.Iterator iterator = collection.iterator(){
     Object object = (Object) iterator.next();
    }

## 06 ##

// 简书作者：达叔小生
    // 创建一个Student类
    public class Student{
     // 定义私有的String变量 name
     private String name;
     // 定义私有的int变量 age
     private int age;
     // 创建构造函数
     public Student(){
      super();
     }
     public Student(String name, int age){
      super();
      this.name = name;
      this.age = age;
     }
     // 创建toString()方法
     @Override
     public String toString(){
      return "Student [name=" + name + ", age=" + age + "]";
     }
     // 创建getXxx()，setXXX()方法
     public String getName(){
      return name;
     };
     public void setName(String name){
      this.name = name;
     }
     public int getAge(){
      return age;
     }
     public void setAge(int age){
      this.age = age;
     }
     // equals();
     @Override
     public boolean equals(Object obj){
      if(this == obj){
       return; 
      }
      if(! (obj instanceof Student) ){
       throw new ClassCastException("类型错误");
      }
       Student stu = (Student)obj;
       return this.name.equals(stu.name) && this.age == stu.age;
     }
    }

> `equals()`方法

// 简书作者：达叔小生
    public class CollectionDemo {
     public static void main(String[] args){
      // 创建集合对象
     Collection collection = new ArrayList();
     // 添加元素 添加一个地址两次为重复
     Student stu = new Student( "a",12 );
     collection.add( stu );
     collection.add( new Student("b",13) );
     collection.add( new Student("c",14) );
     collection.add( new Student("d",15) );
     for(Iterator it = collection.iterator(); it.hasNext(); ){
      Student student = (Student) it.next();
      System.out.println(student.getName());
     }
     }
    }

## Map 与 HashMap(Map的实现类) 的使用 ##

`Map` 为映射，映射中的每个元素都有一个键对象和一个值对象，在`Map`中键是不可以重复的，值是可以重复的。从`jdk1.2`有了这个类。

// 简书作者：达叔小生
    java.util
    Interface Map<K,V>
    K - the type of keys maintained by this map
    V - the type of mapped values

`Map`是一种对象，将`keys`键和`values`值建立起一种映射关系，一个`map`不能有重复的`keys`，每个`key`只能唯一映射到一个值。

// 简书作者：达叔小生
    import java.util.Map;
    import java.util.HahMap;
    public class Demo{
     public static void main(String args[]){
      HashMap<String,String> hasMap = new  HashMap<String,String>();
      Map<String,String> map = hasMap;
     // 向上转型
     // 同理 Map<Stirng,String> map = new HashMap<String,String>();
     // put() 用来存放键值对
     map.put("1","a");
     map.put("2","b");
     map.put("3","c");
    // 获取长度
     int i = map.size();
    // 获取键为2的值
     String s = map.get("2");
     }
    }

在`Map`中键是不可以重复的，值是可以重复的。如果`map`中添加一样的键，那么新的值会覆盖老的值。

> Collection

// 简书作者：达叔小生
    public interface List<E>
    extends Collection<E>

![简书作者：达叔小生][1240 3]

// 简书作者：达叔小生
    java.util
    接口 List<E>
    所有超级接口：Collection<E>，Iterable<E>
    所有已知实现类：AbstractList，AbstractSequentialList，ArrayList，AttributeList，CopyOnWriteArrayList，LinkedList，RoleList，Vector，Stack。
    可以用 ArrayList

> `public interface List<E> extends Collection<E>`

// 简书作者：达叔小生
    public class ListDemo{
     public static void main(String[] args){
      // List
      List list = new ArrayList();
     // 添加元素
     list.add( new Student("a",12) );
     list.add( new Student("b",13) );
     list.add( new Student("c",14) );
     // 插入元素
     // list.add( 1, new Student("d",15) );
     // list.remove(44); 
     // 角标越界IndexOutOfBoundsException)
     // list.set( 2, new Student("dashucoding", 16) );
     // 循环出对象
     for(Iterator it = List.iterator(); it.hasNext(); ){
      Student stu = (Student) it.next();
      System.out.println(stu);
     }
     // 获取对象
     Object obj = list.get(1);
     System.out.println(obj);
     // 获取对象
     for(int i = 0; i<list.size(); i++){
      System.out.println(list.get(i));
     }
    }

> 往后余生，唯独有你  
> 简书作者：达叔小生  
> 90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通  
> 简书博客： [https://www.jianshu.com/u/c785ece603d1][https_www.jianshu.com_u_c785ece603d1]

## 结语 ##

*  下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/8f6cf8671e114a27a56e9369f88b2838.png
[1240 1]: /images/20210724/d6c75f2270b640c39b6ec927d026694d.png
[Collection]: /images/20210724/7195a9e802e642d5b7a9e0c839618f31.png
[1240 2]: /images/20210724/d89e82ad80ae45b5a5527b7683e93753.png
[Set]: /images/20210724/f24e1e7f6c22445f9832230632598ecc.png
[List]: /images/20210724/37bcc88a27e34f8da93e0dbddac71db1.png
[Map]: /images/20210724/0dc30e1d399241499c6ec31644c88adf.png
[Collection 1]: /images/20210724/904ddc8e801e4660bfcc05d1fa90f2cf.png
[1240 3]: /images/20210724/380ff9feb9674ae7aa98a0ebbdc0bd10.png
[https_www.jianshu.com_u_c785ece603d1]: https://www.jianshu.com/u/c785ece603d1