java学习笔记第二天

运算符

位运算符：二进制运算

按位与运算：&

    int result=12&3;   结果为0
    转换成二进制
    00001100
    00000011    右侧有效位对齐，上下比较，两者都为1，结果才为1，否则就为0
    -------------
    00000000    得0
    int result=12&4; 结果为4
    00001100
    00000100  
    -------------
    00000100    第三位相同，2的2次方=4

按位或运算：|

    int result=12|11；  结果为15
    00001100
    00001011
    -------------
    00001111
    两者有一者为1则为1

按位异或运算：^

    int result=12^11;   结果为7
    00001100
    00001011
    ------------
    00000111
    两者不同则为1，两者相同则为0

反码运算：~  

（所有数值变为相反，包括符号位）
    int result=~11;   结果为-12
    00001011
    11110100  （各数位取反之后）
    ↑为符号位，1代表负数，根据负数的运算规则，将负数的反码+1得出结果
    10001011   +1
    10001100   得出结果是-12，共取反两次

移位运算

左移：<<

    int result=1<<2;  将1向左移动两位
    00000001
    00000100    (所有有效位全部移动，移动后空出的数位补0)
    3*8的最快计算方法：3<<3

    右移：>>  （负数的数位移动）

  空出来的位置补符号位，与原数符号位一致，缺几个空，补几个符号位
    int result=-1>>2;  将1向左移动两位
    10000000 00000000 00000000 00000001   原码
    11111111 11111111 11111111 11111111   补码：保留符号位，按位取反后+1
    11111111 11111111 11111111 1111111111   这里右移两位，在左侧高位补1
    ↑↑ 这两位是根据符号位补充的数位    ↑↑  这两位因右移超出界限，去掉不要
    11111111 11111111 11111111 11111111
        再根据补码写原码
    10000000 00000000 00000000 00000000   保留符号位，按位取反+1
    10000000 00000000 00000000 00000001   得结果：-1

    >>>    

高位空出的位置补0
int result=-1>>>1; 

二者交换

第一种方法：第三变量

第二种方法：加法运算
int a=11,b=22;
a=a+b;//   a=33   b=22;
b=a-b;//   a=33   b=11;
a=a-b;//   a=22   b=11;

第三种方法：异或运算
int a=11,b=22;
a=a^b;  //   a=29       b=22;
b=a^b;  //   a=29       b=11;
a=a^b;  //   a=22       b=11;

赋值运算

    =，+=，-=，*=，/=，%=
    a=12;
    a+=2;

三元运算

    int result=12>34?11:33;  结果是33  (A?B:C)      A是布尔类型，B,C是值，若A为true，则取B的值，否则取C的值
    
    System.out.println(true?3:4.0);      结果是3.0   有double类型参与的运算结果都是double类型

&和&&的区别

&，|也可以对Boolean进行运算，得到布尔值
boolean bool=true&false;    结果是false    &和&&运算结果是一样的，但是过程不一样
a=12;b=12;
bool=a++<12 & b++>12;     按位与运算符，将前后两个数据按照二进制位进行“与”运算
bool=a++<12 && b++>12;      逻辑运算符，判断true,false，若前为false，则后面算式不计算（有短路现象）

运算符优先级

（本图引用网络图片）

    

流程控制

    if(){}
    else{}
    else if(){}

    swich  case
    swich匹配某一个变量的值，如果匹配到某一个case的项，就从这个case开始运行
    运行到break或者代码块结束
    所有的case项都没有匹配成功才会执行default
    执行顺序从上到下
    1.case项和default项的顺序可以错乱
    2.switch可以匹配的类型：byte，short，int，char，String，Enum（枚举）

    循环while   for：
    
    while循环适合不知道循环多少次的情况
    while(循环条件){
        循环体
        i++；
    }

    do{
        循环体
    }while(循环条件);          do...while至少执行一次

    for循环适合已知循环多少次的情况
    for(int i=0;判断条件;i++){
        循环体
    }

break结束所在循环体
continue跳出本次循环，继续执行下一处循环

break跳出多重循环：
    1.给for循环起名字，break后加循环名字。
    a:for(；；){
        b:for(；；){
            break a;
         }
     }
    
    2.Boolean bool=true;
       for(；bool&&其他条件；){
        for(；bool&&其他条件；){
            if(结束所有循环条件)
                bool=false;
        }
    }

死循环：没有结束条件的循环，之后不能写其他代码，代码报错
无限循环：结束循环的条件永远达不到，之后可以编写其他代码，代码不报错

数组

数组是有序的元素序列
一维数组三种定义写法：
        int[] arr={2,4,5,6,7,8,9};
        int[] arrB=new int[]{23,45};    （这两种是静态初始化）

        int[] arrA=new int[5];      （这是动态初始化） [5]代表可以存放5个元素
    数组的限定：
    1.只能存放指定类型的数据
    2.程序运行时数组的长度是不可变的
    3.下标不得越界

    使用数组中的元素   下标从0开始依次增加
    System.out.println(arr)；打印第一个元素的地址
    System.out.println(Arrays.toString(arr));打印所有元素
    
    获取数组长度：
    System.out.println(arr.length);
    
        int[][] arrs=new int[4][2];
        arrs[0][0]=2;
        System.out.println(Arrays.deepToString(arrs));
    二维数组的限定：其中一维数组的个数不可变，数组内元素个数可变