Java的Set类 Li.038

Set

• 无序
• 不可重复

import java.util.HashSet;

public class Demo1_HashSet {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();

        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");
        System.out.println(hs);
        System.out.println(b1+"  "+b2);
        for(String s:hs){
            System.out.println(s);
        }
    }
}

HashSet 的重写hashCode() 方法, hashCode值一致时, 调用equals方法

• 使用HashSet 存取元素时, 这个元素必须重写 hashCode 和 equals方法

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

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

    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int age;


    @Override
    public String toString(){
        return "Person" + this.getName() + this.getAge();
    }

    @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        return this.getName() == p.getName() && this.getAge() == p.getAge();
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public static int hashCode(Object a[]) {
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

LinkedHashSet

• 底层链表实现的
• 是Set对象中唯一一个保证怎么存就怎么取的集合对象
• HashSet的子类, 也是保证元素是唯一的

import java.util.LinkedHashSet;

public class Demo1_LinkedHashSet {
    public static void main(String[] args) {
        LinkedHashSet <String> linkedHashSet = new LinkedHashSet<>();

        linkedHashSet.add("a");
        linkedHashSet.add("a");
        linkedHashSet.add("b");
        linkedHashSet.add("b");
        linkedHashSet.add("b");
        linkedHashSet.add("c");

        System.out.println(linkedHashSet);
    }
}

HashSet 练习, 放入集合10个[1,20]的整数

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

public class Demo1_Test {
    public static void main(String[] args) {
        Random r = new Random();
        HashSet <Integer> hashSet = new HashSet<>();

        while(hashSet.size() < 10 ){
            Integer i = r.nextInt(20) + 1;
            hashSet.add(i);
        }
        System.out.println(hashSet);
    }
}

HashSet 练习, 输入一串字符串, 去掉重复字符

import java.util.HashSet;
import java.util.Scanner;

public class Demo2_Test {
    public static void main(String[] args) {
        HashSet<Character> hs = new HashSet<>();
        Scanner sc = new Scanner(System.in);
        String s = null;
        if(sc.hasNext()){
            s = sc.nextLine();
        }
        char[] charArray= s.toCharArray();

//        for(Character c:charArray){
        for(char c:charArray){
            hs.add(c);
        }
        System.out.println(hs);
    }
}

HashSet 练习, list 去重, 并返回元素list

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;

public class Demo3_Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");

        HashSet <String> hs = new LinkedHashSet<>();
//        deleteCopyElement(list, hs);
        deleteCopyE(list);
//        System.out.println(hs);
        System.out.println(list);
    }
    public static void deleteCopyElement(List<String> list, HashSet<String> hashSet){
        hashSet.addAll(list);
        list.clear();
        list.addAll(hashSet);
    }
    public static void deleteCopyE(List<String> list){
        LinkedHashSet<String> hs = new LinkedHashSet<>();
        hs.addAll(list);
        list.clear();
        list.addAll(hs);
    }
}

TreeSet 集合, 对集合进行排序的, 元素唯一

• 保证元素唯一
• 集合排序

import java.util.TreeSet;

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet <Integer> ts = new TreeSet<>();

        ts.add(1);
        ts.add(1);
        ts.add(2);
        ts.add(2);
        ts.add(3);
        ts.add(3);
        System.out.println(ts);
    }
}

TreeSet , 类实现Comparable接口

• compareTo 方法返回0, 则集合中只用一个元素
• compareTo 方法返回正数, 集合怎么存怎么取
• compareTo 方法返回负数, 集合倒序存储

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

public class Person implements Comparable <Person>{
    public Person(){}
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int age;


    @Override
    public String toString(){
        return "Person" + this.getName() + this.getAge();
    }



    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Person)) {
            return false;
        }
        Person person = (Person) o;
        return getAge() == person.getAge() && Objects.equals(getName(), person.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(Person p) {
        int num = this.age - p.age;
        return num == 0 ? this.name.compareTo(p.name) : num;
    }
}

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("小明", 20));
        ts.add(new Person("小红", 19));
        ts.add(new Person("小张", 21));
        ts.add(new Person("小张", 21));

        System.out.println(ts);
    }
}

TreeSet 如果使用Person 的name排序, 则需要实现Compareable 接口, compareTo方法

@Override
public int compareTo(Person p) {
    int num = this.name.compareTo(p.name);
    return num == 0 ? this.age-p.age : num;
}

public class Demo1_TreeSet {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<>();
        ts.add(new Person("a", 20));
        ts.add(new Person("a", 19));
        ts.add(new Person("ab", 19));
        ts.add(new Person("ba", 21));
        ts.add(new Person("ca", 21));

        System.out.println(ts);
    }
}

TreeSet 使用Person 的name长度比较

@Override
public int compareTo(Person p){
    int length = this.name.length()- p.name.length();
    int num = length == 0 ? this.name.compareTo(p.name) : length;
    return num == 0 ? this.age - p.age : num;
}

TreeSet 实现Comparator接口, 在创建TreeSet时调用

• 自动定义String 长度作为比较

class Compare implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        int length = o1.length() - o2.length();
        int num =  length == 0 ? o1.compareTo(o2) : length;
        return num;
    }
}

public class Demo4_TreeSet {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Compare());
        ts.add("asdfsdf");
        ts.add("z");
        System.out.println(ts);
    }

}

练习, ArrayList 重复无序的数据, 如何按字典排序, 且不可去除重复数据

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

public class Demo5_TreeSet {
    public static void main(String[] args) {
        ArrayList<String> aList = new ArrayList<>();
        aList.add("aaa");
        aList.add("aaa");
        aList.add("aaa");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("bbb");
        aList.add("aaa");
        aList.add("aaa");
        aList.add("zzz");
        aList.add("zzz");
        aList.add("zzz");
        sortArrayList(aList);
        System.out.println(aList);

    }
    public static void sortArrayList(ArrayList<String> list){
       // 实际Comparator
       // list添加到tree(new comparator)中
       // 清空list
       // list.addAll(TreeSet)
        TreeSet<String> ts = new TreeSet<>(new StrComparator());
        ts.addAll(list);
        list.clear();
        list.addAll(ts);
    }
}
class StrComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        int num = o1.compareTo(o2);
        if(0 == num){
            num ++;
        }
        return num;
    }
}

练习, 输入字符hello 输出ehllo

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

public class Demo6_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = null;
        if(sc.hasNext()){
            s = sc.nextLine();
        }
        char[] chaArray = s.toCharArray();
//        Arrays.sort(chaArray);
//        System.out.println(chaArray);
        TreeSet<Character> ts = new TreeSet<>(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                int num = o1.compareTo(o2);
                return num == 0? 1 :num;
            }
        });
        for(Character c:chaArray){
            ts.add(c);
        }
        for(Character c:ts){
            System.out.print(c);
        }
    }
}

练习, 输入数字并倒序

• 输入quit 退出

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

public class Demo7_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                int num = o2.compareTo(o1);
                return num == 0 ? 1 :num ;
            }
        });
        while (sc.hasNext()){
            String s = sc.next();
            if( "quit".equals(s)){
                break;
            } else{
                ts.add(Integer.parseInt(s));
            }
        }
        for(Integer i:ts){
            System.out.print(i+" ");
        }
    }
}

练习

• 录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩) 按总成绩从高到低输入到控制台

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@AllArgsConstructor
@NoArgsConstructor
public class Student implements Comparable<Student>{
    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private int motherTongue;
    @Getter
    @Setter
    private int math;
    @Getter
    @Setter
    private int english;

    @Override
    public int compareTo(Student o) {
        int num =  (o.motherTongue + o.math + o.english) - (this.motherTongue + this.math + this.english);
        int num2 = num == 0 ? o.motherTongue - this.motherTongue : num;
        int num3 = num2 == 0 ? o.math - this.math : num2;
        int num4 = num3 == 0 ? o.english - this.english : num3;
        int num5 = num4 == 0 ? o.name.compareTo(this.name) : num4 ;
        if (0 == num5){
            num5 = -1;
        }
        return num5;
    }

    @Override
    public String toString() {
        return "Student."+this.name +".语文"+this.motherTongue+".数学"+this.math+".英语" + this.english;

    }
}

import com.lizicai.bean.Student;

import java.util.Scanner;
import java.util.TreeSet;

public class Demo8_TreeSet {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        TreeSet<Student> ts = new TreeSet<>();
        for(int i=0; i<5;i++){
            String str = null;
            if(sc.hasNext()){
                str = sc.nextLine();
            }
            String[] strArray = str.split(",");
            ts.add(new Student(strArray[0],
                    Integer.parseInt(strArray[1]),
                    Integer.parseInt(strArray[2]),
                    Integer.parseInt(strArray[3])));
        }
        System.out.println(ts);
    }
}