2019-05-27 Java学习日记 day17

Hashset集合

存储字符串并遍历

import java.util.HashSet;

public class dmo1_hashset {
        //set集合，无索引，不可以重复，无序(存取不一致)
    public static void main(String[] args) {
        HashSet<String> hSet=new HashSet<>();  //创建hashset对象
        boolean b1=hSet.add("a");
        boolean b2=hSet.add("a");    //当向set集合中存储重复元素的时候返回为false
        hSet.add("b");
        hSet.add("c");
        hSet.add("d");
        
        System.out.println(hSet);  //hashset的继承体系中有重写toString方法
        //System.out.println(b1);
        //System.out.println(b2);
        for (String string : hSet) {  //只要能用迭代器迭代的，就可以使用增强for循环遍历
            System.out.println(string);
        }

    }

}

存储自定义对象保证元素唯一性

Hashset原理

　　我们使用set集合都是需要去掉重复元素的，如果在存储的时候逐个equals（）比较，效率较低，哈希算法提高了重复的效率，降低了使用equals（）方法的次数

　　当Hashset调用add（）方法存储对象的时候，先调用对象的hashset（）方法得到一个哈希值，然后在集合中查找是否有哈希值相同的对象：

　　如果没有哈希值相同的对象就直接存入集合

　　如果有哈希值相同的对象，就和哈希值相同的对象逐个进行equals（）比较，比较结果为false就存入，true则不存

 

将自定义累的对象存入Hashset去重复

　　类中必须重写hashCode（）和equals（）方法

　　hashCode（）：属性相同的对象返回值此项相同，属性不同的返回值尽量不同(提高效率)

　　equals（）：属性相同返回true，属性不同返回false，返回false的时候存储　

import java.util.HashSet;

import tan.jung.bean.Person;

public class demo2_hashset {

    public static void main(String[] args) {
        HashSet<Person> hs =new HashSet<>();
        hs.add(new Person("张三",23));
        hs.add(new Person("张三",23));
        hs.add(new Person("张三",23));
        hs.add(new Person("李四",24));
        hs.add(new Person("李四",24));
        
        System.out.println(hs);  //需要重写equals和HashCode方法
        

    }

}

//第二个包
public class Person {
    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("执行了");
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age == p.age;  
    }
    @Override
    public int hashCode() {
        final  int num=38;
        return name.hashCode() * num +age;
    }*/
    @Override
    public int hashCode() {
        final int prime = 31; //31是一个质数，质数是能被1和自己本身整除的数 ，即不大也不小，比较好算，2的五次方-1,2向左移动五位
        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;　　　　　　　　　　//直接返回rute　　　　
        if (obj == null)　　　　　　　　　　//传入的对象为null
            return false;　　　　　　　　　　//返回false
        if (getClass() != obj.getClass())　//判断两个对象对应的字节码未见是否是同一个字节码
            return false;　　　　　　　　　　　//如果不是直接返回false
        Person other = (Person) obj;　　　　　//向下转型
        if (age != other.age)　　　　　　　　//调用对象的年内不等于传入对象的年龄
            return false;　　　　　　　　　　 //返回false
        if (name == null) {　　　　　　　　　　//调用对象的姓名不为null
            if (other.name != null)　　　　　　//传入对象的姓名不为null
                return false;　　　　　　　　　　//返回false
        } else if (!name.equals(other.name))　　//调用对象的姓名不等于传入对象的姓名
            return false;　　　　　　　　　　　　　　//返回flase
        return true;　　　　　　　　　　　　　　　　　//返回true
    }
}

 

LinkedHashset

特点：

　　可以保证怎么存就怎么取

底层是连带实现的，是set集合中唯一一个能保证怎么存怎么取得集合对象

因为Hashset的子类，所以也是保证元素唯一的，与Hashset的原理一样

随机数

public class test1 {

    public static void main(String[] args) {
        //创建Random类创建随机数对象
        Random r1=new Random();
        //不能重复，需要用Hashset方法
        HashSet<Integer> hs1=new HashSet<>();
        //hashset的size是下雨10就可以不断存储，如果大于等于10就停止存储
        while (hs1.size()<10) {
            //通过random类中的nextInt（n）方法获取1到20之间的随机数，并将这些随机数存现在hashset集合中
            hs1.add(r1.nextInt(21));
        }
        //遍历Hashset
        for (Integer integer : hs1) {
            System.out.println(integer);
        }
    }

键盘输入，去掉重复

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

import javax.sound.sampled.Line;

public class test2 {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        
        System.out.println("请输入");    
        //创建Hashset独享，将字符存储，去掉重复
        HashSet<Character> hs1 =new HashSet<>();
        //将字符串转换成字符数组，获取每一个字符存储在Hashset集合中，自动去除重复
        String line=sc.nextLine();    
        char[] arr=line.toCharArray();
        
        for (char c : arr) { //遍历字符数组
            hs1.add(c);
        }
        //遍历Hashset，打印每一个字符
        for(Character ch:hs1){
            System.out.println(ch);
        }
    }

}

去除集合中的重复

import java.util.ArrayList;
import java.util.LinkedHashSet;

public class test3 {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
                        
        getSingle(list);    //调用方法
                
        System.out.println(list);

    }

    public static void getSingle(ArrayList<String> list) {
        LinkedHashSet<String> lsh=new LinkedHashSet<>();
        
        lsh.addAll(list); //添加list元素
        
        list.clear();        //清除list元素
        
        list.addAll(lsh);    //将LinkedHashset集合中的元素添加会list集合中
    }

}

TreeSet

Treeset存储Integer类型的元素并遍历

import java.util.TreeSet;

public class demo4_TreeSet {
    //TreeSet集合是用来对对象元素进行排序的，同事也可以保证元素的唯一
    public static void main(String[] args) {
        
        TreeSet<Integer> ts1=new TreeSet<>();
        ts1.add(1);
        ts1.add(1);
        ts1.add(2);
        ts1.add(2);
        ts1.add(3);
        ts1.add(3);
        ts1.add(3);
        ts1.add(4);
        ts1.add(4);
        
        System.out.println(ts1);

    }

}

TreeSet存储自定义对象

二叉数：两个叉

小的存储在左边（负数），打的存储在右边（整数），相等就不存（0）

compareTo方法，在TreeSet集合如何存储元素取决于compareTo方法的返回值

返回0，集合中只有一个元素

返回负数集合会将存储的元素倒序

返回整数会怎么存怎么取

import java.util.Iterator;
import java.util.TreeSet;

import tan.jung.bean.Person;

    /*当compareTo方法返回0的时候集合中只有一个元素
     *当compareTo方法返回整数的时候集合会怎么存就怎么取
     *当compareTo方法返回负数的时候集合会倒序存储
     * */
public class demo5_TreeSet {
    public static void main (String args[]){
      TreeSet<Person> ts1=new TreeSet<>();
      ts1.add(new Person("xx",20));
      ts1.add(new Person("hh",20));      
      ts1.add(new Person("nn",20));
      ts1.add(new Person("mm",20));
      
      Iterator<Person> it1=ts1.iterator();
      while (it1.hasNext()) {
        Person p1=it1.next();
        System.out.println(p1.getName()+"  "+p1.getAge());
        
    }
      //System.out.println(ts1);
    }
    
}

//第二个包
public class Person implements Comparable<Person>{
    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("执行了");
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age == p.age;  
    }
    @Override
    public int hashCode() {
        final  int num=38;
        return name.hashCode() * num +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;
        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 int compareTo(Person o) {
        
        return -1;
    }
}

按照姓名排序

按照年龄排序

import java.util.Iterator;
import java.util.TreeSet;

import tan.jung.bean.Person;

    /*当compareTo方法返回0的时候集合中只有一个元素
     *当compareTo方法返回整数的时候集合会怎么存就怎么取
     *当compareTo方法返回负数的时候集合会倒序存储
     * */
public class demo5_TreeSet {
    public static void main (String args[]){
      //demo1();
        TreeSet<Person> ts1=new TreeSet<>();
          ts1.add(new Person("张三",20));
          ts1.add(new Person("李四",12));      
          ts1.add(new Person("王五",25));
          ts1.add(new Person("赵六",11));
          ts1.add(new Person("七七",11));
          
          System.out.println('张'+0);
          System.out.println('李'+0);
          System.out.println('王'+0);
          System.out.println('赵'+0);
          System.out.println('七'+0);
          
          Iterator<Person> it1=ts1.iterator();
          while (it1.hasNext()) {
            Person p1=it1.next();
            System.out.println(p1.getName()+"  "+p1.getAge());
            
        }
    }

    public static void demo1() {
        TreeSet<Person> ts1=new TreeSet<>();
          ts1.add(new Person("xx",20));
          ts1.add(new Person("hh",12));      
          ts1.add(new Person("nn",25));
          ts1.add(new Person("mm",11));
          ts1.add(new Person("ss",11));
          
          Iterator<Person> it1=ts1.iterator();
          while (it1.hasNext()) {
            Person p1=it1.next();
            System.out.println(p1.getName()+"  "+p1.getAge());
            
        }
    }
    
}


//第二个包
import java.awt.RenderingHints;

public class Person implements Comparable<Person>{
    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    /*@Override
    public boolean equals(Object obj) {
        System.out.println("执行了");
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age == p.age;  
    }
    @Override
    public int hashCode() {
        final  int num=38;
        return name.hashCode() * num +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;
        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 int compareTo(Person o) {
        int num =this.age-o.age;  //年龄是主要条件
        return num==0 ? this.name.compareTo(o.name) : num;
    }*/
    @Override
    public int compareTo(Person o) {
        int num=this.name.compareTo(o.name); 
        int num2=this.age-o.age;//姓名是主要条件
        return num==0 ? num2 :num;
    }
    
}

按照姓名长度排序

public int compareTo(Person o) {
        int length =this.name.length() - o.name.length();  //比较长度为主要条件
        int num =length == 0? this.name.compareTo(o.name) :length;//比较内容为次要条件
        //如果length等于0的话就比较this.name.compareTo(o.name) ，compare比较内容
        //如果不等于0的话就比较length
        return num ==0 ? this.age-o.age :num; //比较年龄为次要条件
    }

接口不能直接new 需要给子类对象

public class demo5_TreeSet {
    public static void main (String args[]){  
        //demo1();
        //demo2();
        //demo3();
        TreeSet<String> ts1=new TreeSet<>(new CompareByLen());       
                 //compare c=new CompareByLen();
          ts1.add("abccd");
          ts1.add("z");
          ts1.add("bb");
          ts1.add("sss");
          System.out.println(ts1);
        
                
          
    }
}

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 ; //内容为次要条件
    }
     
 }

TreeSet原理

特点：

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

使用方式：

　　1.自然排序（Comparable）

　　　　TreeSet类的add（）方法中会把存入的对象提升为Comparable类型

　　　　调用对象的compareTo（）方法和集合中的对象比较

　　　　根据compareTo（）方法返回结果进行存储

　　2.比较器顺序（Comparator）

　　　　创建TreeSet的时候可以制定一个Comparatpr

　　　　如果传入了Comparator的子类对象，那么TreeSet就会按照比较器中的顺序排序

　　　　add（）犯法内部会自动调用Comparator接口中compare（）方法排序

　　　　调用的对象是compare（）方法的第一个参数，集合中的对象是compare方法的第二个参数

　　3.两种方式区别：

　　　　TreeSet构造函数什么都不传，默认按照类中Comparable的顺序（没有就报错ClassCasException）

　　　　TreeSet如果传入了Comparator，就优先按照Comparator