java集合之set

public class Demo1_Set {

    /*
     * set集合无序、不可重复、无索引
     */
    public static void main(String[] args) {

        //demo1();
        HashSet<Student> hs = new HashSet<>();
        hs.add(new Student("張三",19));
        hs.add(new Student("張三",19));
        hs.add(new Student("李四",20));
        hs.add(new Student("李四",20));
        hs.add(new Student("李四",20));
        System.out.println(hs);
        /*
          注意：  向集合中添加自定义类对象时，要想不添加重复的数据（如：同姓名、同年龄认为是同一个人），需要在自定义类中重写equals和hashCode方法
         执行结果如下：
         -----------------------        
                  執行了嗎
            執行了嗎
            執行了嗎
            執行了嗎
            [Student [name=李四, age=20], Student [name=張三, age=19]]
         --------------------------------
            @Override
            public boolean equals(Object arg0) {
                System.out.println("執行了嗎");
                Student s = (Student) arg0;
                return this.name.equals(s.name) && this.age == s.age;
            }
            
            @Override
            public int hashCode() {
                return 1;
            }
         */
    }

    public static void demo1() {
        HashSet<String> hs = new HashSet<>();
        boolean b1 = hs.add("a");
        boolean b2 = hs.add("a");
        boolean b3 = hs.add("c");
        boolean b4 = hs.add("d");
        boolean b5 = hs.add("e");
        boolean b6 = hs.add("f");
        
        System.out.println(b1);   // true
        System.out.println(b2);   //false
        System.out.println(hs);   //[f, d, e, c, a]
        for (String string : hs) {
            System.out.print(string);  //fdeca  Set集合类有实现toString的方法，所以打印对象时是打印的值
        }
    }

}

--------------------------------------------------------------------------------

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    /*
     * @Override public boolean equals(Object arg0) { System.out.println("執行了嗎");
     * Student s = (Student) arg0; return this.name.equals(s.name) && this.age ==
     * s.age; }
     * 
     * 
     * @Override public int hashCode() { return 1; }
     */

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

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        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;
        Student other = (Student) 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;
    }

    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;
    }

    /*
     * 优先比较姓名的长度，其次比较姓名的内容，再比较年龄
     */
    @Override
    public int compareTo(Student arg0) {
        int length = this.name.length() - arg0.name.length();
        int num = length == 0 ? this.name.compareTo(arg0.name) : length;
        return num == 0 ? this.age - arg0.age : num;
    }

    /*
     * 优先按照姓名排序，之后再按照年龄排序
     * 
     * @Override public int compareTo(Student arg0) { int num =
     * this.name.compareTo(arg0.name); return num == 0 ? this.age - arg0.age : num;
     * }
     */

    /*
     * 优先按照年龄排序，之后再按照姓名排序
     * 
     * @Override public int compareTo(Student arg0) { int num = this.age - arg0.age;
     * return num == 0 ? this.name.compareTo(arg0.name) : num; }
     */

}

------------------------------------------------------------------------

public class Demo2_Quchong {

    /*
     * 需求：将一个集合中的重复元素去除掉
     * 分析：
     *         1.获取一个拥有重复元素的list集合
     *         2.将list集合中的元素添加到set集合中
     *         3.将list集合中的元素清除
     *         4.将获取到的set集合添加到清空了的list集合中
     * 
     * LinkedHashSet 集合怎么存进去的就怎么取出来
     * TreeSet 集合是可以对存进去的集合进行排序，同样也可以保证集合中元素的唯一行
     */
    public static void main(String[] args) {
         //*         1.获取一个拥有重复元素的list集合
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");
        list.add("c");
        
        //通过方法去除重复元素
        getSingle(list);
        
        //打印list集合
        System.out.println(list);
         
    }

    public static void getSingle(List<String> list) {
        
        //2.将list集合中的元素添加到set集合中
        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        lhs.addAll(list);
        
         //3.将list集合中的元素清除
        list.clear();
        
         //4.将获取到的set集合添加到清空了的list集合中
        list.addAll(lhs);
    }

}

------------------------------------------------------------------

public class Demo3_Quchong {

    /*
     * 需求：通过键盘输入一串字符，然后去除重复，输出不同的字符
     * 分析：
     *   1.提示输入一串字符
     *   2.将这一串字符转换成字符数组
     *   3.将字符数组存入set集合
     *   4.打印最终的结果
     */
    public static void main(String[] args) {
        //1.提示输入一串字符
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串字符：");
        
        //2.将这一串字符转换成字符数组
        String line = sc.nextLine();
        char[] ch = line.toCharArray();
        
        //3.将字符数组存入set集合
        HashSet<Character> hs = new HashSet<>();
        for (Character character : ch) {
            hs.add(character);
        }
        
        //4.打印最终的结果
        System.out.println(hs);

    }

}

-------------------------------------------------------------------

public class Demo4_TreeSet {

    /*
     * TreeSet 集合自动对集合进行排序，同样也能满足集合中元素的唯一性
     * 
     * 当自定义对象没有实现Comparable方法的时候，新增对象的时候会报类型转换异常
     * 当compareTo方法返回值为 0 的时候，集合中只会有一个元素被存进去
     * 当compareTo方法返回值为正数的时候，怎么存就怎么取
     * 当compareTo方法返回值为负数的时候，取的时候会倒序去值
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        TreeSet<String> ts = new TreeSet<>(new CompareByLen());
        ts.add("aaaaaaaa");
        ts.add("b");
        ts.add("cc");
        ts.add("avb");
        ts.add("nba");
        System.out.println(ts);
    }

    public static void demo3() {
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(new Student("zhangsan", 23));
        ts.add(new Student("lisi", 33));
        ts.add(new Student("zhaoliu", 43));
        ts.add(new Student("wangwu", 13));
        ts.add(new Student("aaaa", 13));
        System.out.println(ts);
    }

    public static void demo2() {
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(new Student("张三",23));
        ts.add(new Student("王五",22));
        ts.add(new Student("赵五",22));
        ts.add(new Student("李四",25));
        ts.add(new Student("赵六",20));
        System.out.println(ts);
    }

    public static void demo1() {
        TreeSet<String> ts = new TreeSet<>();
        ts.add("c");
        ts.add("a");
        ts.add("b");
        ts.add("a");
        ts.add("b");
        ts.add("b");
        ts.add("a");
        
        System.out.println(ts);   //[a, b, c]
    }

}

class CompareByLen implements Comparator<String> {

    @Override
    public int compare(String s1, String s2) {
        int num = s1.length() - s2.length();
        return num == 0 ? s1.compareTo(s2) : num;
    }
    
}