目录

一.set简介

二.set集合的特点

1.Set不存储重复的元素

2.Set中的元素通常是无序的

三.set集合的遍历方式

1.foreach遍历

2.iterator迭代器遍历

四.HashSet哈希表存储，重复元素存储底层原理

五.LinkedHashSet保留元素插入顺序

六.TreeSet(自然排序，比较器排序)

1.默认排序：set集合中的默认的排序

2.自然排序：实现java.lang.Comparable接口

3.比较器排序：实现java.util.Comparator的匿名内部类

七.SortedSet 

1.first()和last()方法分别获取了集合中的最小值和最大值。

2.subSet()方法获取了子集合

3.tailSet()方法尾部子集合

---

一.set简介

在Java中，Set是一个接口，用于存储一组不重复的元素。Set接口继承自Collection接口，因此它具有Collection接口定义的所有方法，例如添加、删除和迭代等。

二.set集合的特点

1.Set不存储重复的元素

2.Set中的元素通常是无序的

package com.ctb.set;

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

/**
 * set集合的特点 
 * 1.无序-没有下标--所以无法修改 
 * 2.元素无重复
 * 
 * @author biao
 *
 */
public class Demo1 {
	public static void main(String[] args) {
		//定义set集合
		Set set=new HashSet<>();
		//增加
		set.add("ha");
		set.add("ds");
		set.add("dh");
		set.add("es");
		set.add("di");
		//删除
		set.remove("di");
System.out.println(set.size()); //输出：4
		//查询
		System.out.println(set);//输出[dh, ha, es, ds]
	}
}

三.set集合的遍历方式

1.foreach遍历

2.iterator迭代器遍历

package com.ctb.set;

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

/**
 * set集合的遍历方式
 * 1.foreach遍历
 * 2.iterator迭代器遍历
 * @author biao
 *
 */
public class Demo2 {
	public static void main(String[] args) {
		//定义set集合
				Set set=new HashSet<>();
				//增加
				set.add("花花");
				set.add("曹操");
				set.add("苹果");
				//foreach遍历
				for (Object object : set) {
					System.out.println(object);//输出：花花 苹果 曹操
				}
				System.out.println("------------------------------------");
				//iterator迭代器遍历
				Iterator it = set.iterator();
				while (it.hasNext()) {
					System.out.println(it.next());//输出：花花 苹果 曹操
				}
	}

}

四.HashSet哈希表存储，重复元素存储底层原理

Set集合中元素是不重复的，但在我们存储对象过程中，对象是可以重复添加的，那么，我们 需要重写存储对象中的hashcode方法和equals方法，它会在hashCode方法中进行筛选，再到equals方法进行判断

注：若只重写一个方法，则无法避免存储对象重复的添加

package com.ctb.set;

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

/**
 * set集合对象去重底层原理
 * 先进入hashcode方法进行筛选，后进入equlas方法判断
 * @author biao
 *
 */
public class Demo3 {
	public static void main(String[] args) {
		Set set = new HashSet<>();
		set.add(new Cat(1, "土猫"));
		set.add(new Cat(2, "哈士奇"));
		set.add(new Cat(3, "翔子猫"));
		set.add(new Cat(4, "毛猫"));
		// System.out.println(set.contains(new Cat(2, "哈士奇")));//false
		set.add(new Cat(2, "哈士奇"));
		for (Object object : set) {
			System.out.println(object); //输出结果：Cat [id=4, name=毛猫]
			                           // Cat [id=3, name=翔子猫]
			                          // Cat [id=1, name=土猫]
									 // Cat [id=2, name=哈士奇]
		}

	}
}

class Cat {
	private int id;
	private String name;

	public Cat() {
		// TODO Auto-generated constructor stub
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Cat [id=" + id + ", name=" + name + "]";
	}

	public Cat(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Cat other = (Cat) obj;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

五.LinkedHashSet保留元素插入顺序

LinkedHashSet是基于链表和哈希表的实现，它保留了元素插入的顺序，通过哈希表来实现元素的快速查找。

package com.ctb.set;

import java.util.LinkedHashSet;
import java.util.Set;
/**
 * LinkedHashSet
 * 元素插入排序
 * @author biao
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		Set set = new LinkedHashSet<>();
		set.add("花花");
		set.add("鸟鸟");
		set.add("猫猫");
		set.add("哈哈");
		for (Object object : set) {
			System.out.println(object);// 输出：花花 鸟鸟 猫猫 哈哈
		}
	}
}

六.TreeSet(自然排序，比较器排序)

1.默认排序：set集合中的默认的排序

2.自然排序：实现java.lang.Comparable接口

3.比较器排序：实现java.util.Comparator的匿名内部类

package com.ctb.set;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * set集合排序
 * @author biao
 *
 */
public class Demo4 {
	public static void main(String[] args) {
		Set set =new TreeSet<>();
		set.add(new Cart(1, "麻辣", 19));
		set.add(new Cart(2, "香甜", 32));
		set.add(new Cart(3, "可口", 23));
		set.add(new Cart(4, "酸辣", 45));
		set.add(new Cart(5, "苦逼", 23));
		set.add(new Cart(6, "咸蛋", 23));
		System.out.println("-------set集合默认排序---------");
		//默认排序
		for (Object object : set) {
			System.out.println(object);
		}
		
		//自然排序
		Set ts=new TreeSet<>();
		//添加数据
		for (Object object : set) {
			ts.add(object);
		}
		System.out.println("------java.lang.Comparable自然排序-------");
		for (Object object : ts) {
			System.out.println(object);
		}
		
		//比较排序--根据价格排序
		Set s=new TreeSet<>(new Comparator<Cart>() {
			@Override
			public int compare(Cart o1, Cart o2) {
				// TODO Auto-generated method stub
				return o2.getPrice()-o1.getPrice();
			}
		});
		//添加数据
		for (Object object : set) {
			s.add(object);
		}
		System.out.println("---------java.util.Comparator的匿名内部类-按价格排序--------");
		for (Object object : s) {
			System.out.println(object);
		}
		
		//比较排序--先根据价格排序--价格相同则按id排序
				Set ss=new TreeSet<>(new Comparator<Cart>() {
					@Override
					public int compare(Cart o1, Cart o2) {
						// TODO Auto-generated method stub
						int n=o2.getPrice()-o1.getPrice();
						if (n==0) {
							return o1.getId()-o2.getId();
						}
						return n;
					}
				});
				//添加数据
				for (Object object : set) {
					ss.add(object);
				}
				System.out.println("---------java.util.Comparator的匿名内部类-先价格，再id排序--------");
				for (Object object : ss) {
					System.out.println(object);
				}
	}

}
class Cart implements Comparable<Cart>{
	private int id;
	private String name;
	private int price;
	public Cart() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Cart [id=" + id + ", name=" + name + ", price=" + price + "]";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public Cart(int id, String name, int price) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + price;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Cart other = (Cart) obj;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (price != other.price)
			return false;
		return true;
	}
	@Override
	public int compareTo(Cart o) {
		return this.id-o.id;
	}

}

输出：

七.SortedSet 

1.first()和last()方法分别获取了集合中的最小值和最大值。

2.subSet()方法获取了子集合

subSet()方法的第一个参数inclusive，第二个参数exclusive，即包含起始元素但不包含结束元素

3.tailSet()方法尾部子集合

package com.ctb.set;

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
 * SortedSet
 * @author biao
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		SortedSet<Integer> set = new TreeSet<>();
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);

		System.out.println( set.first()); // 1
		System.out.println( set.last()); // 5

		SortedSet<Integer> subSet = set.subSet(2, 4);
		System.out.println(subSet); // [2, 3]

		SortedSet<Integer> tailSet = set.tailSet(3);
		System.out.println( tailSet); // [3, 4, 5]
	}
}

祝大家在梦想之路披荆斩棘！！