1.9 集合

- 日理万妓 2023-10-06 12:49 23阅读 0赞

#### 文章目录 ####

*   *  一、集合
     *  二、Collection集合
     *   *  1、Collection集合
         *  2、单列集合：collection；双列集合：map
         *  3、collection中的功能：
         *  4、Iterator迭代器
         *  5、增强for：
         *  6、泛型：
         *   *  6.1、含有泛型的类
             *  6.2、含有泛型的方法
             *  6.3、含有泛型的方法
         *  7、泛型通配符:用来匹配泛型的
         *  8、 泛型上下限:
         *   *  8.1、泛型上限
             *  8.2、泛型下限:
     *  三、List接口
     *   *  1、List接口特点：
         *  2、常见数据结构：
         *  3、LinkedList集合：
     *  四、set接口：
     *   *  1、LinkedHashSet:
     *  五、Collections工具类：
     *  五、Map集合
     *   *  1、概念
         *  2、Map集合子类：
         *  3、常用方法：
         *  4、Map的遍历：
         *  5、可变参数：
         *  6、 HashSet集合存储数据的结构（哈希表）(扩容机制)
     *  六、xmind整理
     *   *  1、图：
         *  2、\[CSDN地址：\](https://download.csdn.net/download/weixin\_44624117/12598401)
         *  3、\[百度云地址：\](https://pan.baidu.com/s/1gj6H6BZ9wi8kML9fTwEseQ)

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

### 一、集合 ###

**概念：**

Java集合大致可分为List、Set、Queue和Map四种体系.

List：代表有序、重复的集合。

Set：代表无序、不可重复的集合。

Map：则代表具有映射关系的集合。

Queue：Java5又增加了Queue体系集合，代表一种队列集合实现。

**分类：**

Java的集合类主要由两个接口派生而出： Collection和Map， Collection和Map是Java 集合框架的根接口，这两个接口又包含了一些子接口或实现类。如下所示是 Java集合 简单结构图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70]

### 二、Collection集合 ###

#### 1、Collection集合 ####

数组的长度是固定的。集合的长度是可变的。

数组存储任意类型数据。集合存储的都是引用数据类型。基本类型需要转为对应的包装类。

#### 2、单列集合：collection；双列集合：map ####

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

#### 3、collection中的功能： ####

<table> 
 <thead> 
  <tr> 
   <th>public boolean add(E e) ：</th> 
   <th>把给定的对象添加到当前集合中 。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void clear() :</td> 
   <td>清空集合中所有的元素。</td> 
  </tr> 
  <tr> 
   <td>public boolean remove(E e) :</td> 
   <td>把给定的对象在当前集合中删除。</td> 
  </tr> 
  <tr> 
   <td>public boolean contains(Object obj) :</td> 
   <td>判断当前集合中是否包含给定的对象。</td> 
  </tr> 
  <tr> 
   <td>public boolean isEmpty() :</td> 
   <td>判断当前集合是否为空。</td> 
  </tr> 
  <tr> 
   <td>public int size() :</td> 
   <td>返回集合中元素的个数。</td> 
  </tr> 
  <tr> 
   <td>public Object[] toArray() :</td> 
   <td>把集合中的元素，存储到数组中</td> 
  </tr> 
 </tbody> 
</table>

#### 4、Iterator迭代器 ####

public Iterator iterator() : 获取集合对应的迭代器，用来遍历集合中的元素的；
    public E next() :返回迭代的下一个元素。
    public boolean hasNext() :如果仍有元素可以迭代，则返回 true；

实现代码：

Iterator<String> it = coll.iterator();
    // 泛型指的是 迭代出 元素的数据类型
    while(it.hasNext()){
         //判断是否有迭代元素
    	String s = it.next();//获取迭代出的元素
    	System.out.println(s);
    }

#### 5、增强for： ####

高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

//使用增强for遍历数组
    for (int a : arr) {
        //a代表数组中的每个元素
        System.out.println(a);
    }

#### 6、泛型： ####

##### 6.1、含有泛型的类 #####

————含有 泛型的类：——在创建对象的时候确定泛型；

class ArrayList<E> {
        
        public boolean add(E e) {
        
        }
        public E get(int index) {
        
        }
    }

(1)、创建对象时候确定泛型：

ArrayList<String> list = new ArrayList<String>();

则原来内部代码理解为：

class ArrayList<String> {
        
        public boolean add(String e) {
        
        }
        public String get(int index) {
        
        }
    }

##### 6.2、含有泛型的方法 #####

————含有含有泛型的方法——调用方法时，确定泛型的类型

public class MyGenericMethod {
        
        public <MVP> void show(MVP mvp) {
        
            System.out.println(mvp.getClass());
        }
    }

(2)、调用方法时候确定：

public class GenericMethodDemo {
        
        public static void main(String[] args) {
        
            // 创建对象
            MyGenericMethod mm = new MyGenericMethod();
            // 演示看方法提示
            mm.show("aaa");
            mm.show(123);
        }
    }

##### 6.3、含有泛型的方法 #####

————含有泛型的接口——

public interface MyGenericInterface<E> {
        
        public abstract void add(E e);
        public abstract E getE();
    }

《1》定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
        
    }
    @Override
    public void add (String e){
        
    }

《2》始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class MyImp2<E> implements MyGenericInterface<E> {
        
        @Override
        public void add(E e) {
        
        }
    }

#### 7、泛型通配符:用来匹配泛型的 ####

?: 代表任意的数据类型

注意: 用来匹配泛型的,而不能用来定义泛型

ArrayList<String> list1 = new ArrayList<>();
    list1.add("aaa");
    ArrayList<Integer> list2 = new ArrayList<>();
    list2.add(200);
    print(list1);
    print(list2);
    //定义一个方法,完成上面的两个集合的遍历
    public static void print (ArrayList < ? > list){
        
        for (Object obj : list) {
        
            System.out.println(obj);
        }
    }

泛型的注意事项:

《1》创建集合对象时,<>中指定的类型,左右必须保持一致(泛型不存在多态)

《2》ArrayList<?> list:

可以接收ArrayList的任意泛型对象(创建ArrayList集合时,只要<>中定了具体的类型,就是ok的)

ArrayList<?> list;//只是用来接收创建的值得。可以用通配符；
        list = new ArrayList<String>();
        list = new ArrayList<Integer>();

#### 8、 泛型上下限: ####

##### 8.1、泛型上限 #####

泛型的上限：

> 格式： 类型名称 <? extends 类 > 对象名称  
> 意义： 只能接收该类型及其子类

? extends Person: Person类型或者Person类型的子类型，表示继承Person的类；
    ? extends E: E类型或者E类型的子类型

public static void print(ArrayList<? extends Person> list) {

##### 8.2、泛型下限: #####

> 格式： 类型名称 <? super 类 > 对象名称  
> 意义： 只能接收该类型及其父类型

? super Teacher: Teacher类型或者Teacher类型的父类型，表示父类是Teacher的类；
    ? super E: E类型或者E类型的父类型

public static void print(ArrayList<? super Teacher> list) {

### 三、List接口 ###

#### 1、List接口特点： ####

—它是一个元素存取有序的集合。

—它是一个带有索引的集合；

—集合中可以有重复的元素；

常用方法：

*  add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
 *  get(int index) :返回集合中指定位置的元素。
 *  remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
 *  set(int index, E element) :替换集合中元素,返回值的更新前的元素；

#### 2、常见数据结构： ####

数据存储的常用结构有：栈、队列、数组、链表和红黑树。

**——栈：**

又称堆栈，运算受限的线性表，仅允许在标的一端进行插入和删除操作；

**特点：**

先进后出：

栈的入口、出口的都是栈的顶端位置。

压栈：就是存元素。

弹栈：就是取元素。

**——队列：**

运算受限的线性表，仅允许在表的一端进行插入，而在表的另一端进行删除。

先进先出；

队列的入口、出口各占一侧。

**——数组：**

有序的元素序列

查找元素快；增删元素慢；

在指定索引位置增加元素和删除元素;

**——链表：**

由一系列结点组成，其中每个结点包括两个部分：

一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域；

链表结构有单向链表与双向链表；

特点：

多个结点之间，通过地址进行连接。

查找元素慢：增删元素快：

**——红黑树：**

二叉树是每个节点最多有两个子树的树结构。

顶上的叫根结点，两边被称作“左子树”和“右子树”。

#### 3、LinkedList集合： ####

LIst集合下面ArrayList集合和LinkedList集合;

LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

常用方法：

*  addFirst(E e) :将指定元素插入此列表的开头。
 *  addLast(E e) :将指定元素添加到此列表的结尾。
 *  getFirst() :返回此列表的第一个元素。
 *  getLast() :返回此列表的最后一个元素。
 *  removeFirst() :移除并返回此列表的第一个元素。
 *  removeLast() :移除并返回此列表的最后一个元素。
    
     *  pop() :从此列表所表示的堆栈处弹出一个元素。
 *  push(E e) :将元素推入此列表所表示的堆栈。
 *  isEmpty() ：集合是否为空，为空返回true;

### 四、set接口： ###

Set集合取出元素的方式可以采用：迭代器、增强for。

HashSet是Set 接口的一个实现类；

特点：

存储的元素是不可重复的，并且元素都是无序的；

根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。

哈希表是由数组+链表+红黑树；

保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的；

就必须复写hashCode和equals方法建立属于当前对象的比较方式。

#### 1、LinkedHashSet: ####

链表和哈希表组合:保证了存入其中元素而的有序性，和唯一性；

Set<String> set = new LinkedHashSet<String>();

### 五、Collections工具类： ###

Collections 是集合工具类，用来对集合进行操作：

`shuffle(List<?> list)`:打乱集合顺序。

`public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。  
`public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。

int类型按照升序进行排列；

string类型，按照字母的ASC码进行排序的；

//排序方法
    Collections.sort(list);

`sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序；

Collections.sort(list, new Comparator<Student>() {
        
    	@Override
    	public int compare(Student o1, Student o2) {
        
    		return o1.getAge()‐o2.getAge();//以学生的年龄升序
    }

### 五、Map集合 ###

#### 1、概念 ####

映射：身份证号与个人，这种一一对应的关系；

Collection 中的集合称为单列集合， Map 中的集合称为双列集合；

特点：

Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

#### 2、Map集合子类： ####

HashMap：存储数据采用的哈希表结构，

元素的存取顺序不能保证一致。

保证键唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap：HashMap下有个子类LinkedHashMap，

存储数据采用的哈希表结构+链表结构。

通过链表结构保证元素的存取顺序一致；

通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

#### 3、常用方法： ####

*  put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
 *  remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的
 *  get(Object key) 根据指定的键，在Map集合中获取对应的值。
 *  Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
 *  Set> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
 *  containKey(Object key) :判断该集合中是否有此键；

#### 4、Map的遍历： ####

——键找值方式：

1.  获取Map中所有的键（keyset()）
2.  遍历键的Set集合，得到每一个键。
3.  根据键，获取键所对应的值。（get(K key)）

//  1、将key以Set形式取出
    Set<Object> keySet = hashMap.keySet();
    //  2、将key转为迭代器
    Iterator<Object> iterator = keySet.iterator();
    //  3、遍历取值
    while (iterator.hasNext()) {
        
        String key = iterator.next().toString();
        String value = hashMap.get(key).toString();
        System.out.println(key + "==" + value);
    }

——键值对方式

使用方法：

Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
    那么同样Entry中，获取键和获取值的方法：
    getKey() ：获取Entry对象中的键。
    getValue() ：获取Entry对象中的值。

1、获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。— entrySet() 。

2、遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

3、通过键值对(Entry)对象，获取Entry对象中的键与值。——getkey() getValue()

//  1、获取键值对(Entry)对象
    Set<Map.Entry<Object, Object>> entries = hashMap.entrySet();
    //  2、转为迭代器
    Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
    //  3、遍历取值
    while (iterator.hasNext()) {
        
        Map.Entry<Object, Object> next = iterator.next();
        String key = next.getKey().toString();
        String value = next.getValue().toString();
        System.out.println(key + "==" + value);
    }

#### 5、可变参数： ####

public static int getSum(int… arr) ：可变参数的使用格式；

int sum = getSum(6, 7, 2, 12, 2121);//调用方法;
    public static int getSum(int... arr) {
        //接受数值
        int sum = 0;
        for (int a : arr) {
        //遍历求和
        sum += a;
        }
    }

注意：

1.一个方法只能有一个可变参数

2.如果方法中有多个参数，可变参数要放到最后。

Collections中也提供了添加一些元素方法：

//往集合中添加一些元素；
    public static <T> boolean addAll(Collection<T> c, T... elements)

具体应用：

ArrayList<Integer> list = new ArrayList<Integer>();
    //采用工具类 完成 往集合中添加元素
    Collections.addAll(list, 5, 222, 1，2);

#### 6、 HashSet集合存储数据的结构（哈希表）(扩容机制) ####

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用数组处理冲突，同一hash值的链表都存储在一个数组里。  
但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈  
希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找  
时间。  
简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。  
![在这里插入图片描述][9bdcfd5466204b039189137a82496782.png_pic_center]

![在这里插入图片描述][661152b360654a8593bfc5ae2d0ea36e.png_pic_center]

### 六、xmind整理 ###

#### 1、图： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 1]

#### 2、[CSDN地址：][CSDN] ####

https://download.csdn.net/download/weixin_44624117/12598401

#### 3、[百度云地址：][Link 1] ####

链接：https://pan.baidu.com/s/1gj6H6BZ9wi8kML9fTwEseQ 
    提取码：uc55

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200710173204546.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[20200710173331832.png]: https://img-blog.csdnimg.cn/20200710173331832.png
[9bdcfd5466204b039189137a82496782.png_pic_center]: https://img-blog.csdnimg.cn/9bdcfd5466204b039189137a82496782.png#pic_center
[661152b360654a8593bfc5ae2d0ea36e.png_pic_center]: https://img-blog.csdnimg.cn/661152b360654a8593bfc5ae2d0ea36e.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200710173541537.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70
[CSDN]: https://download.csdn.net/download/weixin_44624117/12598401
[Link 1]: https://pan.baidu.com/s/1gj6H6BZ9wi8kML9fTwEseQ