Java —Set 集合以及其HashSet,LinkedHashSet,TreeSet实现类

一、Set集合

1.Set 集合里的元素是无序的，无重复的，无下标的
2.用Set的实现类HashSet添加字符串
public static void fun1() {
    //使用HashSet主要是用来，去重
      //创建一个HashSet集合
    HashSet <String> set = new HashSet<>();
    //添加 d d
    //有序是怎么存就怎么打印出来
    //
    boolean add = set.add("d");
    boolean add2 = set.add("d");
              set.add("a");
              set.add("a");
              set.add("b");
              set.add("b");
              set.add("c");
              set.add("c");
    System.out.println(add);
    System.out.println(add2);
    System.out.println(set);
}
}
``

true
fals
[a,b,c,d]

3. //创建一个HashSet添加6个Person，两两一样
 //hashSet 如何自定义对象类型 如何去重？
//通过重写对象类中的，equals方法 和 hashCode方法，来去重
public static void fun2() {
 HashSet<Person> set = new HashSet<>();
        set.add(new Person("鹏鹏", 11));

        set.add(new Person("鹏鹏", 11));

        set.add(new Person("水水", 12));

        set.add(new Person("水水", 12));

        set.add(new Person("茜茜", 13));

        set.add(new Person("茜茜", 13));
        Iterator<Person> iterator = set.iterator();
        while(iterator.hasNext()) {
            Person next = iterator.next();
            System.out.println(next);
        }
}

Person [姓名=茜茜,年龄=13]
Person [姓名=鹏鹏,年龄=11]
Person [姓名=水水,年龄=12]

4.//linkedHashSet 是HashSet一个子类
        //特点：有序，怎么存的就怎么取出来
          //字符串为什么直接放进set中就能去重？
public static void fun3() {
LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("l");
        set.add("w");
        set.add("a");
        set.add("a");
        set.add("n");
        set.add("g");
    System.out.println(set);
}

[l,w,a,n,g]

5.//  编写一个程序，获取10个1至20的随机数，要求随机数不能重复
public static void fun4() {
LinkedHashSet<Integer> set = new LinkedHashSet<>();
      while(set.size()<10) {
          int num = (int) (Math.random()*(20-1+1)+1);
          set.add(num);//自动装箱
      }
      System.out.println(set);
}

[这里面是10个不同随机数]

输入一个字符串,去掉其中重复字符
public static void fun5() {
      String string ="wanglong";
      LinkedHashSet<Character>set = new LinkedHashSet<>();
      //字符串转字符数组
         char[] charArray = string.toCharArray();
         //添加到set集合，完成去重
         for (int i = 0; i < charArray.length; i++) {
                set.add(charArray[i]);//自动装箱
        }
     System.out.println(set);
}

[w,a,n,g,l,o]

7.利用set集合 去除ArrayList集合中的重复元素 aabbccdd(操作原ArrayList)
public static void fun6() {
ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("d");
        list.add("d");
        //创建一个Set集合
        LinkedHashSet<String>set =  new LinkedHashSet<>();
        //将list中所有的元素添加进set中去重
        set.addAll(list);
        //清空list元素
        list.clear();
        //再把所有元素放进list里
        list.addAll(set);
        System.out.println(list);
}

[a,b,c,d]

8.TreeSe集合
public static void fun1() {
    TreeSet<Integer>set = new TreeSet<>();
    set.add(1);
    set.add(13);
    set.add(1);
    set.add(2);
    set.add(3);
    for (Integer integer : set) {
        System.out.println(integer);
    }
}
}

1
2
3
13

9.* 创建TreeSet 集合，保存4个工人
        * 想排序，系统给你留了个接口Comparable，如果你想要通过TreeSet来排序
        *你就实现这个接口，编写排序的规则 系统就会按照这个规则来给你排序
public static void fun2() {
  TreeSet<Worker>set = new TreeSet<>();
       set.add(new Worker("张三",23));
       set.add(new Worker("李四",13));
       set.add(new Worker("王五",43));
       set.add(new Worker("赵六",33));
       for (Worker worker : set) {
       System.out.println(worker);
    } 
    }

10.     * 使用比较器来排序的步骤
        * 1.创建一个类 实现Comparator接口
        * 2.实现接口中的方法 并编写 比较的规则
        * 3.把该类的对象 传入 TreeSet集合中
public static void fun3() {
TreeSet<String>set = new TreeSet<>(new KeepStringComImple());
       set.add("asd");
       set.add("asd");
       set.add("asdef");
       set.add("a");
       set.add("as");
      System.out.println(set);
}  

//保留重复的字符串的比较器 
class  KeepStringComImple 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;
        //返回 1和 -1都行
        //存与不存，取决于这个方法的返回值
         return num == 0 ? 1 :num;

    }

}

11.
public static void fun4() {
    //  键盘接收一个字符串, 程序对其中所有字符进行排序
    //  要求保留重复的
       System.out.println("请输入字符串");
       Scanner scanner = new Scanner(System.in);
       String string = scanner.nextLine();
         char[] charArray = string.toCharArray();
       TreeSet<Character> set = new TreeSet<>(new CharCompImpl());
       for (int i = 0; i < charArray.length; i++) {
        set.add(charArray[i]);
    }
       System.out.println(set);
}

class CharCompImpl implements Comparator<Character>{

    @Override
    public int compare(Character o1, Character o2) {
        int num = o1.compareTo(o2);
        return num == 0 ? 1:num;

    }

}

12.
public static void fun5() {
    /*
         * 程序启动后, 可以从键盘输入接收多个整数, 
         * 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
         * 保留重复，比较器实现 
         */


       Scanner scanner = new Scanner(System.in);
       TreeSet<Integer>set = new TreeSet<>(new StringCompImpl());
       while(true) {  
           System.out.println("请输入整数：");
           String string  = scanner.nextLine();
           if(string.equals("quit")) {
               break;
           }
          //输入的是整数的时候
           int num = Integer .parseInt(string);
           //添加到容器 
           set.add(num);
       }
     System.out.println(set);
}

“`
class StringCompImpl implements Comparator{

@Override
public int compare(Integer o1, Integer o2) {
     int num = o1 - o2;
     return num == 0 ? 1 :num;

}

}