java基础系列06--集合(2)

2019-01-14 本文已影响8人 addin_gao

JAVA　集合二

Set集合

特点：无索引，不可重复，无序，存取不一致

public static void main(String[] args){
//     Set集合无索引，不可重复，无序，存取不一致，  
       HashSet<String> hs = new HashSet<>();
       boolean b1 = hs.add("a");  // true
       boolean b2 = hs.add("b");  // true
       boolean b3 = hs.add("a");  // false
       System.out.println(hs); // [a, b] HashSet类有父类(AbstractCollection)重写了toString方法
       for (String string : hs) {
           System.out.println(string); // a b 所有能用迭代器遍历的都可以使用增强for循环
       }
       
}

HashSet类

HashSet原理: 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数

当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象,如果没有哈希值相同的对象就直接存入集合,如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存

将自定义类的对象存入HashSet去重复:类中必须重写hashCode()和equals()方法

public class Student {
    public static void main(String[] args){
//     Set集合无索引，不可重复，无序，存取不一致，  
       HashSet<Person> hs = new HashSet<>();
       hs.add(new Person("张三",11));
       hs.add(new Person("张三",11));
       hs.add(new Person("李四",11));
       hs.add(new Person("王五",11));
       System.out.println(hs);//[Person [age=11, name=王五], Person [age=11, name=张三], Person [age=11, name=李四]]
       
    }
    
}
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Person(String name,int age){
        this.age = age;
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;　//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;
        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 String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
}

LinkedHashSet类

LinkedHashSet是HashSet子类，是Set集合中唯一一个保证怎么存就怎么取的集合对象，原理和HashSet类似，同样不能保存重复数据

public static void main(String[] args){
        LinkedHashSet<String> li = new LinkedHashSet<>();
        li.add("a");
        li.add("b");
        li.add("c");
        li.add("a");
        System.out.println(li); // [a b c]
}

练习:

// 练习一
public static void main(String[] args){
//      使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
        Scanner sc = new Scanner(System.in);            //创建键盘录入对象
        System.out.println("请输入一行字符串:");
        String line = sc.nextLine();                    //将键盘录入的字符串存储在line中
        char[] arr = line.toCharArray();                //将字符串转换成字符数组
        HashSet<Character> hs = new HashSet<>();        //创建HashSet集合对象
            
        for(char c : arr) {                             //遍历字符数组
            hs.add(c);                                  //将字符数组中的字符添加到集合中
        }   
        for (Character ch : hs) {                       //遍历集合
            System.out.println(ch);
        }
}
// 练习二
public static void main(String[] args){
    // 获取10个1至20的随机数，要求随机数不能重复。
    HashSet<Integer> hs = new HashSet<>();      //创建集合对象
    Random r = new Random();                    //创建随机数对象
    while(hs.size() < 10) {
        int num = r.nextInt(20) + 1;            //生成1到20的随机数
        hs.add(num);
    }
    for (Integer integer : hs) {                //遍历集合
        System.out.println(integer);            //打印每一个元素
    }
}
//  练习三
public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("a");
            list.add("a");
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("b");
            list.add("b");
            list.add("c");
            list.add("c");
            list.add("c");
            list.add("c");
                
            System.out.println(list);
            System.out.println("去除重复后:");
            getSingle(list);
            System.out.println(list);
}
            
/*
* 将集合中的重复元素去掉
* 1,void
* 2,List<String> list
*/
            
public static void getSingle(List<String> list) {
    LinkedHashSet<String> lhs = new LinkedHashSet<>();
    lhs.addAll(list);               //将list集合中的所有元素添加到lhs
    list.clear();               　　 //清空原集合
    list.addAll(lhs);               //将去除重复的元素添回到list中
}

TreeSet类

TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列

使用方式:

自然顺序(Comparable)

TreeSet类的add()方法中会把存入的对象提升为Comparable类型
调用对象的compareTo()方法和集合中的对象比较
根据compareTo()方法返回的结果进行存储

public class Student {
  public static void main(String[] args){
      TreeSet<Integer> ts = new TreeSet<>();
      ts.add(3);
      ts.add(1);
      ts.add(2);
      ts.add(1);
      System.out.println(ts); // [1, 2, 3] 二插搜索树排
      
      TreeSet<Person> ts1 = new TreeSet<>();
      ts1.add(new Person("张三",13));
      ts1.add(new Person("李四",14));
      ts1.add(new Person("张三",15));
      ts1.add(new Person("赵六",15));
      System.out.println(ts1); // 报错com.test.Person cannot be cast to java.lang.Comparable
      // 不添加重复项是因为会调用实现的Comparable接口的compareTo方法，上面的Integer可以是因为Integer类实现了Comparable接口，
      //　　但是我们自定义的对象是没有继承Comparable接口，没有重写compareTo方法，所以会报错，所以我们自定义的类需要实现Comparable接口
      //   compareTo方法有个返回值，TreeSet则是根据这个返回值判断是否需要加入集合的方式，0 则不加，小于0则反着排，大于0则正向排序
  }
  
}
class Person implements Comparable<Person>{
  private int age;
  private String name;
  public int getAge() {
      return age;
  }
  public void setAge(int age) {
      this.age = age;
  }
  public String getName() {
      return name;
  }
  public void setName(String name) {
      this.name = name;
  }
  public Person(String name,int age){
      this.age = age;
      this.name = name;
  }
  @Override
  public String toString() {
      return "Person [age=" + age + ", name=" + name + "]";
  }
  @Override
  public int compareTo(Person o) {
      //return -1; //　反向排序添加
      //　return 1; // 正向排序添加
      // return 0; //　不添加
//        return this.age - o.getAge(); // 根据年龄大小排序　//[Person [age=13, name=张三], Person [age=14, name=李四], Person [age=15, name=张三]]
      int num = this.age - o.getAge(); // 优先根据年龄排序
      int sum = num == 0 ? this.name.compareTo(o.getName()):num; // 年龄若相同，则根据姓名排序
      return sum;  //[Person [age=13, name=张三], Person [age=14, name=李四], Person [age=15, name=张三], Person [age=15, name=赵六]]
      
}

比较器顺序(Comparator)

创建TreeSet的时候可以制定一个Comparator
如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
add()方法内部会自动调用Comparator接口中compare()方法排序
调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数

public class Student {
  public static void main(String[] args){
      // 将字符串按照字符串长度排序
      TreeSet<String> ts = new TreeSet<>();
      ts.add("aaaaa");
      ts.add("bcd");
      ts.add("dc");
      ts.add("a");
      System.out.println(ts);  // [a, aaaaa, bcd, dc]这是按照ASIIC码排序
      
      TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){
          @Override      //匿名内部内，
          public int compare(String o1, String o2) {
              int num = o1.length() - o2.length(); // 优先按照字符串长度排序
              int sum = num == 0? o1.compareTo(o2):num; //　字符串长度一致则按照ASIIC码排序
              return sum;
          }
      });
      ts2.add("aaaaa");
      ts2.add("bcd");
      ts2.add("dc");
      ts2.add("a");
      System.out.println(ts2);   //[a, dc, bcd, aaaaa] 这是按照字符串长度排序的
  }
}

两种方式的区别:

TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序, TreeSet如果传入Comparator, 就优先按照Comparator

练习：键盘输入: helloworld程序打印:dehllloorw

java基础系列06--集合(2)

JAVA　集合二

Set集合

HashSet类

LinkedHashSet类

TreeSet类

猜你喜欢

热点阅读

java基础系列06--集合(2)

JAVA 集合二

Set集合

HashSet类

LinkedHashSet类

TreeSet类

猜你喜欢

热点阅读

JAVA　集合二