java集合——HashSet与LinkedHashSet

Set VS List

1. List是有序的可重复集合，Set是自然有序不可重复集合
2. List的有序是指集合元素的存取有序，即添加的顺序与取出的顺序一致，而Set是一种自然有序的集合（使用链表结构的LInkedHashSet除外），自然有序是指集合类的元素是自然排序（自然排序：比如自然数：1,2,3,4,5,6 字母顺序：a,b,c,d,e)
3. List是有序存储，存在下标，Set是使用HashCode进行存储，不存在下标，其底层是由map来实现。

HashSet的基本使用

创建集合

Set集合创建时必须选择对数据类型，这样保证了数据的一种安全。

HashSet<String> set  =new HashSet<>();
HashSet<String> set2  =new HashSet<>();
HashSet<Integer> set3 = new HashSet<>();
HashSet<Character> set4 = new HashSet<>();

添加集合元素

1. 逐个添加

set.add("张三1");
set.add("张三丰2");
set.add("张三3");
set.add("张三丰4");

2. 批量添加

//通过CollectionS工具类批量添加
Collections.addAll(set2,"李四1","李四2","张三3","张三5");
//通过自己的方法批量添加
set.addAll(set2);

常用方法

1. 保留交集

set.retainAll(set2);

2. 去除交集

set.removeAll(set2);

3. 判断集合是否包含否元素

System.out.println(set.contains("张三5"));

4. 判断set集合是不是全部包含set2集合

System.out.println(set.containsAll(set2));

5. 删除

set.remove("张三8");
//过滤器删除
set.removeIf(new Predicate<String>() {
			@Override
			public boolean test(String t) {
				if(t.length() > 3)//过滤掉元素长度大于3的元素
					return true;
				return false;
			}
		});

遍历

Set遍历不能使用普通循环遍历，因为Set集合没有下标

1. 增强for循环遍历

System.out.println("--------------增强for循环--------------");
	for (String string : set) {
		System.out.println(string);
	}

2. 迭代器遍历

Iterator<String> it =set.iterator();
	System.out.println("--------------迭代器遍历--------------");
	while(it.hasNext()) {
		String ele = it.next();
		System.out.println(ele);
	}

测试所写代码

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Predicate;

public class HashSetTest {
	public static void main(String[] args) {
		//HashSet的基本使用
		/*
		 * 特点：1、存放的元素是不同的，也就是不能存放相同元素
		 * 		2、无序：取出的顺序与存入的顺序不一定相同，
		 * 存入时自动计算hash值，然后根据hash值进行存储
		 * 		3、不存在下标，所以在集合中有关下标的方法都不能使用
		 */
		System.out.println("---------------Integer类型自然排序效果-------------------");
		HashSet<Integer> set3 = new HashSet<>();
		set3.add(4);
		set3.add(7);
		set3.add(3);
		set3.add(1);
		set3.add(5);
		set3.add(3);
		for (Integer integer : set3) {
			System.out.println(integer);
		}
		System.out.println("--------------Character类型自然排序效果--------------------");
		HashSet<Character> set4 = new HashSet<>();
		set4.add('A');
		set4.add('B');
		set4.add('C');
		set4.add('D');
		set4.add('F');
		set4.add('E');
		for (Character character : set4) {
			System.out.println(character);
		}
		HashSet<String> set = new HashSet<>();
		set.add("张三1");
		set.add("张三丰2");
		set.add("张三3");
		set.add("张三丰4");
		set.add("张三5");
		set.add("张三丰6");
		set.add("张三7");
		set.add("张三丰8");
		System.out.println("集合的长度："+set.size());
		//删除
		set.remove("张三8");
		//过滤器删除
		set.removeIf(new Predicate<String>() {

			@Override
			public boolean test(String t) {
				if(t.length() > 3)//过滤掉元素长度大于3的元素
					return true;
				return false;
			}
		});
		
		//批量添加
		HashSet<String> set2  =new HashSet<>();
		Collections.addAll(set2,"李四1","李四2","张三3","张三5");
		set.addAll(set2);
		//保留交集
		set.retainAll(set2);
		//去除交集
		//set.removeAll(set2);
		
		//判断集合是否包含否元素
		System.out.println(set.contains("张三5"));
		//判断set集合是不是全部包含set2集合
		System.out.println(set.containsAll(set2));
		
//		遍历(增强for循环，即foreach，其实现也是使用迭代器的方式)
		System.out.println("--------------增强for循环--------------");
		for (String string : set) {
			System.out.println(string);
		}
		
		//迭代器方式遍历
		Iterator<String> it =set.iterator();
		System.out.println("--------------迭代器遍历--------------");
		while(it.hasNext()) {
			String ele = it.next();
			System.out.println(ele);
		}
		
	}
	 
}

LinkedHashSet

LinkedHashSet与HashSet没什么太大差别，只是LinkedHashSet在HashSet的基础上使用了双向链表的数据结构，所以这个集合是有序的，即存取有序，其他的用法和上面的HashSet是一样的用法。

测试所写代码

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Set;
import java.util.function.Predicate;

public class LinckedHashSetTest {
	public static void main(String[] args) {
		//HashSet的基本使用
		/*
		 * 特点：1、存放的元素是不同的，也就是说不能存放相同元素
		 * 		2、有序：通过双向链表的存储结构保证有序
		 * 		3、不存在下标，所以在集合中有关下标的方法都不能使用
		 * 		4、继承于HashSet
		 */

		LinkedHashSet<String> set = new LinkedHashSet<>();
		set.add("张三1");
		set.add("张三丰2");
		set.add("张三3");
		set.add("张三丰4");
		set.add("张三5");
		set.add("张三丰6");
		set.add("张三7");
		set.add("张三丰8");
		System.out.println("集合的长度："+set.size());
		System.out.println("有序测试：");
		for (String string : set) {
			System.out.println(string);
		}
		//删除
		set.remove("张三8");
		//过滤器删除
		set.removeIf(new Predicate<String>() {

			@Override
			public boolean test(String t) {
				if(t.length() > 3)//过滤掉元素长度大于3的元素
					return true;
				return false;
			}
		});
		
		//批量添加
		HashSet<String> set2  =new HashSet<>();
		Collections.addAll(set2,"李四1","李四2","张三3","张三5");
		set.addAll(set2);
		//保留交集
		set.retainAll(set2);
		//去除交集
		//set.removeAll(set2);
		
		//判断集合是否包含否元素
		System.out.println(set.contains("张三5"));
		//判断set集合是不是全部包含set2集合
		System.out.println(set.containsAll(set2));
		
//		遍历(增强for循环，即foreach，其实现也是使用迭代器的方式)
		System.out.println("--------------增强for循环--------------");
		for (String string : set) {
			System.out.println(string);
		}
		
		//迭代器方式遍历
		Iterator<String> it =set.iterator();
		System.out.println("--------------迭代器遍历--------------");
		while(it.hasNext()) {
			String ele = it.next();
			System.out.println(ele);
	}
		System.out.println("----------------------------------");
	}
}

提示

以上只是我自己的看法，如有相同纯属意外。如有错误，也请谅解，勿喷！如有收获或疑问，欢迎点赞评论！