杰神之Java集合中的Set(懒人版)

Set

今天博主太累了,不想分类了,例子都在里面,内容都在注释上,自己瞅吧
今天例子用到的类:

public class Person {
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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 String toString() {
        // TODO Auto-generated method stub
        return "名字:"+name+" 年龄"+age;
    }
    //之后使用系统自动生成的hashCode和equals方法
    @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;//返回true
        if (obj == null)//如果传进来的对象是null
            return false;//返回false
        if (getClass() != obj.getClass())//如果两个对象不是一个类创建出来的
            return false;               //就返回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;
    }

//  @Override
//  public boolean equals(Object obj) {
//      // TODO Auto-generated method stub
//      Person person =(Person)obj;
//      return this.name.equals(person.getName())&&this.age==person.getAge();
//  }
//  //重写hashCode方法
//  //Set集合在进行存储的时候
//  //当hashCode值相同时 
//  //会调用equals方法 进行对比 是同一个对象就不存
//  //当hashCode不同时,没有调用equals方法
//  @Override
//  public int hashCode() {
//      // TODO Auto-generated method stub
//      return this.age;
//  }
}
public class Worker extends Person implements Comparable<Worker>{

    public Worker() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Worker(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }
    //实现接口中的唯一方法
    /*
     * 返回0时  set中只有一个元素
     * 1(正数)  按存进去的顺序正序打印
     * -1(负数) 按存进去的顺序倒序打印
     * 
     * TreeSet 按二叉树保存
     * 要保存的数比我小 放在我左边(返回负数)
     * 要保存的数比我大 放在我右边(返回正数)
     * 要保存的数一样大 不保存
     * 打印按从小到大打(正序)
     * 
     * 使用TreeSet排序的步骤
     * 1.让TreeSet集合中保存的对象 实现Comparable接口
     * 2.实现compareTo方法
     * 3.在compareTo方法中 实现 你要排序的规则
     */
    //按年龄排序
//  @Override
//  public int compareTo(Worker o) {
//      // TODO Auto-generated method stub
//      return this.getAge()-o.getAge();
//  }
//  
    //比较的主要条件 按年龄
    //     次要条件 按姓名
//  @Override
//  public int compareTo(Worker o) {
//      // TODO Auto-generated method stub
//      if (this.getAge()-o.getAge()!=0) {
//          return this.getAge()-o.getAge();
//      } else {
//          return this.getName().compareTo(o.getName());
//      }
//      //三目运算符版本
//      return this.getAge()-o.getAge()!=0 ?this.getAge()-o.getAge():this.getName().compareTo(o.getName());
//  }
    @Override
    //先比字符串长度 再比年龄 再比字符串
    public int compareTo(Worker o) {
        // TODO Auto-generated method stub
        return this.getName().length()-o.getName().length()!=0?this.getName().length()-o.getName().length():this.getAge()-o.getAge()!=0 ?this.getAge()-o.getAge():this.getName().compareTo(o.getName());
    }
}

应用:

/*
 * Set(接口)
 * 无序(无下标) 不重复
 */
public class Demo01 {
    public static void main(String[] args) {
        //fun1();
        //fun2();
        //fun3();
        //fun4();
        //fun5();
        //利用set集合 去除ArrayList集合中的重复元素 a a b b c c d d
        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");
        LinkedHashSet<String> set=new LinkedHashSet<>();
        set.addAll(list);
        list.clear();
        list.addAll(set);
        System.out.println(list);
    }
    /**
     * 
     */
    public static void fun5() {
        //输入一个字符串 去掉其中重复字符 wlznbwlznb-->wlznb
        String string="wlznbwlznb";
        char[] charArray = string.toCharArray();
        LinkedHashSet<Character> set=new LinkedHashSet<>();
        for (char c : charArray) {
            set.add(c);
        }
        System.out.println(set);
    }
    /**
     * //  编写一个程序，获取10个1至20的随机数，要求随机数不能重复
     */
    public static void fun4() {
        HashSet<Integer> set=new HashSet<>();
        for (int i = 0; i < 10; i++) {
            int rand = rand(1, 20);
            boolean add = set.add(rand);
            if (add==false) {
                i--;
            }
        }
        System.out.println(set);
    }
    public static int rand(int i, int j) {
        int num;
        int min = i, max = j;
        num = min + (int) (Math.random() * (max - min + 1));
        return num;
    }
    /**
     * 
     */
    public static void fun3() {
        //LinkedHashSet是HashSet的一个子类
        //特点:有序 怎么存的就能怎么取出
        LinkedHashSet<String> set =new LinkedHashSet<>();
        set.add("w");
        set.add("a");
        set.add("n");
        set.add("g");
        System.out.println(set);
    }

    /**
     * 
     */
    public static void fun2() {
        //创建一个hashSet 添加6个人 两两一样
        HashSet<Person> set=new HashSet<>();
        set.add(new Person("鹏鹏",17));
        set.add(new Person("鹏鹏",17));
        set.add(new Person("水水",18));
        set.add(new Person("水水",18));
        set.add(new Person("茜茜",19));
        set.add(new Person("茜茜",19));
        //遍历set集合 查看去重效果
        Iterator<Person> iterator = set.iterator();
        while (iterator.hasNext()) {
            Person person = (Person) iterator.next();
            System.out.println(person);
        }
    }

    /**
     * 添加字符串的
     */
    public static void fun1() {
        //使用HashSet主要用来去重
        //创建一个HashSet
        HashSet<String>hashSet=new HashSet<>();
        //添加d d看看效果
        hashSet.add("d");
        hashSet.add("d");
        hashSet.add("a");
        hashSet.add("b");
        hashSet.add("c");
        System.out.println(hashSet);
    }
}

public class Demo02_2 {
    public static void main(String[] args) {
        // fun1();
        //fun2();
    }

    /**
     *  程序启动后, 可以从键盘输入接收多个整数, 直到输入quit时结束输入. 
     *  把所有输入的整数倒序排列打印.
     */
    public static void fun2() {
        Scanner sc = new Scanner(System.in);
        String nextLine = "";
        TreeSet<Integer> set = new TreeSet<>(new DaoXu());
        while (true) {
            nextLine = sc.nextLine();
            if (nextLine.equals("quit")) {
                break;
            }
            int zs = Integer.parseInt(nextLine);
            set.add(zs);
        }
        System.out.println(set);
        sc.close();
    }

    /**
     * 键盘接受一个字符串,程序对其中所有字符进行排序 要求保留重复的
     */
    public static void fun1() {
        Scanner sc = new Scanner(System.in);
        String nextLine = sc.nextLine();
        char[] array = nextLine.toCharArray();
        TreeSet<Character> set = new TreeSet<>(new CharLengthCompareImpl());
        for (char c : array) {
            set.add(c);
        }
        System.out.println(set);
        sc.close();
    }
}

// 倒叙输出的规则
class DaoXu implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        // TODO Auto-generated method stub
        return o2 - o1;
    }
}

// 保留字符串的规则
class CharLengthCompareImpl implements Comparator<Character> {
    @Override
    public int compare(Character o1, Character o2) {
        // TODO Auto-generated method stub
        if (o1 - o2 == 0) {
            return 1;
        }
        return o1 - o2;
    }
}

import java.util.Comparator;
import java.util.TreeSet;
class StringLengthCompareImpl implements Comparator<String>{
    //主要比 字符串长度
    //次要比 比较字符串
//  @Override
//  public int compare(String o1, String o2) {
//      // TODO Auto-generated method stub
//      return o1.length()-o2.length()!=0 ?o1.length()-o2.length():o1.compareTo(o2);
//  }
    //保留重复
    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        int num =o1.length()-o2.length()!=0 ?o1.length()-o2.length():o1.compareTo(o2);
        return num!=0?num:1;
    }
}
public class Demo02 {
    public static void main(String[] args) {
        //fun1();
        //fun2();

        //使用比较器来排序的步骤
        //1创建一个比较器类 实现Comparator接口
        //2实现接口中的方法并编写比较规则
        //3把该类的对象传入TreeSet的集合中
        TreeSet<String> set =new TreeSet<>(new StringLengthCompareImpl()
                );
        set.add("asd");
        set.add("asdge");
        set.add("asdef");
        set.add("z");
        set.add("z");
        set.add("as");
        //按字符串长度排序
        System.out.println(set);
    }

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

    /**
     * 
     */
    public static void fun1() {
        //创建一个TreeSet
        TreeSet<Integer> set =new TreeSet<>();
        set.add(1);
        set.add(3);
        set.add(4);
        set.add(6);
        set.add(7);
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}