集合

Posted 2020-12-08 lf-637

一、集合

1. 集合概述

数组可以保存多个对象，但数组长度不可变，若在初始化数组时指定了数组长度那就是不可变的。为了保存数量不确定的数据，以及保存具有映射关系的数据，Java提供了集合类。集合类主要负责保存、盛装其它数据，因此集合类也被称为容器类。

• Java集合类可用于存储数量不等的多个对象，并可以实现常用的数据结构，如栈、队列等。还可以用于保存具有映射关系的关联数组。

• Java集合类主要由两个接口派生出：Collection和Map。

2. 集合与数组的比较

数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合

• 数组能存放基本数据类型和对象，而集合类存放的都是对象，集合类不能存放基本数据类型。数组和集合存放的对象皆为对象的引用地址。
• 数组容易固定无法动态改变，集合类容量动态改变。
• 数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数
• 集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式
• 集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率

3. 集合框架包含的内容

Java集合框架提供了一套性能优良，使用方便的接口和类，他们位于java.util包中，按照其存储结构可以分为两大类：单列集合java.util.Collection和双列集合java.util.Map。接口和具体类如下图所示：

注意：

• Collection 接口存储一组不唯一，无序的对象。定义的是所有单列集合中共性的方法(不带索引的方法)
• List 接口存储一组有序、可重复的对象。List 关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往 list 集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。
• Set 接口存储一组无序、不能重复的对象，集合中的元素不允许重复，且没有索引(不能用普通for循环遍历)，存储与取出元素顺序可能不同。访问集合中的元素只能根据元素本身来访问（集合里元素不允许重复的原因）
• Map 接口存储一组键值对象，提供key到value的映射。Map 集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对 map 集合遍历时先得到键的 set 集合，对 set 集合进行遍历，得到相应的值

---

二、Collection接口【从顶层开始学习】

1. 概述

Collection接口是处理对象集合的单列集合类根接口，其中定义了很多对元素进行操作的方法。Collection接口有两个主要的子接口List和Set，注意Map不是Collection的子接口

其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。

重点如图：

2. Collection 常用方法

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e)： 把给定的对象添加到当前集合中
• public void clear() :清空集合中所有的元素
• public boolean remove(E e): 把给定的对象在当前集合中删除
• public boolean contains(E e): 判断当前集合中是否包含给定的对象
• public boolean isEmpty(): 判断当前集合是否为空
• public int size(): 返回集合中元素的个数，获取长度
• public Object[] toArray(): 把集合转为一个数组

方法演示：

import java.util.ArrayList;
import java.util.Collection;

public class UseCollection {
    public static void main(String[] args) {
		// 创建集合对象 
    	// 使用多态形式
    	Collection<String> cl = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
		cl.add("你好");
        cl.add("我是");
        cl.add("一个");
        cl.add("好人");
        cl.add("！");
    	System.out.println(cl); //[你好, 我是, 一个, 好人, ！]

    	// boolean contains(E e) 判断o是否在集合中存在
    	System.out.println("判断好人是否在集合中"+cl.contains("好人"));  //true

    	//boolean remove(E e) 删除在集合中的o元素
    	System.out.println("删除好人："+cl.remove("好人"));
    	System.out.println("操作之后集合中元素:"+cl);
    	
    	// size() 集合中有几个元素
		System.out.println("集合中有"+cl.size()+"个元素");
        
		// Object[] toArray()转换成一个Object数组
    	Object[] objects = cl.toArray();
    	// 遍历数组
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中内容为："+cl);
		// boolean  isEmpty()  判断是否为空
		System.out.println(cl.isEmpty());  	
	}
}

注意：有关Collection中的方法并不止上面这些，其他方法可以在API中查看。

---

三、Iterator接口

1. 概述

所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现Iterator接口的对象，**Iterator对象称作为迭代器，用于方便的对容器内元素进行遍历操作 **

在程序开发中，经常需要遍历集合中的所有元素。JDK为此提供了一个接口java.util.Iterator。Iterator接口也属于Java集合，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素。

Iterator迭代器是一个接口，无法直接使用。需要使用接口中的iterator方法。

• public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素

Iterator接口的常用方法如下：

• public E next(): 取出的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

迭代器的使用步骤

• 使用集合中的方法iterator()获取迭代器的实现类对象，用Iterator接口接收(多态)
• 使用Iterator接口中的方法hasNext判断有没有下一个元素
• 使用Iterator接口接口中的方法取出集合中的下一个元素

接下来我们通过案例学习如何使用Iterator迭代集合中的元素：

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();

        // 添加元素到集合
        coll.add("喵星人");
        coll.add("铲屎官");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
  	}
}

tips:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

2. 增强for

增强for循环(也称for each循环)，是JDK1.5以后出现的高级for循环，专用来遍历数组和集合。其内部原理是Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型 元素变量x  : 数组或集合对象){ 
  	//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

注意： 增强for循环必须有被遍历的目标。目标只能是Collection或者是数组。且仅为遍历操作出现

实例：

private static void useFor(){
	int[] arr = {1,2,3,4,5,6};
	for (int i : arr){
		System.out.println(i)
	}
}//1 2 3 4 5 6

---

四、泛型

1. 概述

泛型是 JDK 5 中引入的一个新特性, 它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

泛型是一种位置的数据类型，当我们不知道要用什么数据类型的时候可以用泛型。泛型也可以看成一个变量用来接受数据类型。

E e ：Elem元素
T t ：Type类型

ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据，所以使用泛型。集合对象在创建的时候才会确定类型。E：未知的类型

2. 使用泛型的好处

若创建集合对象，不使用泛型

• 好处是默认的类型就是Object类型，可以存储任意类型的数据
• 弊端是不安全，会引发异常

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}

若创建集合对象，使用泛型

• 优点
  • 避免了类型转换的麻烦，存储与取出的是同种类型
  • 把运行期的异常(运行之后抛出的异常)，提升到了编译期(写代码的时候报错)
• 缺点：泛型是什么类型，就只能存储什么类型的数据

3. 泛型的定义与使用

泛型用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如 API中的ArrayList集合：

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

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

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

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例自定义泛型类

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如，

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

使用格式：调用方法时，确定泛型的类型

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

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如，

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) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型。接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。就相当于定义了一个含有泛型的类

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

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

4. 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?，其中?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

tips:泛型不存在继承关系 Collection

以上是关于集合的主要内容，如果未能解决你的问题，请参考以下文章

金蝶handler中 collection 代码片段理解

Alfred常见使用

比较 C# 中的字符串片段并从集合中删除项目

带有红宝石集合/可枚举的酷技巧和富有表现力的片段[关闭]

[ jquery 文档处理 insertBefore(content) before(content|fn) ] 此方法用于把所有匹配的元素插入到另一个指定的元素元素集合的前面,实现外部插入(代码片段

前端开发常用js代码片段