4.Java基础1

1.转义字符

public class Hello {
    public static void main(String[] args){
        System.out.println("12\t3");//输出  12    3
        System.out.println("你好\n世界");
        /*
        你好
        世界
        -------------------------------
        \t    制表符
        \n    换行符
        \\    一个\
        \"    一个"
        \'    一个'
         */
        System.out.println("你好\\世界");//你好\世界
        System.out.println("你好\"世\'界");//你好"世'界
    }
}

2.数据类型

1byte=8bit(bit为二进制数字)

public class Hello {
    public static void main(String[] args){
        //测试char的特性
        char c1 = 'a';   //a
        char c2 = '\t';  //空格
        char c3 = '中';   //中
        char c4 = 97;     //a    97在ASCII码表上面对应的就是小写字母a
        char a ;
        a= 'a' + 1;  //b    97+1=98  98在ASCII码表上面对应的就是小写字母b
         System.out.println( (int)a );  //98  强转
        //例子：'中'转换为Unicode为\u4e2d
         a='\u4e2d';// 中  十六进制 
         System.out.println(0x4e2d );//中
         System.out.println( a );//中
         System.out.println((int) a );//20013
         a=20013;
         System.out.println(a);//中
    }
}

布尔型：Boolean a=true,b=false;

3.自动类型转换

char -> int -> long -> float -> double ;
byte -> short -> int -> long -> float -> double;
boolean不转换;
char和short、char和byte之间不进行自动转换;
byte、short、char计算时转换为int类型;
有多种数据类型混合运算的时候，会转成精度最大的那个数据类型，再进行计算;
表达式最终返回结果的类型，自动提升为操作数中精度最高的类型。

4.算术运算符

作为独立的语句使用: 前++和后++都完全等价于i=i+1;
作为表达式使用: 前++（++i）先自增后赋值，赋值是先赋值给一个临时变量；后++（i++）先赋值后自增

public class Hello {
    public static void main(String[] args){
        int y=1,x=1;
        int c=y++;//tmp=y=1;y=y+1;c=tmp=1
        int d=++x;//x=x+;tmp=x;d=tmp;
        System.out.println(c);//1   先赋值
        System.out.println(d);//2   先自增
    }
}
public class Hello1 {
    public static void main(String[] args){
        int y=1,x=1;
        y=y++;
        System.out.println("y = " + y);  //tmp=y;y=y+1;y=tmp;
        x=++x;
        System.out.println("x = " + x);  //x=x+1;tmp=x;x=tmp;
    }
}
public class Hello {
    public static void main(String[] args){
        int x = 4;
        int y = (--x)+(x--)+(x*10);
        System.out.println(y);//26
        System.out.println(x);//2
        //y=a+b+(x*10);  a=(--x);b=(x--);
        //x=x-1=3;tmp=x=3;a=tmp;
        //tmp1=x=3;x=x-1=2;b=tmp1=3;
        //2*10=20
        //y=3+3+20=26
    }
}

5.赋值运算符

+= -= *= /= %=
a += 2; 等价于 a = a + 2;
例子1：byte b = 3; b += 4; 合法，可以看作有个强转的操作；
例子2：byte b = 3; b++; 合法，同上；

6.逻辑运算符（部分）

短路与&&：一假全假；左边为假,右边就不运算
短路或||：一真全真；左边为真,右边就不运算
取反!：!(false) =true
逻辑与&：一假全假；不管真假两边都运算
逻辑或|：一真全真；不管真假两边都运算
逻辑异或^ ：a^b: 当a和b不同时，则结果为true,否则为false

7.三元运算符

变量 = (条件表达式) ? 表达式1 : 表达式2;
当 条件表达式=true时： 变量 = 表达式1；
当 条件表达式=false时：变量 = 表达式2；

public class Hello {
    public static void main(String[] args){
           //求三个数中的最大数max；
           int a=100,b=200,c=300,max=0;
           int result=0;
            max=a>b?a:b;
            result=result > c ? result : c;
           System.out.println(result);//300
    }
}

8.进制与位运算符

public class Hello {
    public static void main(String[] args){
        //右移运算符demo
        System.out.println(10>>1);//5    // 10 的二进制 为0000 1010 ；右移一位变为 0000 0101 =5；
    }
}

位运算符： & | ^ ~ << >> >>>

9.进制转换

十进制：0-9
二进制：0和1，0b或者0B开头
八进制：0-7，0开头
十六进制：0-9abcdef，0x或者0X开头
——————————————————————————-
十进制转十六进制 ： 将该数不断除以16，直到商为0，每步得到的余数倒过来，就是对应的十六进制。
十进制的10转为十六进制为64。
100/16=6——4
6/16=0——6
——————————————————————————-
二进制转十六进制：从低位开始,将二进制数每四位一组,转成对应的十六进制数即可。
0 1 0 0 1 0 0 1 =（08+14+02+01）（18+04+02+11）=49（十六进制）
——————————————————————————-
Hex编码（十六进制编码）

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;
import java.security.MessageDigest;
public class Hello {
    public static void main(String[] args){
        try {
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            md5.update("a12345678".getBytes());
            byte[] digest= md5.digest();
            for (int i = 0; i < digest.length; i++) {
                System.out.println(digest[i]);
            }
           //{-23,-68,14,19,-88,-95,108,-69,7,-79,117,-39,42,17,49,38};
            //byte 数组，一个byte=8bit;  根据二进制转为十六进制，0000  0001 =01 例子来看，md5后hex编码结果，每两位等于一个byte
            //加密结果中的每个字母数字，等于四个比特位
            System.out.println(HexBin.encode(digest));// E9 BC 0E 13 A8 A1 6C BB 07 B1 75 D9 2A1 1 31 26
        } catch (Exception e) {}}}

10.switch语句

public class Hello {
    public static void main(String[] args){
        int x = 5;
        switch(x){
            case 5:
                System.out.println("case 5");
            case 2:
                System.out.println("case 2");
                break;
            case 8:
                System.out.println("case 8");
            case 3:
            case 4:
                System.out.println("春季");
                break;
        }
        //switch是从上往下挨个判断的，如果没加“break”，则会自上而下挨个执行,直到break出现才跳出switch语句。
        //以上结果输出  case 5  case 2
    }}

11.break与continue

public class Hello {
    public static void main(String[] args){
        abc:
        for (int a = 0; a < 3; a++) {
            bcd:
            for (int i = 0; i < 22; i++) {
                if (i==2){
                    continue bcd;
                    //break;  后面不加默认代表  break bcd；
                    //continue abc;代表结束内部循环；
                    //continue bcd; 和continue； 效果一样
                };
                System.out.println("==================");
                System.out.println(i);
            }
        }
    }}

常见的循环控制方法：
break 跳出循环；
continue 到循环尾；
return 跳出所在的方法，如果return写在main方法中，则退出程序。

12.数组

概念：数组是多个相同类型数据的组合，实现对这些数据的统一管理。
动态初始化：元素类型[] 数组名 = new 元素类型[数组长度]; int[] arr = new int[5];
静态初始化：元素类型[] 数组名 = new 元素类型[]{元素,元素,…};int[] arr = new int[]{1,2,3,4,5};

public class Hello {
    public static void main(String[] args){
        int [] aaa=new int[5];//动态初始化
        int[]bbb={2,3,3,3,6};//第一种   静态初始化
        int bbb1[]={2,3,3,3,6};//第二种  静态初始化
        int bbb2[]=new int[]{2,3,3,3,6};//第三种  静态初始化
        int[] bbb3=new int[]{2,3,3,3,6};//第四种 静态初始化
    }}

求int数组中的最大数：

public class Hello {
    public static void main(String[] args){
        int [] aaa=new int[5];//求数组中最大数
        aaa[0]=0;
        aaa[1]=1;
        aaa[2]=2;
        aaa[3]=3;
        aaa[4]=4;
        int max=1;
        for (int i = 0; i < aaa.length; i++) {
            if (max<aaa[i]){max=aaa[i];};}
        System.out.println(max);//4
    }}

数组扩容原理：新创建一个数组，把旧数组内容拷贝到新数组里面（for循环）可实现扩容；
数组是引用类型，如果两个数组简单的复制，即arr1=arr;改变arr1的内容，arr也会随之改变；

二维数组： int[][] arr = new int[2][3]; arr[0][1] = 78;
二维数组的遍历：

public class Hello {
    public static void main(String[] args){
        int[][]arr={{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }}
    }}
/* 几种定义方式  int[] x;      int x[];
    int[][] y;    int y[][];    int[] y[];
  int[] x,y[];  //定义两个数组，x是一维的，y是二维的
*/

十进制转十六进制代码实现：

public class Hello {
    public static void main(String[] args){
        StringBuffer stringBuffer = new StringBuffer();
        char []chars = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        int num=31;
        while (num>0){
          int index= num % 16;//取余
          char tmp = chars[index];//取出对应的十六进制的数值
            stringBuffer.append(tmp);
            num=num/16;
        }
        System.out.println(stringBuffer.reverse().toString());
    }}
//初识stringBuffer
//数组的灵活使用

13.Java帮助文档

Java API中文文档 https://www.matools.com/
Java API的查看方式