JAVA_从基础学起（十二）集合类

12 集合类

12.1 集合类概述

java.util包中提供了一些集合类，又称为容器。容器中存放的是对象的引用，长度可以变化。常用的集合类有List，Set和Map等，其中List和Set继承了Collection接口，个借口还提供了不同的实现类。

12.2 Collection接口

Colection接口是层次结构中的跟借口。构成Collection接口的单位叫做元素。Collection接口通常不能直接使用，但是该接口提供了添加元素，删除元素，管理数据的方法。而List和Set集合继承了Collection接口，因此这些方法对List和Set集合都是通用的。
Collection接口的一些常用方法：

方法	功能描述
add(E e)	将制定的对象添加到该集合中
remove(Object o)	将指定的对象从该集合中删除
isEmpty()	返回布尔值，判断当前集合是否为空集合
iterator()	返回在次Collection的元素上进行迭代的迭代器。用于遍历集合中的对象
size()	返回int型值，获取该集合中元素的个数

通常来说，遍历集合都是通过迭代器来实现的。Collection接口中的iterator方法可以返回在此Collection进行迭代的迭代器。下面的实例就是典型的遍历集合的方法：

import java.util.*
public class Muster{
    public static void main(String[] args){
        Collection<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        
        Iterator<String> it = list.itrerator();
        while(it.hasNext()){
            String str = (String)it.next();
            System.out.println(str);
        }
    }
}

需要注意的是，next()函数的返回值类型为Object。

11.3 List集合

List集合包括List接口以及List接口的所有实现类。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。类似Java数组，用户可以通过使用索引来访问集合中的元素。

11.3.1 List接口

List接口继承了Collection接口，包含Collection中的所有方法。此外还定义了两个非常重要的方法，分别为get方法和set方法。

11.3.2 List接口的实现类

List接口的常用实现类由ArrayList和LinkedList。
ArrayList类实现了可变的数组，允许保存所有元素包括null，可以根据索引位置对集合进行快速随机的访问；但是缺点是向指定索引位置插入对象或删除对象的速度较慢。
LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象。插入删除对象是，使用LinkedList类实现效率较高，但是随机访问集合中的对象时效率较低。
与数组相同，集合的索引也是从零开始。

11.4 Set集合

Set集合中的各对象不按特定的方式排序，只是简单地把对象加入集合中，但是Set集合中不能包含重复对象。Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection节后，因此包含Collection接口的所有方法。
Set的构造有一个约束条件，传入的Collection对象不能有重复值，必须小心操作可变对象。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object) == true ,则会出现一些问题。

S而它接口常用的实现类有HashSet类与TreeHash类。
HashSet类实现Set接口，由哈希表（实际上时一个HashMap实例）支持。他不保证Set的选择顺序，特别是不保证该顺序恒久不变。此类允许使用null元素
TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。TreeSet类新增的方法有：

方法	功能描述
first()	返回此Set中当前第一个（最低）元素
last()	返回此Set中当前最后一个（最高）元素
comparator()	返回对此Set中的元素进行排序的比较器，如果按照自然排序则返回null
headSet(E toElement)	返回一个新的Set集合，新集合是toElement对象（不包含）前的所有对象
subSet(E fromElement ，E toElement)	返回一个新的Set集合，新集合是fromElement对象（包含）与toElement对象（不包含）之间的所有对象
tailSet(E fromElement)	返回一个新的Set集合，新集合是toElement对象（不包含）后的所有对象

下面通过实例介绍：

package com.mw;

import java.util.Iterator;
import java.util.TreeSet;

public class UpdateStu implements Comparable<Object>{
	String name ;
	long id;
	
	public UpdateStu(String name, long id) {//构造方法
		this.name = name;
		this.id = id;
	}

	public int compareTo(Object o) {
		UpdateStu updateStu = (UpdateStu)o;
		int result = id>updateStu.id?1:(id==updateStu.id?0:-1);
		return result;
	}
	
	public String getName(){
		return name;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
	public long getId(){
		return id;
	}
	
	public void setId(long id){
		this.id = id;
	}
	
	public static void main(String[] args) {
		UpdateStu up1Stu = new UpdateStu("李同学", 01011);
		UpdateStu up2Stu = new UpdateStu("陈同学", 01021);
		UpdateStu up3Stu = new UpdateStu("王同学", 01051);
		UpdateStu up4Stu = new UpdateStu("张同学", 01012);
		
		TreeSet<UpdateStu> treeSet = new TreeSet<UpdateStu>();//向集合中添加对象
		treeSet.add(up1Stu);
		treeSet.add(up2Stu);
		treeSet.add(up3Stu);
		treeSet.add(up4Stu);
		
		Iterator<UpdateStu> iterator = treeSet.iterator();
		System.out.println("Set集合中的各所有元素：");
		while (iterator.hasNext()) {
			UpdateStu updateStu = (UpdateStu)iterator.next();
			System.out.println(updateStu.getId()+" "+updateStu.getName());
		}
		
		iterator = treeSet.headSet(up2Stu).iterator();  //截取排up2stu对象前的对象
		System.out.println("截取前面部分的集合：");
		while (iterator.hasNext()) {
			UpdateStu updateStu = (UpdateStu)iterator.next();
			System.out.println(updateStu.getId()+" "+updateStu.getName());
		}
		
		iterator = treeSet.subSet(up2Stu, up3Stu).iterator();
		System.out.println("截取中间部分的集合：");
		while (iterator.hasNext()) {
			UpdateStu updateStu = (UpdateStu)iterator.next();
			System.out.println(updateStu.getId()+" "+updateStu.getName());
		}
	}
}

存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、0或负整数。

而且当选取集合的子集时，一般可以进行如下判断：指定参数是新集合的终止位置时，一般不包含该参数表示的对象；指定参数是新集合的起始位置时，则包含该参数表示的对象。

12.5 Map集合

Map集合没有继承Collection接口，其提供的是key到value的映射。Map中不能包含相同的key，每个key只能映射一个value。key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过“散列技术”进行处理，产生一个散列码的整数值。散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。Map集合包括Map接口以及Map接口的所有实现类。

12.5.1 Map接口

Map接口提供了将key映射到值的对象。一个映射不能包含重复的key，每个key最多只能映射到一个值。Map接口中同样提供了集合的常用方法，除此之外还包括如下所示的常用方法：

方法	功能描述
put(K key , V value)	向集合中添加指定的key与value映射关系
containsKey	如果此映射包含着指定key的映射关系，则返回true
containsValue	如果此映射将一个或多个key映射到指定值，则返回true
get(Object key)	如果存在指定的key对象，则返回该对象对应的值，否则返回null
keySet()	返回该集合中的所有key对象形成的Set集合
values()	返回集合中所有值对象形成的Collection集合

下面通过实例介绍Map接口中一些方法的使用：

package com.mw01;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class UpdateStu {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();   //创建Map实例
		map.put("01", "李同学");
		map.put("02", "魏同学");
		Set<String> set = map.keySet();                        //构建Map集合中所有key对象的集合
		Iterator<String> iterable =  set.iterator();            //创建集合迭代器
		System.out.println("key集合中的元素：");
		while (iterable.hasNext()) {
			System.out.println(iterable.next());
		}
		
		Collection<String> collection = map.values();         //构建Map集合中所有value值的集合
		iterable = collection.iterator();
		System.out.println("Value集合中的元素：");
		while (iterable.hasNext()) {
			System.out.println(iterable.next());
		}
	}
}

Map集合中允许值对象时null，而且没有个数限制值。即可以通过map.put(05,null);的语句向集合中添加对象。

12.5.2 Map接口的实现类

Map接口的实现类常用的有HashMap和TreeMap。建议使用HashMap类实现Map集合，因为由HashMap实现的Map集合添加和删除映射关系效率更高。HashMap是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找；而TreeMap中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。

1. HashMap是基于哈希表的Map接口实现的，这个实现提供所有可选的映射操作，并允许使用null值和null键，但是必须保证key的唯一性。HashMap通过哈希表对其内部的映射关系进行快速的查找，但不保证映射的顺序，特别是不保证该顺序恒久不变。
2. TreeMap不仅实现了Map接口，还实现了java.util.SortedMap接口，因此集合中的各映射关系时有一定顺序的。但是在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。而且因为映射关系是根虎key对象按照一定顺序排列的，因此不允许key对象为null
   所以我们可以使用HashMap创建应设计和，当需要顺序输出时，在创建一个完成相同映射关系的TreeMap类实例。

下面通过HashMap实例化Map集合，比那里Map集合后实例化TreeMap实例实现将集合中的元素顺序输出：

package com.mw02;
import java.util.*;

//创建Emp类
public class Emp {
	private String e_id;
	private String e_name;
	public Emp(String e_id, String e_name) {
		this.e_id = e_id;
		this.e_name = e_name;
	}
	public void setId(String id) {
		e_id = id;
	}
	public void setName(String name) {
		e_name = name;
	}
	public String getId() {
		return e_id;
	}
	public String getName() {
		return e_name;
	}
}
//实例化HashMap集合并输出，实例化TreeMap并输出，比较不同
public class MapText {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		
		Emp mEmp1 = new Emp("351", "张三");
		Emp mEmp2 = new Emp("512", "李四");
		Emp mEmp3 = new Emp("853", "王一");
		Emp mEmp4 = new Emp("125", "赵六");
		Emp mEmp5 = new Emp("341", "黄七");
		
		map.put(mEmp1.getId(), mEmp1.getName());
		map.put(mEmp5.getId(), mEmp5.getName());
		map.put(mEmp3.getId(), mEmp3.getName());
		map.put(mEmp2.getId(), mEmp2.getName());
		map.put(mEmp4.getId(), mEmp4.getName());

		Set<String> set = map.keySet();
		Iterator<String> iterator = set.iterator();
		System.out.println("HashMap类实现的Map集合，无序：");  //使用HashMap来进行无序的输出
		while (iterator.hasNext()) {
			String string = iterator.next();
			String nameString = (String)map.get(string);
			System.out.println(string + " " + nameString);
		}
		
		Map<String, String> map2 = new TreeMap<String, String>();
		map2.putAll(map);                          //向集合中添加对象
		Iterator<String> iterator2 = map2.keySet().iterator();
		System.out.println("TreeMap实现的Map集合，键对象升序排序:");
		while (iterator2.hasNext()) {
			String string = iterator2.next();
			String nameString = map2.get(string);
			System.out.println(string + " " + nameString);
			
		}
 	}
}

输出结果为：

HashMap类实现的Map集合，无序：
341 黄七
125 赵六
853 王一
512 李四
351 张三
TreeMap实现的Map集合，键对象升序排序:
125 赵六
341 黄七
351 张三
512 李四
853 王一

---

2020.6.11