java详解 --- Set接口

set接口是继承于collection接口,是collection的一个分支.

一.hashSet

1.hashSet是可以用来去除集合中的重复的元素
代码举例:

HashSet<String> hashSet = new HashSet<>();
    hashSet.add("a");
    hashSet.add("a");
    hashSet.add("b");
    hashSet.add("b");
    hashSet.add("c");
    hashSet.add("c");
    hashSet.add("d");
    hashSet.add("d");
    // 使用增强for循环 遍历
    for(String string : hashSet){
        System.out.println(string);
    }
    System.out.println(hashSet);

结果为:

2.LinkedHashSet是hashSet的子类,特点是去重 有序排序,怎么存的怎么取出来
代码举例:

LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
    linkedHashSet.add("a");
    linkedHashSet.add("a");
    linkedHashSet.add("b");
    linkedHashSet.add("b");
    linkedHashSet.add("c");
    linkedHashSet.add("c");
    linkedHashSet.add("d");
    linkedHashSet.add("d");
    System.out.println(linkedHashSet);

输出结果:

3.问题举例:
①.需求:编写一个程序 获取10个1 - 20的随机数.要求不能重复

HashSet<Integer> hashSet = new HashSet<>();
// while写一个死循环
while(true){
    // 判断集合长度超过10,结束循环
    if(hashSet >= 10){
        break;
    }
    // 将随机数添加进hashset中
    int num = (int)(Math.random() * (20 + 1 - 1 ) + 1);
    hashSet.add(num);
}
System.out.println(hashSet);

输出结果:

②.输入一个字符串,去掉其中重复字符, 打印出不同的那些字符

// 接收字符串
System.out.println("请输入一个字符串:");
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
// 将字符串转化为字符数组
char[] array = string.toCharArray();
// 创建set集合
HashSet<Character> hashSet = new HashSet<>();
// 将字符数组放进set集合
for(int i = 0 ; i < array.length ; i++) {
    hashSet.add(array[i]);
}
System.out.println(hashSet);

输出结果:

③.利用set集合 去除ArrayList集合中的重复元素(操作原ArrayList集合)

ArrayList<String> arrayList = new ArrayList<>();
    arrayList.add("a");
    arrayList.add("a");
    arrayList.add("b");
    arrayList.add("b");
    arrayList.add("c");
    arrayList.add("c");
// 保持怎么存怎么取的原则 使用linkedHashSet
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
// 将arrayList中的元素添加到LinkedHashSet
linkedHashSet.addAll(arrayList);
// 清空arrayList集合
arrayList.clear();
// 将LinkedHashSet中的元素添加到arrayList
arrayList.addAll(linkedHashSet);
System.out.println(arrayList);

输出结果:

④.创建一个hashset 保存5个人 遍历
认为年龄和姓名一样就是同一个人 去除重复的
先创建一个人类:

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    // 构造方法
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // set/get方法
    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;
    }

    // toString方法的重写
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    // 生成哈希值
    // 重写hashcode方法
    // hashcode在存储对象时 按照哈希值去存储的
    // 注意 保存对象的时候,先看哈希值 
    // 哈希值一样 再看equals方法
    // 哈希值不一样 就不看equals
    @Override
    public int hashCode() {
        // this.name.hashcode + age
        // 写这么复杂 就是为了让hashcode减少重复
        // 少调用equals方法 提高存储效率
        final int prime = 31; 
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    // 重写equals方法
    @Override
    public boolean equals(Object obj) {
        // 防御式判断(健壮性判断)
        if (this == obj) // 两个对象地址一样
            return true; // 说明是一个对象
        if (obj == null) // 有一个对象时空的
            return false;// 两个对象肯定不一样
        // 判断两个对象是不是同一类创建出来的
        if (getClass() != obj.getClass()) 
            return false; // 认为不是一个对象
        Person other = (Person) obj; // 向下转型
        if (age != other.age) // 判断年龄 不同
            return false; //说明不是一个对象
        if (name == null) { // 判断名字是否为空
            if (other.name != null) // 名字一个为空一个不为空
                return false; // 说明不是一个对象
        } else if (!name.equals(other.name)) 
            return false; // 名字不同 则不是一个对象
        return true; // 前面都没走 直接到这里 就说明两个对象时同一个对象
    }   
}

HashSet<Person> hashSet = new HashSet<>();
hashSet.add(new Person("p1",19));
hashSet.add(new Person("p1",19));
hashSet.add(new Person("p2",21));
hashSet.add(new Person("p2",21));
hashSet.add(new Person("p3",22));
hashSet.add(new Person("p3",22));
for (Person person : hashSet) {
    System.out.println(person);
}
System.out.println(hashSet);

输出结果:

由此,可以看出:
你要是想使用hashSet去除重复的对象的时候
你需要重写其中的HashCode()和equals()方法

二.TreeSet

1.TreeSet可以用来排序时候默认升序排的,,但是只能排常量的值
代码举例:

TreeSet<Integer> set = new TreeSet<>();
    set.add(1);
    set.add(4);
    set.add(2);
    set.add(3);
    System.out.println(set);

输出结果:

2.创建一个treeset 添加4个人 查看是否排序

TreeSet<Person> set = new TreeSet<>();
set.add(new Person("p10",18));
set.add(new Person("p2222",19));
set.add(new Person("p3",20));
set.add(new Person("p422",21));
set.add(new Person("p3",19));
System.out.println(set);

输出结果:你会发现报错

需要在Person中重写compareTo方法

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    // 构造方法
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // set/get方法
    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;
    }

    // toString方法的重写
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    // 重写compareTo方法
    // 重写排序规则
    // 主要看字符串长度
    // 次要看姓名的比较
    // 再次要看年龄的比较
    // 如果都相同,就认定是同一个对象
    @Override
    public int compareTo(Person o) {
        int length = this.name.length() - o.getName().length();
        int num2 = this.name.compareTo(o.getName());
        int num3 = this.age - o.getAge();
        return length == 0 ? (num2 == 0 ? num3 : num2) : length;
    }

输出结果:

如果TreeSet想向里面存储元素
就看compareTo方法里的返回值到底是正数,0,还是负数:
返回0 –> 只有一个值
返回一个正数 –> 按存进去的顺序 输出
返回一个负数 –> 按存进去的顺序逆向 输出

3.比较器
需求:集合中保存字符串 按字符串长度排序

需要创建一个比较器用来试下你接口中的方法
比较器相当于TreeSet的存储规则

public class ComparatorImpl implements Comparator<String>{
    // 重写排序规则
    // 主要看字符串长度
    // 次要按照字符比
    @Override
    public static void compareTo(String o1,String o2){
        int length = o1.length() - o2.length();                     
        int num = o1.compareTo(o2);
        // 如果有两个字符串两个都相同 但也需要保留
        // 所以返回1 和 -1 都没区别 只要被返回 0 就行
        return length == 0 ? (num == 0 ? 1 : num) : length;
    }
}

// 初始化TreeSet的同时把比较器 传入TreeSet中
TreeSet<String> set = new TreeSet<>(new ComparatorImpl());
set.add("aa");
set.add("zz");
set.add("sb");
set.add("www");
set.add("lanou");
set.add("ly");
set.add("zz");
    for (String string : set) {
        System.out.print(string + " ");
    }

输出结果:

4.问题举例
①.在一个集合中存储了无序并且重复的字符串,排序,而且还不能去除重复(用比较器)

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("aa");
arrayList.add("zz");
arrayList.add("sb");
arrayList.add("www");
arrayList.add("lanou");
arrayList.add("ly");
arrayList.add("zz");

TreeSet<String> treeSet = new TreeSet<>(new ComparatorImpl());
// 把arrayList 整个塞进 treeSet里
treeSet.addAll(arrayList);
// 清空arrayList
arrayList.clear();
// 再把treeSet 整个怼进 arrayList里
arrayList.addAll(treeSet);
System.out.println(arrayList);

这里的比较器也可以用3中的比较器
输出结果:

②.键盘输入一个字符串,对其中所有字符进行排序.(不去重复的)

// 键盘接收字符串
System.out.println("请输入一个字符串:");
Scanner scanner = new Scanner(System.in);
// 接收字符串
String string = scanner.nextLine();
// 转成字符数组
char[] array = string.toCharArray();
// 创建TreeSet
TreeSet<Character> set = new TreeSet<>(new charImpl());
    // 把字符数组中的每一个元素 都放进set中
    for (int i = 0; i < array.length; i++) {
        set.add(array[i]);
    }
System.out.println(set);

这里需要写一个比较器:
直接比较两个字符的ASCII码值就好了

public class charImpl implements Comparator<Character> {
    // 重写排序的方法
    @Override
    public int compare(Character o1, Character o2) {
        int num = o1 - o2;
        return num == 0 ? 1 : num;
    }
}

输出结果: