hashMap 临界值初步理解

import java.util.*;

public class Bs {

//Integer.highestOneBit((number - 1) << 1)分解

public static void main(String []args) {

//number(hashMap需要多大的长度,先简单的理解为table.length)
int a = 1;//根据传入的table.length=1,计算这个hashMap需要多大的长度
int b = 3;
int c = 5;
int d = 8;
System.out.println("初始结果----------------------------------");
System.out.println(Integer.toBinaryString(a));//1
System.out.println(Integer.toBinaryString(b));//11
System.out.println(Integer.toBinaryString(c));//101
System.out.println(Integer.toBinaryString(d));//1000
System.out.println("");

//number - 1 ****************************************************为什么减1?--->保证结果是最近偶数
int a1 = 1-1;//0
int b1 = 3-1;//2
int c1 = 5-1;//4
int d1 = 8-1;//7

//number
//int a1 = 1; //不减1最终的结果是1-->2;应该是1
//int b1 = 3; //不减1最终的结果是3-->4;应该是4
//int c1 = 5; //不减1最终的结果是5-->8;应该是8
//int d1 = 8; //不减1最终的结果是8-->16;应该是8

//为什么减1
//如果这个数为奇数,减1后是比它小1的偶数,这个偶数是2的倍数,如果乘2,可能恰好是一个2的次方
//如果这个数为偶数,可能本身它就是一个2的次方,那么通过下面的移位算法,计算出来的空间就会大,浪费空间

System.out.println("减1结果----------------------------------");
System.out.println(Integer.toBinaryString(a1));//0
System.out.println(Integer.toBinaryString(b1));//10
System.out.println(Integer.toBinaryString(c1));//100
System.out.println(Integer.toBinaryString(d1));//111
System.out.println("");

//(number - 1) << 1 ****************************************************为什么左移?-->取偶数->大部分是最近的偶数了

//为什么左移
//<<:左移运算符，num << 1,相当于num乘以2
//左移后低位是由0来补充的
//JAVA中没有<<<的，因为左移后低位肯定是由0来补充的

int a2 = a1 << 1;
int b2 = b1 << 1;
int c2 = c1 << 1;
int d2 = d1 << 1;
System.out.println("左移结果----------------------------------");
System.out.println(Integer.toBinaryString(a2));//0 0 1
System.out.println(Integer.toBinaryString(b2));//100 4 3
System.out.println(Integer.toBinaryString(c2));//100 8 5
System.out.println(Integer.toBinaryString(d2));//1110 14 8
System.out.println("");

System.out.println("最终结果----------------------------------");
System.out.println("");
//Integer.highestOneBit((number - 1) << 1) ****************************************************为什么取111的形式然后做了个减法运算?
int a3 = highestOneBit(a2);
int b3 = highestOneBit(b2);
int c3 = highestOneBit(c2);
int d3 = highestOneBit(d2);
System.out.println("1--->"+a3);
System.out.println("3--->"+b3);
System.out.println("5--->"+c3);
System.out.println("8--->"+d3);
System.out.println("");

System.out.println("修正0值----------------------------------");
int fix = 1 >= (1 << 30)
? (1 << 30)
: (1 > 1) ? 0 : 1;

int f1 = (1 > 1) ? 0 : 1;
System.out.println("1--->"+f1);
int f2 = 1 >= (1 << 30) ? (1 << 30) : 1;
System.out.println("2--->"+f2);
System.out.println("3--->"+fix);
System.out.println("");

int a4 = 1;//1
int b4 = 4;//3
int c4 = 8;//5
int d4 = 8;//8
System.out.println("理想结果----------------------------------");
System.out.println(Integer.toBinaryString(a4));//10
System.out.println(Integer.toBinaryString(b4));//100
System.out.println(Integer.toBinaryString(c4));//100
System.out.println(Integer.toBinaryString(d4));//1000
System.out.println("");
System.out.println("1--->"+a4);
System.out.println("3--->"+b4);
System.out.println("5--->"+c4);
System.out.println("8--->"+d4);
System.out.println("");

System.out.println("测试----------------------------------");
System.out.println(14>>1);//14/2=7
System.out.println(7>>1);//7/2=3
System.out.println(3>>1);//3/2=1
System.out.println(1>>1);//1/2=0
System.out.println(0>>1);//0/2=0

}

//0,4,8,14
//14->8
//1110->(这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果)->1000->8
//这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果:说白了就是取离我最近的，比我小的一个2次方的值-----为什么？
//2--->10
//4--->100
//8--->1000
//16--->10000
//32--->100000

public static int highestOneBit(int i) {

// HD, Figure 3-1
System.out.println("右移结果");
i |= (i >>  1);
//>>:右移运算符，num >> 1,相当于num除以2
//表示右移，如果该数为正，则高位补0，若为负数，则高位补1

System.out.println("1--->"+Integer.toBinaryString(i));
i |= (i >>  2);
System.out.println("2--->"+Integer.toBinaryString(i));
i |= (i >>  4);
System.out.println("3--->"+Integer.toBinaryString(i));
i |= (i >>  8);
System.out.println("4--->"+Integer.toBinaryString(i));
i |= (i >> 16);
System.out.println("5--->"+Integer.toBinaryString(i));

System.out.println("6--->"+Integer.toBinaryString(i >>> 1)+"(无符号右移)");
//>>>:无符号右移，忽略符号位，空位都以0补齐
//表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0
System.out.println("7--->"+Integer.toBinaryString(i - (i >>> 1))+"(减法运算)");
System.out.println("");

return i - (i >>> 1);
}
//1,4,8,8

/*
这个函数的作用是取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果。
1、第一步的作用是把最高位1右移移位，并与原数据按位取或。那么这就使得最高位和它的下一位是连续两个1。    2、第二步的作用是把刚刚移位得到连续两个1继续右移两位并与原数据按位取或。那么这就使得最高两位和它的下两个连续位组成四个连续的1。
3、 以此类推，最终得到的i是从开始的最高位到结束全是1。并减去i不带符号的右移一位，即可得到一个int数据的最高位的值。    4、上述情况是针对于i不为零和负数的情况，如果i为零，那么得到的结果始终为零。如果i位负数，那么得到的结果始终是-2147483648。即等于Integer.MIN_VALUE。（原因在于负数的最高位始终为1，即是负数的符号位）
---------------------
本文来自 JessenPan 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/jessenpan/article/details/9617749?utm_source=copy
*/

}