3.set的平底是map集合,方法和Collection的办法基本等同

set接口的特性:

set接口的特色:

1.不含有重复元素

1.不分包重复元素

2.set会晤没有索引,只好用迭代器或增加for循环遍历

2.set会聚没有索引,只好用迭代器或抓好for循环遍历

3.set的平底是map集合

3.set的底层是map集合

方式和Collection的方法基本相同

措施和Collection的点子基本一致

 

 

set接口的贯彻类HashSet:

set接口的完毕类HashSet:

1.无序凑合

1.无序会见

2.得以存入空(null)

2.方可存入空(null)

3.不得以存在重新元素

3.不能够存在双重元素

示例:

示例:

package demo;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("abc1");
        set.add("abc1");
        set.add("abc2");
        set.add("abc3");
        set.add("abc4");
        Iterator<String> i1 = set.iterator();
        while(i1.hasNext()){
            System.out.println(i1.next());
        }
    }
}
/*
输出:
注意:这里的输出特点是无序的
abc1
abc4
abc2
abc3
*/
package demo;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("abc1");
        set.add("abc1");
        set.add("abc2");
        set.add("abc3");
        set.add("abc4");
        Iterator<String> i1 = set.iterator();
        while(i1.hasNext()){
            System.out.println(i1.next());
        }
    }
}
/*
输出:
注意:这里的输出特点是无序的
abc1
abc4
abc2
abc3
*/

 

 

set底层数据结构是哈希表:

set底层数据结构是哈希表:

特色:存储取出都比较快

特点:存储取出都比较快

规律:具体省略,简单说就是链表数组结合体

规律:具体省略,不难说就是链表数组结合体

 

 

目的的哈希值:普通的一个整数

对象的哈希值:普通的一个平头

可以知道为身份证号,是hashset存储的基于

可以领会为身份证号,是hashset存储的基于

package demo;

public class Person {}

package demo;

public class HashDemo {
    public static void main(String[] args) {
        Person p = new Person();
        int i = p.hashCode();
        System.out.println(i);
        //每次运行都会输出不同的整数,比如1191201656

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354
        //这里Stirng重写hashcode方法,有对应的计算公式
        //当字符串的内容相同时候,运算结果就相同,因此s1和s2的哈希值相同
    }
}
package demo;

public class Person {}

package demo;

public class HashDemo {
    public static void main(String[] args) {
        Person p = new Person();
        int i = p.hashCode();
        System.out.println(i);
        //每次运行都会输出不同的整数,比如1191201656

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354
        //这里Stirng重写hashcode方法,有对应的计算公式
        //当字符串的内容相同时候,运算结果就相同,因此s1和s2的哈希值相同
    }
}

 

 

哈希表存储进程:

哈希表存储进度:

1.调用对象的哈希值

1.调用对象的哈希值

2.成团在容器内搜索有没有再一次的哈希值,假诺没有,存入新因素,记录哈希值

2.会聚在容器内搜寻有没有再一次的哈希值,借使没有,存入新因素,记录哈希值

3.重复存储,重复上边的长河

3.再一次存储,重复上面的进度

4.如果有重复的哈希值,调用后来者的equals方法,参数为前来者,结果获得true,集合判断为重新元素,不存入

4.若是有双重的哈希值,调用后来者的equals方法,参数为前来者,结果取得true,集合判断为重新元素,不存入

 

 

一律的字符串假若存进去,哈希值相同,equals方法为true,不会存入相同的

一如既往的字符串即使存进去,哈希值相同,equals方法为true,不会存入相同的

比方哈希值相同或者equals方法为true都成立才不会存入,只要其中一条不知足,都会储存

要是哈希值相同或者equals方法为true都建立才不会存入,只要其中一条不满足,都会蕴藏

 

 

哈希表存储自定义对象:

哈希表存储自定义对象:

package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

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

}
package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

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

}

 

 

package demo;

import java.util.HashSet;

public class HashDemo {
    public static void main(String[] args) {
        HashSet<Person> setPerson = new HashSet<Person>();
        setPerson.add(new Person("a",17));
        setPerson.add(new Person("b",20));
        setPerson.add(new Person("b",20));
        setPerson.add(new Person("c",18));
        System.out.println(setPerson);
        //[c:18, b:20, a:17, b:20]
        //发现存入了重复的元素
        //所以想办法使name和age相同的Person对象视为同一个对象
        //所以需要重写hashcode方法
    }
}
package demo;

import java.util.HashSet;

public class HashDemo {
    public static void main(String[] args) {
        HashSet<Person> setPerson = new HashSet<Person>();
        setPerson.add(new Person("a",17));
        setPerson.add(new Person("b",20));
        setPerson.add(new Person("b",20));
        setPerson.add(new Person("c",18));
        System.out.println(setPerson);
        //[c:18, b:20, a:17, b:20]
        //发现存入了重复的元素
        //所以想办法使name和age相同的Person对象视为同一个对象
        //所以需要重写hashcode方法
    }
}

 

 

温馨重写:

祥和重写:

 

 

package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public int hashCode(){
        return name.hashCode()+age*66;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return name.equals(p.name) && age == p.age;
        }
        return false;
    }
}
package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public int hashCode(){
        return name.hashCode()+age*66;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return name.equals(p.name) && age == p.age;
        }
        return false;
    }
}

 

 

eclipse可以扶助大家写:

eclipse可以扶助大家写:

package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

    public Person(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;
        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;
    }

}
package demo;

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 String toString() {
        return this.name + ":" + this.age;
    }

    public Person() {
    }

    public Person(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;
        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;
    }

}

 

 

LinkedHashSet集合:基于链表的哈希表完毕,继承HashSet,它具备顺序

LinkedHashSet集合:基于链表的哈希表落成,继承HashSet,它抱有顺序

示例:

示例:

package demo;

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //有序的set
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>(); 
        link.add(1);
        link.add(2);
        link.add(3);
        link.add(4);
        System.out.println(link);
        //[1, 2, 3, 4]
    }
}
package demo;

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //有序的set
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>(); 
        link.add(1);
        link.add(2);
        link.add(3);
        link.add(4);
        System.out.println(link);
        //[1, 2, 3, 4]
    }
}

 

 

至于hashcode和equals的有些题材,在面试中会问道:

至于hashcode和equals的局地难题,在面试中会问道:

1.八个对象哈希值相同,那么equals方法肯定重临true吗?不自然

1.多少个对象哈希值相同,那么equals方法肯定重返true吗?不自然

在于怎么着重写equals,若是重写一定了它回到false,结果就一定是false

在于怎么着重写equals,假若重写一定了它回到false,结果就势必是false

2.equals情势再次来到true,那么哈希值一定相同呢?一定

2.equals主意重回true,那么哈希值一定相同呢?一定

一经类中定义一个静态变量(static int a =
1),然后重写hashcode重临a+1,那么每一个对象的哈希值都不平等

设若类中定义一个静态变量(static int a =
1),然后重写hashcode重回a+1,那么每一个对象的哈希值都不等同

而是java中确定:对象相等,必须拥有相同的哈希码值,所以那边是毫无疑问的

不过java中规定:对象相等,必须怀有同等的哈希码值,所以那边是必定的

 

 

相关文章