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 
    */
    
    
    

}