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里面的排序方式进行排序，这个就是自定义排序方法

1. public Iterator<E> descendinglterator() //降序排序迭代器
2. public E last()   //获取最后一个元素
3. 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());
    }
}