JavaSE 集合

布满荆棘的人生 2022-02-04 20:37 224阅读 0赞

## 个人博客网：[https://wushaopei.github.io/][https_wushaopei.github.io]    (你想要这里多有) ##

## 一、数组和集合 ##

### 1、相同点： ###

>    数组 与 集合 都是内存中对数据进行存储和管理的“容器”

### 2、数组存储的特点和缺点 ###

特点：

>         1.数组一旦创建成功，长度不可改变
> 
>          2.元素存储的类型就是数组声明时的类型

缺点：

>            1.数组的长度不可变
> 
>             2.数组的API属性比较少，比如没有 增、删、改、插 等.....
> 
>             3. 存储的元素是有序的可重复的，对无序的不可重复的无能为力

### 3、集合存储的特点 ###

>       1.长度可变
> 
>        2.底层的数据结构比较丰富。比如：数组，链表，红黑树
> 
>        3.集合的API比较丰富，比如 增 ，删，改 ，查，插等.......
> 
>        4.对数据的存储方式支持也比较多，比如有序可重复，无序不可重复

## 二、集合概述 ##

### 1、集合的体系分类 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70][]

### 2、Collection 接口继承树 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 1][]

### 3、Map接口继承树 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 2][]

## 三、Collection 接口 ##

### 1、Collection 接口 定义 ###

> Collection 接口是 List 、Set 和 Queue接口的父接口，该接口里定义的方法既可以用于操作Set集合，也可以用于操作List 和Queue集合。

> 由于JDK 不提供此接口的任何直接实现，而是提供更具体的子接口（如： Set 和 List ）实现。

**注意：**

> 在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。

### 2、Collection 接口常用方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 3][]

### 3、遍历Collection 的两种方式： ###

**3.1  Iterator 迭代器接口**

** （1）作用**： 通过指针的方式遍历集合元素

**实现**： java.utils 报下定义的迭代器接口： **Iterator**

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
    所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
    Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

**  （2） 如何获取实例： 集合的对象. iterator（****）**

**  （3） 常用方法：**

hasNext() : 判断是否还有下一个元素
    
     next(): ① 指针下移 ②返回指针指向的元素

（4） 案例实操：

public class IteartorTest {
    	
    	@Test
    	public void test2(){
    		Collection c = new ArrayList();
    		c.add("aaa");
    		c.add("bbb");
    		c.add("ccc");
    		c.add("ddd");
    		c.add("eee");
    		
    		/*
    		 * 错误的写法 ： 因为c.iterator()会创建一个新的对象
    		while(c.iterator().hasNext()){
    			System.out.println(c.iterator().next());
    		}
    		*/
    		
    		/*
    		 * 错误的写法：因为每次调用next()方法都会指针下移
    		Iterator iterator = c.iterator();
    		while(iterator.next() != null){
    			System.out.println(iterator.next());
    		}
    		*/
    	}
    
    	@Test
    	public void test(){
    		
    		Collection c = new ArrayList();
    		c.add("aaa");
    		c.add("bbb");
    		c.add("ccc");
    		c.add("ddd");
    		c.add("eee");
    		
    		//获取Iterator实现类的对象
    		Iterator iterator = c.iterator();
    		
    		//next() ①指针下移  ②返回指针指向的元素
    //		Object obj = iterator.next();
    //		System.out.println(obj);
    //		System.out.println(iterator.next());
    //		System.out.println(iterator.next());
    //		System.out.println(iterator.next());
    //		System.out.println(iterator.next());
    		//如果没有下一个元素则会报异常
    //		System.out.println(iterator.next());
    		
    		//不建议这么写
    		/*
    		System.out.println(iterator.next());
    		for (int i = 0; i < 5; i++) {
    			System.out.println(iterator.next());
    		}
    		*/
    		
    		System.out.println(iterator.next());
    		while(iterator.hasNext()){
    			System.out.println(iterator.next());
    		}
    		
    		
    	}
    }

**    （5） 原理图解：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 4][]

**注意：**

> 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

**  （6）常用接口方法**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 5][]

**3.2 增强 for  循环： （foreach 循环）**

（1）格式

for(元素的类型  临时变量 ： 集合、数组的对象){
        }

注意：Java 5.0 提供了 foreach 循环迭代访问 Collection

（2）案例实操

Collection c = new ArrayList();
    		c.add("gg");
    		c.add("jj");
    		c.add("dd");
    		c.add("mm");
    		
    		for(Object obj : c){
    			System.out.println(obj);
    		}

（3）遍历数组

/*
    	* 可以理解成
    	* 1. String str = names[0];
    	* 2. str = "aaa";
     */
    String[] names = {"小泽泽","小圆圆","小玲玲"};
         for(String str : names){
    		System.out.println(str);
    	}

### 4、Collection 子接口-List 接口 ###

**（1）List 接口 定义 ：**

* Java中数组用来存储数据的局限性
    * List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
    * List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
    * JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

存储的数据特点： **存储的元素是有序的且可重复的  （**由其底层数据结构可知原因）

**（2）List 集合里 用于 根据索引来操作集合元素的方法**

>  *  void add(int index, Object ele)
>  *  boolean addAll(int index, Collection eles)
>  *  Object get(int index)
>  *  int indexOf(Object obj)
>  *  int lastIndexOf(Object obj)
>  *  Object remove(int index)
>  *  Object set(int index, Object ele)
>  *  List subList(int fromIndex, int toIndex) 
> 
>         将当前集合中fromIndex到toIndex位置上的所有元素存放到一个新的集合中 \[fromIndex,toIndex)

（3）常用实现类：

>     |-------ArrayList : 主要实现类
> 
>     |-------LinkedList ： 
> 
>     |-------Vector

**（4）实现类之 : ArrayList**

① 底层原理：

> **a**.  List的主要实现类底层是一个数组，查找快，增删慢。线程不安全的效率高。List的主要实现类底层是一个数组，查找   快，增删慢。线程不安全的效率高。
> 
> **b.** 当我们创建一个空参构造器的ArrayList的对象时，底层会为我们创建一个长度为10的数组，当我们向容器中添加
> 
> **c. ** 第11个元素时，底层会进行扩容，扩容为原来的1.5倍（创建一个长度为原来的1.5倍的数组，同时将原有的数据复制到新的数组中）。

**  注意：**

> Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…)  返回值是一个固定长度的 List 集合

②构造器说明：

> new ArrayList() : 底层创建一个长度为10的数组
> 
> new ArrayList(int initialCapacity) : 创建一个长度为initialCapacity的数组

③案例实操：

>     @Test
>     	public void test2(){
>     		LinkedList list = new LinkedList();
>     		list.add("aaa");
>     		list.add("bbb");
>     		list.add("ccc");
>     		list.add("ddd");
>     		
>     //		list.addFirst("AAA");
>     		
>     		Object obj = list.removeFirst();
>     		
>     		System.out.println(list);
>     		
>     //		System.out.println(list.getFirst());
>     		
>     		System.out.println(obj);
>     				
>     	}

④ 存储的元素的要求 ： 往集合中添加自定义对象的数据时，自定义类必须重写equals

@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}

/*
    	 * 注意：往集合中添加自定义对象的数据时，自定义类必须重写equals
    	 */
    	@Test
    	public void test(){
    		Collection c = new ArrayList();
    		c.add("aaa");
    		c.add(123);
    		c.add("ccc");
    		c.add(new Person("aa",18));
    		
    		//remove(Object o) : 将o从当前集合中删除掉，删除成功返回true，否则返回false
    //		boolean remove = c.remove("aaa");
    //		remove  = c.remove(new Person("aa",18));
    		
    		//removeAll(Collection c): 从当前集合中删除和c集合交集的部分（c和c2相同的数据）。
    		Collection c2 = new ArrayList();
    		c2.add("aaa");
    		c2.add(123);
    		c2.add(555);
    		
    		c.removeAll(c2);
    		
    		System.out.println(c);
    
    	}

**（5）实现类之 : LinkedList**

**   ** ① 作用：对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

② 常用方法：

>     void addFirst(Object obj)  
>     void addLast(Object obj)      
>     Object getFirst()  
>     Object getLast()  
>     Object removeFirst()  
>     Object removeLast()

### 5、List 面试题 ###

**\[面试题\]ArrayList,LinkedList,Vector的区别是什么？**

三者都是List的实现类，存储的元素都是有有序的可重复的。
     ArrayList : List的主要实现类底层是一个数组，查找快，增删慢。线程不安全的效率高。
     LinkedList ： 底层是一个双向链表，查找慢，增删快
     Vector ：古老的实现类，底层是一个数组，查找快，增删慢。线程安全的效率低。

**（1）ArrayList 面试题**

① 思考？ArrayList到底是根据索引去删除，还是删除的是内容

/*
    * 面试题
     */
    @Test
    public void test3(){
    	List list = new ArrayList();
    	list.add("aa");
    	list.add(111);
    	list.add(1);
    		
    	//根据索引值删除内容
    //	Object remove = list.remove(1); //思考？到底是根据索引去删除，还是删除的是内容
    	//删除内容1
    	list.remove(new Integer(1));
    	System.out.println(list);
    }

② ArrayList的底层实现？

当我们创建一个空参构造器的ArrayList的对象时，底层会为我们创建一个长度为10的数组，当我们向容器中添加
    第11个元素时，底层会进行扩容，扩容为原来的1.5倍（创建一个长度为原来的1.5倍的数组，同时将原有的数据复制到新的数组中）。

[https_wushaopei.github.io]: https://wushaopei.github.io/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70]: /images/20220205/59b5d87de36641aea5e1d2d69f4d78c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 1]: /images/20220205/b0728a2779e5424199833c860f19644b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 2]: /images/20220205/fab68dc1de9e4e6d9bc8f1b6105a995c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 3]: /images/20220205/f1ea32e5867a4ce486055a2c6315007d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 4]: /images/20220205/d056f5c5940e4a32b3b82806449556e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwNTY3MA_size_16_color_FFFFFF_t_70 5]: /images/20220205/c552b51d3ec348a0b968e3ca002eed0d.png