java Set集合总结

不仅要会使用集合的方法,还要对它们底层的数据结构实现原理有一定的了解。

Set集合,无索引,不可以重复,无序(存取不一致)

这里主要总结HashSet,LinkedHashSet,TreeSet

HashSet:

只有重写hashCode方法(此方法不能固定,应尽量减少重复值,相同对象hashCode值相同,再调用equals方法比较属性值),才能保证HashSet集合里面对象的唯一性

import java.util.HashSet;

public class Test {

	/**
	 * @param args
	 * Set集合,无索引,不可以重复,无序(存取不一致)
	 */
	public static void main(String[] args) {
		//demo1();
		HashSet<Person> hs = new HashSet<Person>();
		hs.add(new Person("张三", 23));
		hs.add(new Person("张三", 23));
		hs.add(new Person("李四", 24));
		hs.add(new Person("李四", 24));
		hs.add(new Person("李四", 24));
		hs.add(new Person("李四", 24));
		
		//System.out.println(hs.size());
		System.out.println(hs);
	}

	public static void demo1() {
		HashSet<String> hs = new HashSet<String>();					//创建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);
		}
	}

}

class Person implements Comparable<Person> {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	/*@Override
	public boolean equals(Object obj) {
		System.out.println("执行了吗");
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	@Override
	public int hashCode() {
		final int NUM = 38;
		return name.hashCode() * NUM + age;
	}*/
	
	/*
	 * 为什么是31?
	 * 1,31是一个质数,质数是能被1和自己本身整除的数
	 * 2,31这个数既不大也不小
	 * 3,31这个数好算,2的五次方-1,2向左移动5位
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	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
	}
	/*@Override
	//按照年龄排序
	public int compareTo(Person o) {
		int num = this.age - o.age;				//年龄是比较的主要条件
		return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
	}*/
	/*@Override
	//按照姓名排序
	public int compareTo(Person o) {
		int num = this.name.compareTo(o.name);		//姓名是主要条件
		return num == 0 ? this.age - o.age : num;	//年龄是次要条件
	}*/
	/*
	 * aaa
	 * bbb
	 */
	public int compareTo(Person o) {
		int length = this.name.length() - o.name.length();				//比较长度为主要条件
		int num = length == 0 ? this.name.compareTo(o.name) : length;	//比较内容为次要条件
		return num == 0 ? this.age - o.age : num;						//比较年龄为次要条件
	}
	
}

输出:

[Person [name=张三, age=23], Person [name=李四, age=24]]

LinkedHashSet:

继承自HashSet,保证元素唯一性,底层由链表实现,是Set集合中唯一可以保证怎么存就怎么取的集合对象,元素增删快,查找慢.

举个随机数的例子:用LinkedHashSet也行,不过是随机的,没必要保持产生的随机数的顺序.

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

public class Test {

	/**
	
	 * 获取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) {
		//1,有Random类创建随机数对象
		Random r = new Random();
		//2,需要存储10个随机数,而且不能重复,所以我们用HashSet集合
		HashSet<Integer> hs = new HashSet<>();
		//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);
		}
		
	}

}

字符串去重:

import java.util.LinkedHashSet;
import java.util.Scanner;

public class Test {

	/**
	 * * 使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
	 * 1,创建Scanner对象
	 * 2,创建LinkedHashSet对象,将字符存储,去掉重复
	 * 3,将字符串转换为字符数组,获取每一个字符存储在LinkedHashSet集合中,自动去除重复
	 * 4,遍历LinkedHashSet,打印每一个字符
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//2,创建LinkedHashSet对象,将字符存储,去掉重复
		LinkedHashSet<Character> hs = new LinkedHashSet<>();
		//3,将字符串转换为字符数组,获取每一个字符存储在LinkedHashSet集合中,自动去除重复
		String line = sc.nextLine();
		char[] arr = line.toCharArray();
		
		for (char c : arr) {							//遍历字符数组
			hs.add(c);
		}
		
		//4,遍历LinkedHashSet,打印每一个字符
		
		for(Character ch : hs) {
			System.out.print(ch);
		}
	}

}

输入:

qweqwe

输出:

qwe

 

TreeSet:底层是由二叉树实现的,是用来给里面的元素排序的,同样可以保证元素的唯一性.

注意代码中排序的实现(要自己根据实际情况实现Comparable接口,并重写compareTo方法),详情见代码注释

自然排序:要自己根据实际情况实现Comparable接口,并重写compareTo方法,根据compareTo()方法的返回结果进行存储。排序输出。

比较器排序(优先):实例化TreeSet集合时要传入Comparator的子类对象,add()方法内部会自动调用Comparator接口中的Compare()方法排序

 

比较器排序的原理:

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

public class Test {

	/**
	 * @param args
	 * TreeSet集合是用来对象元素进行排序的,同样他也可以保证元素的唯一
	 * 当compareTo方法返回0的时候集合中只有一个元素
	 * 当compareTo方法返回正数的时候集合会怎么存就怎么取
	 * 当compareTo方法返回负数的时候集合会倒序存储
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		//需求:将字符串按照长度排序
		TreeSet<String> ts = new TreeSet<>(new CompareByLen());		//Comparator c = new CompareByLen();
		ts.add("aaaaaaaa");
		ts.add("z");
		ts.add("wc");
		ts.add("nba");
		ts.add("cba");
		
		System.out.println(ts);
	}

	public static void demo4() {
		TreeSet<Person> ts = new TreeSet<>();
		ts.add(new Person("zhangsan", 23));
		ts.add(new Person("lisi", 13));
		ts.add(new Person("wangwu", 33));
		ts.add(new Person("zhaoliu", 43));
		ts.add(new Person("aaaa", 53));
		
		System.out.println(ts);
	}

	public static void demo3() {
		TreeSet<Person> ts = new TreeSet<>();
		ts.add(new Person("李四", 13));
		ts.add(new Person("张三", 23));
		ts.add(new Person("王五", 43));
		ts.add(new Person("赵六", 33));
		
		System.out.println('张' + 0);
		System.out.println('李' + 0);
		System.out.println('王' + 0);
		System.out.println('赵' + 0);
		
		System.out.println(ts);
	}

	public static void demo2() {
		TreeSet<Person> ts = new TreeSet<>();
		ts.add(new Person("张三", 23));
		ts.add(new Person("李四", 13));
		ts.add(new Person("周七", 13));
		ts.add(new Person("王五", 43));
		ts.add(new Person("赵六", 33));
		
		System.out.println(ts);
	}

	public static void demo1() {
		TreeSet<Integer> ts = new TreeSet<>();
		ts.add(3);
		ts.add(1);
		ts.add(1);
		ts.add(2);
		ts.add(2);
		ts.add(3);
		ts.add(3);
		
		System.out.println(ts);
	}

}


class CompareByLen /*extends Object*/ implements Comparator<String> {

	@Override
	public int compare(String s1, String s2) {		//按照字符串的长度比较
		int num = s1.length() - s2.length();		//长度为主要条件
		return num == 0 ? s1.compareTo(s2) : num;	//内容为次要条件
	}
	
}

class Person implements Comparable<Person> {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	/*@Override
	public boolean equals(Object obj) {
		System.out.println("执行了吗");
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	@Override
	public int hashCode() {
		final int NUM = 38;
		return name.hashCode() * NUM + age;
	}*/
	
	/*
	 * 为什么是31?
	 * 1,31是一个质数,质数是能被1和自己本身整除的数
	 * 2,31这个数既不大也不小
	 * 3,31这个数好算,2的五次方-1,2向左移动5位
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	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
	}
	/*@Override
	//按照年龄排序
	public int compareTo(Person o) {
		int num = this.age - o.age;				//年龄是比较的主要条件
		return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
	}*/
	/*@Override
	//按照姓名排序
	public int compareTo(Person o) {
		int num = this.name.compareTo(o.name);		//姓名是主要条件
		return num == 0 ? this.age - o.age : num;	//年龄是次要条件
	}*/
	/*
	 * aaa
	 * bbb
	 */
	public int compareTo(Person o) {
		int length = this.name.length() - o.name.length();				//比较长度为主要条件
		int num = length == 0 ? this.name.compareTo(o.name) : length;	//比较内容为次要条件
		return num == 0 ? this.age - o.age : num;						//比较年龄为次要条件
	}
	
}

输出:

[z, wc, cba, nba, aaaaaaaa]

实例1：

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

public class Test {

	/**
	 * 在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复
	 * 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("fff");
		list.add("eee");
		list.add("ggg");
		list.add("bbb");
		list.add("aaa");
		list.add("aaa");
		
		//2,定义方法对其排序保留重复
		sort(list);
		
		//3,打印list
		System.out.println(list);
	}
	
	/*
	 * 定义方法,排序并保留重复
	 * 分析:
	 * 1,创建TreeSet集合对象,因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器
	 * 2,将list集合中所有的元素添加到TrreSet集合中,对其排序,保留重复
	 * 3,清空list集合
	 * 4,将TreeSet集合中排好序的元素添加到list中
	 */
	public static void sort(List<String> list) {
		//1,创建TreeSet集合对象,因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器
		//这里用到了匿名内部类
		TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {

			@Override
			public int compare(String s1, String s2) {
				int num = s1.compareTo(s2);					//比较内容为主要条件
				return num == 0 ? 1 : num;					//保留重复，返回0代表不能存进去，所以改为1这个正整数
			}
		});
		//2,将list集合中所有的元素添加到TrreSet集合中,对其排序,保留重复
		ts.addAll(list);
		//3,清空list集合
		list.clear();
		//4,将TreeSet集合中排好序的元素添加到list中
		list.addAll(ts);
	}

}

输出:

[aaa, aaa, aaa, aaa, bbb, ccc, ddd, eee, fff, ggg]