java学习总结：Set集合

1，用HashSet存储字符串并遍历

package com.heima.set;

import java.util.HashSet;

public class Demo_1Hashset {
	/*
	 * set集合，无索引，不可以重复，无序（存取不一致）
	 */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet<String> hs = new HashSet<>();		//创建HashSet对象
		boolean b1 = hs.add("a");
		boolean b2 = hs.add("a");		//当向set集合中存储重复元素的时候返回false
		hs.add("b");
		hs.add("c");
		hs.add("d");
		System.out.println(hs);			//HashSet的继承体系中有重写toString方法
		System.out.println(b1);
		System.out.println(b2);
		
		for (String string : hs) {		//只要能用迭代器迭代的，就可以使用增强for循环遍历
			System.out.println(string);
		}
	}

}

底层代码

public boolean equals(Object obj) {
		if (this == obj)						//调用的对象和传入的对象是同一个对象
			return true;						//直接返回true
		if (obj == null)						//传入的对象为null
			return false;						//返回false
		if (getClass() != obj.getClass())		//判断两个对象对应的字节码文件是否是同一个字节码
			return false;						//如果不是直接返回false
		Person other = (Person) obj;			//向下转型
		if (age != other.age)					//调用对象的年龄不等于传入对象的年龄
			return false;						//返回false
		if (name == null) {						//调用对象的姓名为null
			if (other.name != null)				//传入的对象姓名不等于null
				return false;					//返回false
		} else if (!name.equals(other.name))	//调用对象的姓名不等于传入对象的姓名
			return false;						//返回false
		return true;							//返回true

2，LinkedHashSet的概述

LinkedHashSet

• 底层是链表实现的，是set集合中唯一一个能保证怎么存就怎么取的集合对象
• 因为是HashSet的子类，所以也是保证元素唯一的，于HashSet的原理一样

产生1到20 间的随机数并且不能重复（代码演示）

package com.heima.set;

import java.util.HashSet;
import java.util.Random;

public class Demo2 {
/*
 * 获取10个1至20 的随机数，要求随机数不能重复，并输出
 * 分析：
 * 1.有random类创建随机数对象
 * 2.需要存储10个随机数，而且不能重复，所以我们用hashset集合
 * 3.如果HashSet的size是小于10就可以不断存储，如果大于10就停止存储
 * 4.通过random类中的nextInt（n）方法获取1到20 之间的随机数，并将这些随机数存储在HashSet集合中
 * 5.遍历HashSet
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.有random类创建随机数对象
		Random r = new Random();
		//2.需要存储10个随机数，而且不能重复，所以我们用HashSet集合
		HashSet<Integer> hs = new HashSet<Integer>();
		// 3.如果HashSet的size是小于10就可以不断存储，如果大于10就停止存储
		while(hs.size() < 10) {
		//4.通过random类中的nextInt（n）方法获取1到20 之间的随机数，并将这些随机数存储在HashSet集合中
			hs.add(r.nextInt(20) + 1);
		}
		// 5.遍历HashSet
		for (Integer integer : hs) {
			System.out.println(integer);
		}
	}

}

3，练习（在一个集合中存储无序并且重复的字符串，定义一个方法，让其有序（字典顺序）而且不能去重复）

package com.heima.set;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class Demo3 {
/*
 * 在一个集合中存储无序并且重复的字符串，定义一个方法，让其有序（字典顺序）而且不能去重复
 * 
 * 分析：
 * 1.定义一个list集合，并存储重复的无序的字符串
 * 2.定义方法对其排序保留重复
 * 3.打印list集合
 */
	public static void main(String[] args) {
		//1.定义一个list集合，并存储重复的无序的字符串
		ArrayList<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("aaa");
		list.add("ccc");
		list.add("ddd");
		list.add("afffffffff");
		list.add("adr");
		list.add("sdafsdf");
		list.add("bbbbbb");
		list.add("ewstw");
		
		//2.定义方法对其排序保留重复
		sort(list);
		
		//3.打印list集合
		System.out.println(list);
	}
/*
 * 定义方法，排序并保留重复
 * 分析：
 * 1.创建Treeset集合对象，因为本身就具备比较功能，但是重复的不会保留，所以我们用比较器
 * 2.将list集合中所有的元素添加到TreeSet集合中，对其排序，保留重复
 * 3.清空list集合
 * 4.将TreeSet集合中排好序的元素添加到list中
 */
private static void sort(ArrayList<String> list) {
	// TODO Auto-generated method stub
	//1.创建Treset集合对象，因为本身就具备比较功能，但是重复的不会保留，所以我们用比较器
	TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {

		@Override
		public int compare(String o1, String o2) {
			// TODO Auto-generated method stub
			int num = o1.compareTo(o2);		//比较内容为主要条件
			return num == 0 ? 1 : num;		//保留重复
		}
		
	});
	//2.将list集合中所有的元素添加到TreeSet集合中，对其排序，保留重复
	ts.addAll(list);
	//3.清空list集合
	list.clear();
	//4.将TreeSet集合中排好序的元素添加到list中
	list.addAll(ts);
	
}

}

其中

new Comparator<String>() {

		@Override
		public int compare(String o1, String o2) {
			// TODO Auto-generated method stub
			int num = o1.compareTo(o2);		//比较内容为主要条件
			return num == 0 ? 1 : num;		//保留重复
		}
		
	});           // 采用匿名内部类