Set接口 特性:元素没有先后顺序且不允许重复

By xyp-hf

Update date:

Set接口(重点)

基本概念

java.util.Set接口是Collection接口的子接口，元素没有先后放入次序，并且不允许重复
该接口的主要实现类有：HashSet类 和 TreeSet类。

其中HashSet类的底层是采用哈希表进行数据管理的。

其中TreeSet类的底层是采用二叉树进行数据管理的。

此类最大的作用是去重。

Set接口的常用方法参考Collection接口即可。

boolean add(E e) 
          如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。 

boolean addAll(Collection<? extends E> c) 
          如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。 

 void clear() 
          移除此 set 中的所有元素（可选操作）。 

 boolean contains(Object o) 
          如果 set 包含指定的元素，则返回 true。 

 boolean containsAll(Collection<?> c) 
          如果此 set 包含指定 collection 的所有元素，则返回 true。 

 boolean equals(Object o) 
          比较指定对象与此 set 的相等性。 

 int hashCode() 
          返回 set 的哈希码值。 

 boolean isEmpty() 
          如果 set 不包含元素，则返回 true。 

 Iterator<E> iterator() 
          返回在此 set 中的元素上进行迭代的迭代器。 

 boolean remove(Object o) 
          如果 set 中存在指定的元素，则将其移除（可选操作）。 

 boolean removeAll(Collection<?> c) 
          移除 set 中那些包含在指定 collection 中的元素（可选操作）。 

 boolean retainAll(Collection<?> c) 
          仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。 

 int size() 
          返回 set 中的元素数（其容量）。 

 Object[] toArray() 
          返回一个包含 set 中所有元素的数组。 

<T> T[] 
 toArray(T[] a) 
          返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

Iterator iterator() - 用于获取当前集合中的迭代器，用于迭代集合中的所有元素。

迭代就是遍历/访问的意思，通俗来说，使用该方法的返回值可以访问集合任意元素

  • Iterator接口中的常用方法有：

boolean hasNext() - 用于判断当前集合中是否拥有可以访问的元素，如有返回true;

E next() - 获取一个元素返回后并指向下一个元素。

void remove() - 用于删除集合中刚刚获取到的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestSet {

	public static void main(String[] args) {

		// 接口类型的引用指向实现类的对象，形成了多态
		Set<Integer> s1 = new HashSet<Integer>();

		// 向Set集合中添加元素并打印集合中的所有元素
		boolean b1 = s1.add(new Integer(2));
		System.out.println("b1 = " + b1); // true
		System.out.println("s1 = " + s1); // [2]

		// 元素没有先后放入次序
		b1 = s1.add(new Integer(3));
		System.out.println("b1 = " + b1); // true
		System.out.println("s1 = " + s1); // [2, 3]

		b1 = s1.add(new Integer(1));
		System.out.println("b1 = " + b1); // true
		System.out.println("s1 = " + s1); // [1, 2, 3]

		b1 = s1.add(new Integer(2));
		System.out.println("b1 = " + b1); // false
		// 自动调用toString()方法实现打印 String类型的整体
		System.out.println("s1 = " + s1); // [1, 2, 3]

		System.out.println("--------------------------------");
		// 使用迭代器来访问集合中的每一个元素
		Iterator<Integer> it = s1.iterator();
		
		/*// 判断当前集合中是否拥有可以访问的元素
		b1 = it.hasNext();
		System.out.println("b1 = " + b1); // true
		// 获取集合中的一个元素并指向下一个元素的位置
		Integer it1 = it.next();
		System.out.println("获取到的元素是：" + it1); // 1

		// 判断当前集合中是否拥有可以访问的元素
		b1 = it.hasNext();
		System.out.println("b1 = " + b1); // true
		// 获取集合中的一个元素并指向下一个元素的位置
		it1 = it.next();
		System.out.println("获取到的元素是：" + it1); // 2

		// 判断当前集合中是否拥有可以访问的元素
		b1 = it.hasNext();
		System.out.println("b1 = " + b1); // true
		// 获取集合中的一个元素并指向下一个元素的位置
		it1 = it.next();
		System.out.println("获取到的元素是：" + it1); // 3

		// 判断当前集合中是否拥有可以访问的元素
		b1 = it.hasNext();
		System.out.println("b1 = " + b1); // false
		// 获取集合中的一个元素并指向下一个元素的位置
		//it1 = it.next();  产生异常
		//System.out.println("获取到的元素是：" + it1);
*/	
	    while(it.hasNext()){
	    	System.out.println("获取到的元素是：" + it.next());
	    }	
	    
	    System.out.println("--------------------------------");
	    //使用迭代器获取集合中的每一个元素并进行判断，若获取到的是2则删除该元素
	    //重新获取当前集合中的迭代器
	    it = s1.iterator();
	    System.out.println(it.hasNext()); //false  true
	    while(it.hasNext()){
	    	//System.out.println("我要看看你是否执行了！！！");
	    	Integer it2 = it.next();
	    	if(it2.equals(2)){
	    		it.remove(); //调用迭代器自己的remove()方法把刚刚获取的元素删除
	    		//使用Set集合自己的remove()方法来删除元素2
	    		//s1.remove(it2); //产生并发修改异常
	    	}
	    	else{
	    		System.out.println(it2);
	    	}
	    }	
	    
	    System.out.println("--------------------------------");
	    //打印删除元素之后集合中的所有元素
	    System.out.println(s1); //[1, 3]
	    
	    System.out.println("--------------------------------");
	    //使用增强版的for循环/for each结构来访问集合中的所有元素
	    for(Integer it3 : s1){
	    	System.out.println(it3);
	    }
	    
	    System.out.println("--------------------------------");
	    //使用for each结构来访问数组中的每个元素
	    int[] arr = {11, 22, 33, 44, 55};
	    for(int i : arr){
	    	System.out.println(i);
	    }
	}

}

注意：
使用迭代器访问集合中的元素时，不允许使用集合自己的remove()方法来删除元素，否则会产生并发修改异常，应该使用迭代器自己的remove()方法。

增强版的for循环(for each结构)

(1)语法格式
for(元素类型 变量名 : 数组名/集合名){
循环体;
}

(2)执行流程
不断地从数组/集合中取出一个元素赋值给变量名，然后在循环体中使用变量名处理，
直到取完所有元素为止。

JAVA
集合