集合及集合的交，并与差-CFANZ编程社区

HashSet<E>泛型类在数据组织上类似于数学上的集合,可以进行“交”“并”“差“等运算。HashSet<E>泛型类实现了泛型接口Set<E>,而Set<E> 接口是Collection<E>接口的子接口。HashSet<E>类中的绝大部分方法都是接口方法的实现。编程时,可以使用接口回调技术,即把HashSet<E>对象的引用赋值给Collection<E>接口变量或Set<E>接口变量,那么接口就可以调用类实现的接口方法。

HashSet<E>泛型类

HashSet<E>泛型类创建的对象称为集合,如
HashSet < String> set = HashSet < String >();
那么set就是一个可以存储String类型数据的集合,set可以调用add (String s)方法将String 类型的数据添加到集合中,添加到集合中的数据称作集合的元素。集合不允许有相同的元素, 也就是说,如果b已经是集合中的元素,那么再执行set.add(b)操作是无效的。集合对象的初始容量是16字节,装载因子是0.75,也就是说,如果集合添加的元素超过总容量的75%时, 集合的容量将增加一倍。

常用方法
HashSet<E>泛型类的常用方法如下。
public boolean add(E o);向集合添加参数指定的元素。

public void clear():清空集合，使集合不含有任何元素。

public boolean contains(Object o):判断参数指定的数据是否属于集合

public boolean isEmpty():判断集合是否为空

public boolean remove(Object o):集合删除参数指定的元素

public int size():返回集合元素的个数

Object[] toArray():将集合元素存放到数组中，并返回这个数组

boolean containsAll(HanshSet set):判断当前集合是否包含参数指定的集合。
public Object clone():得到当前集合的一个克隆对象,该对象中元素的改变不会影响到当前集合中的元素,反之亦然。
可以借助泛型类Iterator<E>实现遍历集合,一个集合对象可以使用iterator()方法返回一个Iterator<E>类型的对象。如果集合是Student类型的集合,即集合中的元素是Student类创建的对象,那么该集合使用iterator()方法返回一个Iterator<Student>类型的对象,该对象使用next()方法遍
历集合。

我们把学生的成绩存放在一个集合中,并实现了遍历集合。

import java.util.*;
class Student{
	String name;
	int score;
	Student(String name,int score){
		this.name=name;
		this.score=score;
	}
}

public class E13_11 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student zh = new Student("小美",99),
				wa = new Student("小哇",78),
				li = new Student("小李",67);
		HashSet<Student>set = new HashSet<Student>();
		HashSet<Student>subset = new HashSet<Student>();
		set.add(zh);
		set.add(wa);
		set.add(li);
		subset.add(wa);
		subset.add(li);
		//public boolean contains(Object o):判断参数指定的数据是否属于集合
		if(set.contains(wa)) {
			System.out.println("集合set中含有："+wa.name);
			
		}
		if(set.containsAll(subset)) {
			System.out.println("集合set包含集合subset");
			
		}
		int number = subset.size();
		System.out.println("集合subset含有"+number+"个元素");
		Object s[]=subset.toArray();//Object[] toArray():将集合元素存放到数组中，并返回这个数组。
		for(int i=0;i<s.length;i++) {
			System.out.printf("姓名：%s,分数:%d\n",((Student)s[i]).name,((Student)s[i]).score);
		}
		number = set.size();
		System.out.println("集合set中有"+number+"个元素：");
		Iterator<Student>iter = set.iterator();
		while(iter.hasNext()) {
			Student te = iter.next();
			System.out.printf("姓名：%s,分数:%d\\n",te.name,te.score);
		}
	}

}

运行结果：

集合set中含有：小哇
集合set包含集合subset
集合subset含有2个元素
姓名：小李,分数:67
姓名：小哇,分数:78
集合set中有3个元素：
姓名：小李,分数:67\n姓名：小美,分数:99\n姓名：小哇,分数:78\n

集合的交，并与差

集合对象调用 boolean retainAll (HashSet set)方法可以与参数指定的集合求交运算,使得当前集合成为两个集合的交。
集合对象调用boolean addAll(HashSet set)方法可以与参数指定的集合求并运算,使得当前集合成为两个集合的并。
集合对象调用boolean removeAll (HashSet set)方法可以与参数指定的集合求差运算,使得当前集合成为两个集合的差。
参数指定的集合必须与当前集合是同种类型的集合,否则上述方法返回false。

求两个集合A、B的对称差集合,即求A-B 与B-A的合集。

import java.util.*;
public class E13_12 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<Integer>A = new HashSet<Integer>(),
						B = new HashSet<Integer>();
		for(int i=1 ; i<=4; i++) {
			A.add(i);
		}
		B.add(1);
		B.add(2);
		B.add(5);
		B.add(6);
		HashSet<Integer>tempSet = (HashSet<Integer>)A.clone();
		A.removeAll(B); //A变成调用该方法之前的集合A与集合B的差集
		B.removeAll(tempSet); //B变成调用该方法之前的集合B与集合tempSet的差集
		B.addAll(A); //B就是最初的A与B的对称差
		
		int number = B.size(); 
		System.out.println("A和B的对称差集合有"+number+"个元素");
		Iterator<?> iter = B.iterator();
		while(iter.hasNext()) {
			System.out.printf("%d,",iter.next());
		}
	}
}

运行结果：

A和B的对称差集合有4个元素
3,4,5,6,

1,使用“class名称<泛型列表>"声明一个泛型类，当使用泛型类声明对象时，必须用具体类型(不能是基本数据类型)替换泛型列表中的泛型。
2. LinkedList <E>泛型类创建的对象以链表结构存储数据，链表是由若干个被称为结点对象组成的一种数据结构，每个结点含有一个数据以及上一个结点的引用和下一个结点的引用。
3. Stack < E>泛型类创建一个堆栈对象，堆栈把第一个放入该堆栈的数据放在最底下，而把后续放入的数据放在已有数据的上面，堆栈总是在顶端进行数据的输入/输出操作
4. HashMap <K,V>泛型类创建散列映射，散列映射采用散列表结构存储数据，用于存储键/值数据对，允许把任何数量的键/值数据对存储在一起。使用散列映射存储经常需要检索的数据，可以减少检索的开销。
5. TreeSet < E>类创建树集，树集结点的排列和链表不同，不按添加的先后顺序排列，当一个树集中的数据是实现Comparable接口类创建的对象时，结点将按对象的大小关系升序
6. TreeMap <K,V>类创建树映射，树映射的结点存储“键/值”对，和树集不同的是，树映排列。射保证结点是按照结点中的“键”升序排列。