Thinking in Java 4th chap2笔记-操作符

Thinking in Java 4th chap2笔记-操作符

1. 内存分配
     1. 寄存器 -最快的存储区,位于处理器内部，无法直接控制
     2. 堆栈 ：位于RAM，随机访问存储器中，可通过堆栈指针从处理器那里获得直接支持；堆栈指针，向上移动，则分配内存；向下移动， 则释放内存；不过创建程序时，Java系统必须知道存储在堆栈内所有项的生命周期，以便上下移动堆栈指针；这一约束，限制了程序的灵活性；
     Java对象引用存储于堆栈中；而Java对象不存储于其中
     3. 堆 ：一种通用的内存区，也位于RAM区,用于存放所有的Java对象;堆不同于堆栈的好处是：编译器不需要知道存储的数据在堆里存活多长时间；因此在堆里存储有很大的灵活性；当需要一个对象时，只需要new写一行简单的代码,当执行这行代码时，会自动在堆里进行存储分配；
     用堆进行存储分配和清理可能比堆栈进行存储分配需要更多的时间;
     4. 常量存储 :常量值通常存储在程序代码内部,这样做是安全的，因为他们永远不会被改变；
     5. 非RAM存储 :  
      如流对象和持久化对象;在流对象中，对象转换成字节流，通常被发送给另一台机器；在“持久化”对象中，对象被存放于磁盘上；这种存储方式的技巧在于把对象可以转化为其他媒介上的事物，他们仍可以保持自己的状态，在需要时，可以恢复成常规的，基于RAM的对象；Java提供了对轻量级持久化的支持，而诸如JDBC和HIBERNATE这样的机制提供了更加复杂的对在数据库存储和读取对象信息的支持.

2 .基本类型是特例：
     小，简单；不用new来创建变量，而是创建一个并非引用的“自动”变量，这个变量直接存储值，并置于堆栈中，因此更加高效；
  因为new将对象存储在“堆”中，故用new创建一个对象，特别是小的简单的变量，往往不是很有效；

3. 所有数值类型都有正负号 -每种基本类型所占存储空间的大小都是不变的
 char:16bits
 byte:8bits
 short:16bits
 int:32bits
 long:64bits
 float:32bits
 double:64bits

4 .数组 ：当创建一个数组对象时，其实是创建了一个引用数组；并且每个引用会被自动初始化为一个特定值，null
 对于用来存放基本类型的数组，编译器也能确保这种数组的初始化，因为它会将会这种数组所占的内存全部置0

5.二进制码补充学习
    2 二进制 为10
     其实全部显示为00000000000000000000000000000010，高位为0，表示为正

    -2 二进制为11111111111111111111111111111110
     其计算方法为：
          1.首先是找到正数2的二进制形式00000000000000000000000000000010
          2.按位取反->111111111111111111111111111111101
          3.加1->11111111111111111111111111111110
  
    将11111111111111111111111111111110变为整数
         1.首先判断其为负数，按位取反->0000000000000000000000000000001
         2.加1->00000000000000000000000000000010
         3.2步骤后，得结果为2，然后因为是负数，所以加一个符号，得-2

    所以补码的设计目的是：

        ⑴ 使符号位能与有效值部分一起参加运算，从而简化运算规则。补码机器数中的符号位，并不是强加上去的，是数据本身的自然组成部分，可以正常地参与运算。
        ⑵ 使减法运算转换为加法运算，进一步简化计算机中运算器的线路设计。
        (3)为了统一正0和负0

    有符号数：
        最高位是符号位，0表示正，1表示负

        反码表示法规定：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
        补码表示法规定：正数的补码与其原码相同；负数的补码是在其反码的末位加1。

        原码表示虽然很简单，用原码来进行加减运算会出问题,
            问题出在带符号位的负数上
        反码表示，将加减数都表示成反码后，减法可以直接表示成加法
            问题出在(+0)和(-0)上,在人们的计算概念中零是没有正负之分的，于是就出现了补码，正数的补码不变，负数的补码是将其反码加1

        原码和反码中，+0与-0的表示并不相同，所以计算机中一般使用补码。还有利用高位溢出，将减法运算变成加法运算

        模的概念：把一个计量单位称之为模或模数。例如，时钟是以12进制进行计数循环的，即以12为模。在时钟上，时针加上（正拨）12的整数位或减去（反拨）12的整数位，时针的位置不变。14点钟在舍去模12后，成为（下午）2点钟（14=14-12=2）。从0点出发逆时针拨10格即减去10小时，也可看成从0点出发顺时针拨2格（加上2小时），即2点（0-10=-10=-10+12=2）。因此，在模12的前提下，-10可映射为+2。由此可见，对于一个模数为12的循环系统来说，加2和减10的效果是一样的；因此，在以12为模的系统中，凡是减10的运算都可以用加2来代替，这就把减法问题转化成加法问题了（注：计算机的硬件结构中只有加法器，所以大部分的运算都必须最终转换为加法）。10和2对模12而言互为补数。
　　
        同理，计算机的运算部件与寄存器都有一定字长的限制（假设字长为8），因此它的运算也是一种模运算。当计数器计满8位也就是256个数后会产生溢出，又从头开始计数。产生溢出的量就是计数器的模，显然，8位二进制数，它的模数为8=256。在计算中，两个互补的数称为“补码”。

    a. 采用补码后，可以方便地将减法运算转化成加法运算，运算过程得到简化。正数的补码即是它所表示的数的真值，而负数的补码的数值部份却不是它所表示的数的真值。采用补码进行运算，所得结果仍为补码。 　　
    b. 与原码、反码不同，数值0的补码只有一个，即 [0]补=00000000B。 　　
    c. 若字长为8位，则补码所表示的范围为-128～+127；进行补码运算时，应注意所得结果不应超过补码所能表示数的范围。

6.部分源码

package  com.book.chap2.operator;
/** */ /**
 *
 *直接常量
 *<p>byte,short,int,long均有符号和无符号之分，如byte[-128-127]</p>
 *<p>Integer.toBinaryString</p>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public   class  Literals
{
    public static void main(Stringargs)
    {
        //0x-16进制
        int i1 = 0x2f;//f 小写
        //转为2进制
        System.out.println("i1:" + Integer.toBinaryString(i1));
        //转为16进制
        System.out.println("i1:" + Integer.toHexString(i1));
        //转为8进制
        System.out.println("i1:" + Integer.toOctalString(i1));
        System.out.println(i1);
        
        //0x-16进制
        int i2 = 0x2F;//F 大写
        System.out.println("i2:" + Integer.toBinaryString(i1));
        System.out.println(i2);
        
        //0-8进制
        int i3 = 0177;
        System.out.println("i3:" + Integer.toBinaryString(i3));
        
        //char能表示的16进制的最大值,char，2个字节，因为是字符->0-2的16次方-1
        char c = 0xffff;
        System.out.println("c:" + Integer.toBinaryString(c));
        
        //byte的16进制表示的最大值，因为byte1个字节，-128-127
        byte b = 0x7f;
        System.out.println("b:" + Integer.toBinaryString(b));
        
        //short的16进制表示的最大值
        short s = 0x7fff;
        System.out.println("s:" + Integer.toBinaryString(s));
        
        //long的后缀--小写l容易和1混淆
        long n1 = 200L;
        long n2 = 200l;
        
        //float的后缀
        float f1 = 1;
        float f2 = 1f;
        float f3 = 1F;
        
        //double的后缀
        double d1 = 1;
        double d2 = 1d;
        double d3 = 1D;
        
        //TODO 此会编译错误，因为0.2默认为double,应该改为0.2f
//        float f4 = 0.2;
        float f5 = 0.2f;
        
        //TODO 试图向一个变量赋值超过自身范围的数值，编译器会报错
        //byte b2 = 128;Type mismatch: cannot convert from int to byte
        byte b2 = 127;
        
        //TODO 输出各数据类型的最大值/最小值
        System.out.println("byte:" + Byte.MIN_VALUE + "-" + Byte.MAX_VALUE + 
                " " + Integer.toHexString(Byte.MIN_VALUE) + "-" + Integer.toHexString(Byte.MAX_VALUE));
        System.out.println("char:" + Character.MIN_VALUE + "-" + Character.MAX_VALUE + 
                " " + Integer.toHexString(Character.MIN_VALUE) + "-" + Integer.toHexString(Character.MAX_VALUE));
        System.out.println("short:" + Short.MIN_VALUE + "-" + Short.MAX_VALUE + 
                " " + Integer.toHexString(Short.MIN_VALUE) + "-" + Integer.toHexString(Short.MAX_VALUE));
        System.out.println("int:" + Integer.MIN_VALUE + "-" + Integer.MAX_VALUE + 
                " " + Integer.toHexString(Integer.MAX_VALUE) + "-" + Integer.toHexString(Integer.MIN_VALUE));
        System.out.println("long:" + Long.MIN_VALUE + "-" + Long.MAX_VALUE + 
                " " + Long.toHexString(Long.MAX_VALUE) + "-" + Long.toHexString(Long.MIN_VALUE));
        
        //TODO 将float或者double转为整型的时候，总会截尾
        System.out.println((int)0.1);
        System.out.println((int)0.9f);
        
        //TODO 如果需要舍入，则需Math.round
        System.out.println(Math.round(0.9));
        System.out.println(Math.round(0.4));
    }
}

 

package  com.book.chap2.operator;

// TODO 静态导入，这样就不必每次都敲System.out了
import   static  java.lang.System.out;
/** */ /**
 *
 *循环标签-标签是后面跟有冒号的标识符
 *<p>
 *    1.java中，标签起作用的唯一地方是刚好在迭代语句之前:即在标签和迭代语句之间置入任何语句都不好
 * 2.在迭代之前设置标签的唯一理由是：我们希望在其中嵌套另一个迭代或者一个开关switch;break和continue只能中断当前循环，与标签一起使用，则会中断循环，直到标签所在地方
 * 3.注意：在java中使用标签的理由就是因为有嵌套迭代的存在，而且想从多层嵌套中break或者continue
 *</p>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public   class  LoopLabel
{
    public static void main(Stringargs)
    {
        int i = 0;
        //label
        OUTER:
            while(true)
            {
                System.out.println("outter while loop");
                while(true)
                {
                    i++;
                    System.out.println("i = " + i);
                    
                    if(i == 1)
                    {
                        out.println("continue");
                        continue;
                    }
                    
                    //TODO 带标签的continue回达到标签的位置，然后并重新进入紧接在那个标签后面的循环
                    if(i == 3)
                    {
                        out.println("continue outer");
                        continue OUTER;
                    }
                    
                    if(i == 5)
                    {
                        out.println("break");
                        break;
                    }
                    
                    //TODO 带标签的break会中断并跳出标签所指的循环
                    if(i == 7)
                    {
                        out.println("break outer");
                        break OUTER;
                    }
                }
            }
    }
}

 

package  com.book.chap2.operator;


/** */ /**
 *
 *移位
 *<pre>
 *    1.左移<<，按照操作符右侧指定的位数将操作符左侧的操作数向左移动，低位补0
 *    2.“有符号”右移>>,按照操作符右侧指定的位数将操作符左侧的操作数向右移动；“有符号”操作符>>使用符号扩展：若符号为正，则在高位插入0；若符号为负，则在高位插入1
 * 3."无符号"右移，Java新增，它使用零扩展，无论正负，都在高位插入0
 *</pre>
 *
 *@author landon
 *@since JDK1.6
 *@version 1.0 2012-3-21
 *
 */
public   class  ShiftBit
{
    public static void main(Stringargs)
    {
        int j = 2;
        
        //正-左移
        System.out.println("before shift:"+ j + " " + Integer.toBinaryString(j));
        int shitfJ1 = j << 5;
        System.out.println("after shift:"+ shitfJ1 + " " + Integer.toBinaryString(shitfJ1));
        
        int k = -2;
        
        //负-左移
        System.out.println("before shift:"+ k + " " + Integer.toBinaryString(k));
        int shitfk1 = k << 5;
        System.out.println("after shift:"+ shitfk1 + " " + Integer.toBinaryString(shitfk1));
        
        int i = 128;
        
        //正-右移
        System.out.println("before shift:"+ i + " " + Integer.toBinaryString(i));
        int shitfI1 = i >> 5;
        System.out.println("after shift:"+ shitfI1 + " " + Integer.toBinaryString(shitfI1));
        
        //负-右移,符号为负，右移的时候，高位插入1
        int m = -128;
        System.out.println("before shift:"+ m + " " + Integer.toBinaryString(m));
        int shitfm1 = m >> 5;
        System.out.println("after shift:"+ shitfm1 + " " + Integer.toBinaryString(shitfm1));
        
        int n = 128;
        
        //正-无符号右移，无论正负，高位均插入0
        System.out.println("before shift:"+ n + " " + Integer.toBinaryString(n));
        int shitn1 = n >>> 5;
        System.out.println("after shift:"+ shitn1 + " " + Integer.toBinaryString(shitn1));
        
        //负-无符号右移，无论正负，高位均插入0-->这样一个负数就变成了正数
        int o = -128;
        System.out.println("before shift:"+ o + " " + Integer.toBinaryString(o));
        int shitfo1 = o >>> 5;
        System.out.println("after shift:"+ shitfo1 + " " + Integer.toBinaryString(shitfo1));
    }
}