目录
1.内部类
1.1实例内部类
如果非要定义一个静态变量在内部类中,则要将其变为静态常量即:
public static final int data6 = 6;
那么我们如何让来实例内部类对象呢?
1.2内部类的应用场景
内部类一般在链表的应用比较多,比如:
class MyLinkedList {
class Node{
}
}
通过后台我们可以看见,内部类的字节码文件是这样的:
那么如果实例内部类当中和外部类有同名的成员变量,那么如何在实例内部类中访问?
即:
因此实例内部类中一般包含两个this,一个是外部类的this,一个是内部类的this
1.3静态内部类
如何实例静态内部类对象:
如何访问外部类的普通的成员变量
这里并不能直接访问
正确的访问格式:
1.4匿名内部类
这个匿名内部类就像我们之前学过的构建一个大堆或者小堆一样:
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return 0;
}
});
2.哈希表
假设我们有这样一种搜索方法,在一个数组中可以不经过任何的比较,直接找到这个元素。如果构造一种存储结构,通过某种函 数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快 找到该元素。这个函数就叫做哈希函数。
哈希表的大致过程:
可是当我们有14这个值应该怎么办呢?14 / 10 = 4,和之前的4重复,那么我们应该怎么放置呢
此时不同的关键字通过哈希函数,有可能找到相同的位置,此时的情况我们称为哈希冲突。
2.1避免哈希冲突
2.1.1直接定制法
取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B 优点:简单、均匀 缺点:需要事先知道关 键字的分布情况 使用场景:适合查找比较小且连续的情况 。
2.1.2除留余数法
设散列表中允许的地址数为m,取一个不大于m,但最接近或者等于m的质数p作为除数,按照哈希函数: Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
2.2调解负载因子
负载因子 = 存储散列表的元素的个数 / 散列表的长度
因为负载因子在一定程度上和冲突率成正比,因此我们降低负载因子即(增加散列表的长度)可以降低冲突率。
以上就是我们避免哈希冲突的两种方法,那么冲突发生了,我们该如何解决呢?
3.解决哈希冲突方法
开散列 / 哈希桶也叫链地址法,首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码归于同一子 集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结点存储在哈希表中。
代码展示:
public class HashBuck {
static class Node{
public int key;
public int val;
public Node next;
public Node(int key,int val){
this.key = key;
this.val = val;
}
}
public Node[] array;
public int usedSize;
public static final double DEFAULT_LOAD_FACTOR = 0.75;//负载因子
public HashBuck(){
this.array = new Node[10];
}
/**
*put函数
* @param key
* @param val
*/
public void put(int key,int val){
//1.找到key所在的位置
int index = key % this.array.length;
//2.遍历这个下标的链表,看是不是有相同的val值,有的话要更新val值
Node cur = array[index];
while (cur != null){
if(cur.key == key){
cur.val = val;//更新val值
return;
}
cur = cur.next;
}
//3.没有key这个元素,头插法
Node node = new Node(key,val);
node.next = array[index];
array[index] = node;
this.usedSize++;
//4.插入元素成功之后,检查当前散列表的负载因子
if(loadFactor() >= DEFAULT_LOAD_FACTOR){
//扩容
resize();
}
}
//扩容
private void resize(){
//如果数组进行扩容,那么数组里面的每个链表的每个元素都要进行重新哈希
Node[] newArray = new Node[array.length * 2];
for (int i = 0; i <this.array.length ; i++) {
Node cur = array[i];
while (cur != null){
int index = cur.key % newArray.length;//获取新的下标
//把cur这个节点,以头插的形式插入到新的数组对应下标的链表中
Node curNext = cur.next;//用curNext来保存cur的下一个节点地址
cur.next = newArray[index];//先绑定后面
newArray[index] = cur;//再绑定前面
cur = curNext;//cur继续向下遍历
}
}
array = newArray;
}
private double loadFactor(){
return 1.0 * usedSize / array.length;
}
/**
*根据key获取val值
* @param key
* @return
*/
public int get(int key){
//1.找到key所在的位置
int index = key % this.array.length;
//2.遍历这个下标的链表,看是不是有相同的val值,有的话要更新val值
Node cur = array[index];
while (cur != null){
if(cur.key == key){
return cur.val;
}
cur = cur.next;
}
return -1;
}
可是如果数组里面存储得不是整数或者类型是引用类型得数据,怎么办呢?
假设接下来得key是一个person,如果身份证号一样,我们认为是同一个人,hashcode函数是将不规则的数变为整数:
那么在这个代码里面,hashcode 就是帮助我们找到index下标,然后用equals方法来比较key值是否相同,因此,以后在HashMap中放入自定义的类,那么hashcode和equals方法一定要重写
class Person{
public String ID;
public Person(String ID) {
this.ID = ID;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(ID, person.ID);
}
@Override
public int hashCode() {
return Objects.hash(ID);
}
@Override
public String toString() {
return "Person{" +
"ID='" + ID + '\'' +
'}';
}
}
public class HashBuck2<K,V> {
static class Node<K,V>{
public K key;
public V val;
public Node<K,V> next;
public Node(K key,V val){
this.val = val;
this.key = key;
}
}
public Node<K,V>[] array = (Node<K, V>[]) new Node[10];
public int usedSize;
public void put(K key,V val){
int hash = key.hashCode();
int index = hash % array.length;
Node<K,V> cur = array[index];
while (cur != null){
if(cur.key.equals(key)){
cur.val = val;//更新val值
return;
}
cur = cur.next;
}
Node<K,V> node = new Node<>(key,val);
node.next = array[index];
array[index] = node;
this.usedSize++;
}
public V get(K key){
int hash = key.hashCode();
int index = hash % array.length;
Node<K,V> cur = array[index];
while (cur != null){
if(cur.key.equals(key)){
return cur.val;
}
cur = cur.next;
}
return null;
}
题1:
hashcode一样,equals一定一样吗?
答案是不一定一样,因为hashcode确定的是哈希的位置,一个位置可能有多个key值。
equals一样,hashcode一定一样吗?
答案是一定一样。