Set集合接口规范概述
Set接口继承自——Collection——Iterable
Iterable接口循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iterator迭代器。它主要通过foreach方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历。
Set接口只能存储不相等的对象，Set接口是数学Set的抽象描述，与ArrayList不同，它其中的元素不带有任何索引，不能使用索引方式访问集合中元素。
Set接口通常追加，遍历元素比较慢，随机删除修改数据速度稍快。
Set集合接口常用方法
boolean add(Oject e) //在末尾添加元素
void clear() //清空集合
boolean contains(Object o) //是否包含对象
Iterator<E> iterator() //得到一个指向集合的迭代器
boolean remove(Object o) //移除给定的元素
int size() //返回集合的大小
boolean isEmpty() //判断集合是否为空
Object[] toArray() //把集合中的所有元素封装成一个Object数组返回
HashSet集合实现类
此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用null元素。
HashSet实现不是同步的。如果多个线程同时访问一个哈希set，而其中至少一个线程修改了该set，那么它必须保持外部同步。
不能存储同一对象，如果有后面的数据会覆盖原来的。
代码案例：
/**
* 商品信息实体类
*/
public class Goods {
private String number; //商品编号
private String name; //商品名称
private double price; //商品单价
private int quantity; //商品数量
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
}
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.UUID;
public class Demo01 {
public static void main(String[] args) {
Set goodsSet= new HashSet();
Goods goods=new Goods();
goods.setName("肥皂");
goods.setNumber(UUID.randomUUID().toString());
goods.setQuantity(100);
Goods goods2=new Goods();
goods2.setName("运动鞋");
goods2.setNumber(UUID.randomUUID().toString());
goods2.setQuantity(200);
goodsSet.add(goods);
goodsSet.add(goods2);
Iterator iterable= goodsSet.iterator();
while (iterable.hasNext()){
Object obj=iterable.next();
Goods good=(Goods)obj;
System.out.println(good.getName()+"\t"+good.getNumber()+"\t"+good.getQuantity());
}
//将Set集合中的所有元素封装为Object数组返回
Object[] objs=goodsSet.toArray();
for(int i=0;i<objs.length;i++){
System.out.println(((Goods)objs[i]).getName()+"\t"+((Goods)objs[i]).getNumber());
}
} }
TreeSet集合实现类
基于TreeMap的NavigableSet继承并实现了SortedSet排序接口。使用元素的自然顺序对元素进行排序，或者根据创建set时提供的Comparator进行排序。
此实现不是同步的。如果多个线程同时访问一个TreeSet，而其中至少一个线程修改了该set，那么它必须外部同步。
由于排序，通常此类比HashSet效率要低。
TreeSet集合常用方法
public TreeSet(Comparator<E> comparator) //按照comparator里面的排序方式进行排序，这个就是自定义排序方法
- public Iterator<E> descendinglterator() //降序排序迭代器
- public E last() //获取最后一个元素
- public E first() //获取第一个元素 TreeSet treeSet=new TreeSet(); //创建一个采用默认树形自然排序的
TreeSet集合对象
treeSet.add(new Integer(50));
treeSet.add(new Integer(10));
treeSet.add(new Integer(150));
treeSet.add(new Integer(13));
treeSet.add(new Integer(75));
treeSet.add(new Integer(88));
for (Object o:treeSet) {
System.out.print(o+" ");
}
//获取当前TreeSet集合的倒序排序迭代器
Iterator iterator=treeSet.descendingIterator();
while (iterator.hasNext()){
System.out.print((Integer) iterator.next()+" ");
}
运行结果：10 13 50 75 88 150
运行结果：150 88 75 50 13 10
自定义排序
/**
* 商品信息实体类 （这里是一个商品实体类我们会根据商品的价格自定义排序）
*/
public class Goods {
private String number; //商品编号
private String name; //商品名称
private double price; //商品单价
private int quantity; //商品数量
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
}
import java.util.Comparator;
/**
*这里是重写Comparator方法我们用GoodsSorted继承它的方法，这里有两个变量进行比较，强转为商品类后，调用商品类的价格进行比较
*大的或返回1，小于为-1，相等为0这是正常排序
*如果大的值返回-1，小的值返回1,这是倒序
*/
public class GoodsSorted implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Goods g1 = (Goods) o1;
Goods g2 = (Goods) o2;
if(g1.getPrice()>g2.getPrice()){
return 1;
}else if(g1.getPrice()<g2.getPrice())
return -1;
return 0;
}
}
/**
*这里测试类，在TreeSet的构造器里调用GoodsSorted()里的重写方法，编写了几个案例，由于正序排列
*/
public class Demo03 {
public static void main(String[] args) {
TreeSet treeSet=new TreeSet(new GoodsSorted());
Goods g0=new Goods();
g0.setName("足球");
g0.setPrice(230.50);
Goods g2=new Goods();
g2.setName("皮肤");
g2.setPrice(168);
Goods g3=new Goods();
g3.setName("乒乓球");
g3.setPrice(2.0);
Goods g4=new Goods();
g4.setName("篮球");
g4.setPrice(150.4);
treeSet.add(g0);
treeSet.add(g2);
treeSet.add(g3);
treeSet.add(g4);
for (Object o:treeSet) {
System.out.println(((Goods)o).getName()+"\t"+((Goods)o).getPrice());
}
}
}
运行结果：乒乓球 2.0
篮球 150.4
皮肤 168.0
足球 230.5
LinkedHashSet集合实现类
基于哈希表和链接列表的Set接口的实现类，与HashSet无序集合相比，LinkedHashSet的迭代是一个可以被预知的访问操作，它以添加到集合中的顺序为迭代最终顺序。
由于LinkedHashSet需要维护元素顺序，因此其效率比HashSet要稍低些。
通常在需要保证使用Set接口并安装存储顺序迭代时使用此类。
LinkedHashSet综合案例
/**
* 省份实例类
*/
public class Province {
private String name; //省份名称
private long area; //土地面积
private boolean general; //是普通省还是直辖市（true 普通省 false 直辖市）
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getArea() {
return area;
}
public void setArea(long area) {
this.area = area;
}
public boolean isGeneral() {
return general;
}
public void setGeneral(boolean general) {
this.general = general;
}
}
import java.util.LinkedHashSet;
/**
*功能模块实现
*/
public class ProvinceManager {
private LinkedHashSet proviceSet;
public LinkedHashSet getProviceSet(){
return proviceSet;
}
/**
* 添加省份到Set集合中
*/
public void addProvince(Province pro){
proviceSet.add(pro);
}
/**
* 根据给定的省份名称显示省份信息
*/
public Province findProviceByName(String name){
for (Object o:proviceSet){
if(((Province)o).getName().equals(name)){
return ((Province)o); //返回查找到的对象
}
}
return null;
}
/**
* 显示所有省份信息
*/
public void showProvice(){
for (Object o:proviceSet){
System.out.println(((Province)o).getName()+"\t"+((Province)o).getArea()+"\t\t"+((Province)o).isGeneral());
}
}
public ProvinceManager(){
if(proviceSet==null)
proviceSet=new LinkedHashSet();
}
}
import com.Set.dao.ProvinceManager;
import com.Set.entity.Province;
import java.util.Scanner;
public class TestLinkedHashSet {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
ProvinceManager province=new ProvinceManager();
System.out.println("请输入3个省份信息：");
Province pro=null;
for (int i=0;i<3;i++){
pro=new Province();
System.out.println("请输入第"+(i+1)+"个省份名称");
pro.setName(scanner.next());
System.out.println("请输入第"+(i+1)+"个省份土地面积");
pro.setArea(scanner.nextLong());
System.out.println("请输入第"+(i+1)+"个省份属性"); //0普通省，1直辖市
int tag=scanner.nextInt();
if(tag==0)
pro.setGeneral(true);
else
pro.setGeneral(false);
province.addProvince(pro);
}
System.out.println("显示所有的城市信息：");
province.showProvice();
System.out.println("请输入查找的省份姓名：");
String proName=scanner.next();
Province pros=province.findProviceByName(proName);
System.out.println("省份名称"+pros.getName()+"\t"+"省份土地面积"+pros.getArea()+"\t"+"省份是"+pros.isGeneral());
}
}