7月15号JavaSE学习笔记

移位运算符是最基本的运算符之一，几乎每种编程语言都包含这一运算符。移位操作中，被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。移位运算符只作用于整形变量，分为两类，第一类是 long 类型，long 类型长度为 8 字节 64 位；第二类为 int 类，int 长度为 4 字节 32 位，short、byte、char 在做移位之前会自动转换为 int 型，因此与 int 规则一致，在做完移位运算后，short、byte、char类型都将变成 int 型数据（转换过程中需要考虑高位丢失的问题）

按位与运算 &

将A和B转成二进制右侧对其上下比较，两者都为1则结果为1，否则为0，最后将结果转为十进制
int result =12 & 3;

按位或运算 |

将A和B转成二进制右侧对其上下比较，两者有一个为1则结果为1，否则为0，最后将结果转为十进制
result=12|11;

按位异或运算 ^

                //将A和B转成二进制右侧对其上下比较，两者不同则为1，相同则为0，最后将结果转为十进制
       result=12^11;

反码运算~

                 //将所有二进制数值中的0换成1，1换成0
                result=~11;//-12

扩展：两正数交换值问题

       //加法运算交换值
       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

       //异或运算交换整数值
       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

移位运算

个人总结：逻辑移位运算(虽然表面说符号位不移动，但本质符号位移动，只不过中间0(负数是1)多，中间0舍去完了就溢出了变成负数了如00011111左移3位)，十进制解释就是byte最大值是127，左移一位扩大两倍无法保存切割后变负数，数据溢出

<< 向左移位运算

正负数都自动补0
result=-5<<2;// -20 向左移动2位，即扩大4倍，移动一位扩大2倍

        对正数进行左移：所有位左移，即 <<，可能会变成负数
       byte p=127;
       //(p<<1)返回值是int，但强转位byte后切割成一个负数了
       //(p<<1)=254
       p=(byte)(p<<1);//p=-2

>> 向右移位运算

        移动补符号位，正补0负补1
       result=-1>>2;//向右移动2位

>>> 向右移位运算

无论正负数移动补0
result=-1>>>1;//向右移动补0

优先级

& > | > && > ||

& | 也可用对布尔值进行运算得到布尔值

boolean bool=true&false;//&和&&结果一样但过程绝对不一样

        a=12;b=12;
       bool=a++<12 & b++>12;//都要运算 a:13 b:13

&与&&区别（|与||同理）

1.&&是逻辑操作符，而& 既是位运算符又是逻辑运算符
2.&是按位与运算符，用于对两个条件进行逻辑与操作，
3.而&&是逻辑与运算符，在条件语句中只有在第一个条件为true时才会继续执行第二个条件，如果第一个条件为false，则不会继续判断第二个条件。
4.&&具有短路功能，而&不具有短路功能

赋值运算符 = += -= /= *= %= &=

+= 操作符会进行隐式自动类型转换，此处 a += b 隐式地将加操作的结果类型强制转换为持有结果的类型，而 a = a + b 则不会自动进行类型转换。

byte a = 1;
byte b = 2;
b = a + b; //报编译错误，不兼容的类型: 从 int 转换到 byte 可能会有精度损失
b += a; //ok
int c=1;
b+=c;

        byte ab=12;
       ab+=2;
       ab=(byte)(ab+2);
       ab-=2;
       ab*=2;
       ab/=2;

三元运算符 A?B:C

A是条件布尔类型 B:C都是值 true取B false取C

result=(int) (12>34?11.1:33);//double到int要强转结果为33虽然不是11.1但总体也要强转

流程控制

if语句

        设置if语句时考虑执行顺序，避免效率低下
       //低效率
       int age=100;
       if(age>=60&&age<70) {

       }else if(age>=70&&age<80) {

       }else {

       }
       //高效率
       if(age>=80) {

       }else if(age>=70&&age<80) {

       }else if(age>=60&&age<70) {

       }else {

       }

switch语句

        //switch case 匹配某一个变量的值是什么，匹配到某一个case项，就从这个case项运行到break或者代码块结束
       //所有的case项都没有匹配成功才会执行default
       //case项和defual的顺序可以是错乱的
       //switch可以匹配的类型且只能是 byte short int char String(Java7新增) Enum

int num=8;

       switch(num) {

           default:
               System.out.println("无");
           case 1://匹配后顺序执行达到并列效果
           case 7://进入
               System.out.println("春");
               break;//退出
           case 2:
               System.out.println("夏");
               break;
           case 3:
               System.out.println("秋");
               break;
           case 4:
               System.out.println("冬");
               break;

运行结果：无加春解释：最终匹配default然后穿透运行到break结束

while

        while 先判断再去做
       适合不明确多少次的情况
       while(继续循环的条件) {
           循环体
       };
例：int n=0;
       while(n<4) {
           System.out.println((char)('a'+n));
           n++;
       }

do...while

        do...while 先做再循环至少执行一次
       do{
       循环体
       }while(继续循环的条件);

例如：int i=1;
       do {
           System.out.println(i);
       }while(i!=1);

for

        for循环适合明确多少次的情况
    计数器;条件;自增或自减
       for(;;) {
       }

例：for(i=0;i<10;i++) {
System.out.println(i+1);
}

流程控制语句

break;结束所在循环体

                //break跳出多重循环
                boolean bool=true;//2.加锁对象
                one:for(;;) {//1.第一个for循环叫one
                    for(;bool;) {
                        for(int bb=0;bb<100;bb++) {
                            if(bb==50) {
                                bool=false;
                                break one;//跳出第一个循环，嵌套循环结束
                            }
                        }
                    }
                }

continue

跳过本次循环进行下一次循环

死循环无结束循环条件 while(true){} 控制台运行报错
无限循环永远达不到循环结束的条件int a=1;while(a<1000){a--;} 可以编写其他代码

数组

有序的元素序列

扩展：Arrays类功能

        给数组赋值：通过fill方法
        对数组排序：通过sort方法，按升序
        比较数组：通过equals方法比较数组中元素值是否相等。
        查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
        Arrays.fill(a,2,4,0);//就是将a数组中从2到4的位置填充为0。会将原来的覆盖掉。

定义：

int[] arr；

int arr[];//效果相同但非首选

三种初始化方法：

        int[] arr= {1,2,3};
       int[] arr3=new int[] {1,2,3};
       int[] arr2=new int[4];

数组限定

1.只能存放指定类型的数据
2.数组的长度不可变

3.其元素必须是相同类型，不允许出现混合类型

数组的各种使用方法：

//使用数组中的元素下标从0开始依次增加
System.out.println(arr[2]);//从0开始第三个

打印数组
       System.out.println(Arrays.toString(arr));
       //打印第一个元素的地址
       System.out.println(arr);
       //获取数组长度
       System.out.println(arr.length);

//遍历数组
for(int a:arr)
System.out.println(a);

数组不可越界下标越界运行会报错

         arr=new int[4];
       //arr[4]=0;//运行会报错
       //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
       //at com.easy.EasyE.main(EasyE.java:46)

二维数组

定义和初始化

int[][] arrs=new int[4][2];

int[][] arrs=new int[4][];//并没有问题

使用方法

        //赋值
       arrs[0][1]=12;
       //打印
       System.out.println(Arrays.deepToString(arrs));
       //遍历
       for(int i=0;i<arrs.length;i++) {
           for(int j=0;j<arrs[i].length;j++) {

           }
       }