Java学习-20211213_java中char类型实际上是一个整数类型,它可以存储unicode字符的编码。-CSDN博客

本文链接：https://blog.csdn.net/Komoribe_1212/article/details/121910830

本文仅是自己在听课时上的笔记，时不时会更新，各位大佬看到了希望有错的地方能多多指点，谢谢。

Java基础

一、变量

变量都是其程序的基本组成单位：变量有三要素（类型+名称+值）

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

1.1 基本步骤

声明变量
int a;
赋值
a= 60;
使用 System.out.println(a); 也可以int a=60；

二、数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。

2.1 整数类型

2.1.1 细节

Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。
Java的整型常量默认为int型，声明long型常量须后加 “ l ” 或 “ L ”
java程序中变量常声明为int型，除非不足以表示大数，才使用 long
bit:计算机中的最小存储单位。byte:计算机中基本存储单元,1 byte = 8 bit [二进制再详细说，简单举例一个 byte 3和 short 3 ]

2.2 浮点类型

关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
尾数部分可能丢失,造成精度损失(小数都是近似值)。

2.2.1 细节

与整数类型类似，Java 浮点类型也有固定的范围和字段长度，不受具体 OS 的影响。[ float 4个字节double 是8个字节]
Java的浮点型常量默认为 double 型，声明 float 型常量,须后加 ’ f ’ 或 ’ F ’
浮点型常量有两种表示形式
十进制数形式:如: 5.12 512.0f .512 (必须有小数点) 科学计数法形式: 如: 5.12e2 [5.12*10的2次方] 5.12E-2[5.12的-2次方]
通常情况下，应该使用 double 型,因为它比 float 型更精确
浮点数使用陷阱:2.7 和 8.1 / 3 比较

当我们对运算结果是小数的进行相等判断时，要小心

2.3 字符类型（char）

字符类型可以表示单个字符,字符类型是 char, char 是两个字节(可以存放汉字),多个字符我们用字符串String (我们后面详细讲解 String )

字符类型可以直接存放一个数字

2.3.1 细节

字符常量是用单引号(’ ')括起来的单个字符。例如:char c1 = ‘a’; char c2 ='中; char c3 =9";
Java中还允许使用转义字符 ’ \ ′ 来将其后的字符转变为特殊字符型常量。例如:char c3 = ’ \n ’ ；// ’ \n ’ 表示换行符
在java中，char的本质是一个整数，在输出时，是unicode码对应的字符。
http://tool.chinaz.com/Tools/Unicode.aspx
可以直接给char赋一个整数，然后输出时，会按照对应的 unicode 字符输出。char=97->输出a
char类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码。

字符型存储到计算机中，需要将字符对应的码值（整数）找出来，比如’a’

存储:‘a’ ==>码值97 >二进制>存储
读取:二进制=> 97 ==> ‘a’=>显示

字符和码值的对应关系是通过字符编码表决定的(是规定好)

2.3.2 字符编码表

ASCII (ASCII编码表一个字节表示，一个128个字符,实际上一个字节可以表示256个字符,只用128个)

Unicode (Unicode编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节,这样浪费空间)

utf-8 (编码表，大小可变的编码字母使用1个字节，汉字使用3个字节)

gbk (可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)

gb2312 (可以表示汉字，gb2312< gbk)big5码(繁体中文,台湾，香港)

2.4 基本数据类型转换

2.4.1 自动类型转换

当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换。

数据类型按精度（容量）大小排序为：

2.4.1.1 细节

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时，就会报错,反之就会进行自动类型转换。
( byte, short )和 char 之间不会相互自动转换。
byte,short,char 他们三者可以计算,在计算时首先转换为 int 类型。
boolean 不参与转换
自动提升原则:表达式结果的类型自动提升为操作数中最大的类型

2.4.2 强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符)，但可能造成精度降低或溢出,格外要注意。

2.4.2.1 细节

当进行数据的大小从大——>小，就需要使用到强制转换
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
char 类型可以保存 int 的常量值，但不能保存 int 的变量值,需要强转
byte 和 short 类型在进行运算时，当作 int 类型处理

2.5 基本数据类型和 String 类型的转换

基本数据类型 -> String 类型

基本类型的值 + " "
String类型 -> 基本数据类型

通过基本类型的包装类调用 parsexx 方法

2.5.1 细节

在将String类型转成基本数据类型时，要确保 String 类型能够转成有效的数据,比如我们可以把 “123”，转成一个整数，但是不能把 "hello"转成一个整数
如果格式不正确，就会抛出异常，程序就会终止

三、运算符

3.1 算数运算符

/ 除法运算符，10/4 为 2， double b = 10/4 是2.0 10.0/4 为2.5

% 取模（取余）原理： a % b = a - a / b * b

++ 自增 独立使用时都等价于i=i+1作为表达式使用前 ++ ：++i 先自增后赋值后++：i++ 先赋值后自增（–同理）

面试题：

int i=0; i=++i;	i = 0 ;
 //原理 （1）temp=i （2）i=i+1 （3）i=temp 
int i=0; i=i++; i = 1 ; 
//原理 （1）i=i+1（2）temp=i  （3）i=temp

3.2 逻辑运算符

a & b : & 叫逻辑与:规则:当 a 和 b 同时为 true ,则结果为 true，否则为 false 对于 & 第一个条件为 false，后面的条件还会判断。
a && b : && 叫短路与:规则:当 a 和 b 同时为 true ,则结果为 true,否则为 false 对于 && 第一个条件为false，后面的条件不再判断。
a | b 😐 叫逻辑或，规则:当 a 和 b，有一个为 true ,则结果为 true,否则为 false 对于 | 第一个条件为 true，后面的条件还会判断
a || b :|| 叫短路或，规则:当 a 和 b，有一个为 true ,则结果为 true,否则为 false 对于 || 第一个条件为true，后面的条件不再判断
!a :叫取反，或者非运算。当 a 为 true,则结果为 false,当 a 为 false 是，结果为 true
a^b:叫逻辑异或，当 a 和 b 不同时，则结果为 true,否则为 false

3.3 赋值运算符

特点：

运算顺序从右往左
赋值运算符的左边只能是变量，右边可以是变量、表达式
复合赋值运算符会进行类型转换

复合赋值运算符

+= a += b 等价于 a = a + b -= 、/=、*=同理

3.4 三元运算符

条件表达式  ? 表达式1 : 表达式2

运算规则：条件表达式为 true，运算后的结果是表达式1，否则结果为表达式2

表达式1和表达式2要为可以赋给接受变量的类型（或可以自动转换或者强制转换）

三元运算符可以转成 if – else 语句

3.5 运算符优先级

（），{} 等
单目运行
算术运算符
位移运算符
比较运算符
逻辑运算符
三元运算符
赋值运算符

3.6 标识符的命名规则和规范

由26个英文字母大小写，0-9，_或$组成
数字不可以开头。int 3ab = 1;
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。int totalNum = 10; int n = 90;
标识符不能包含空格。int a b = 90;
包名:多单词组成时所有字母都小写: aaa.bbb.ccc // 比如 com.hsp.crm
类名、接口名:多单词组成时，所有单词的首字母大写: XxxYyyZzz 比如: TankShotGame
变量名、方法名:多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写: xxxYyyZzz 比如: tankShotGame
常量名:所有字母都大写。多单词时每个单词用下划线连接: XXX_YY_22z 比如︰定义一个所得税率 TAX RATE

3.7 保留字

Java保留字:现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
byValue、cast、future、generic、inner、operator、outer、rest、var 、goto 、const

3.8 进制

对于整数，有四种表示方式:

二进制: 0,1，满2进1.以 Ob 或 0B 开头。
十进制: 0-9，满10进1。
八进制: 0-7，满8进1.以数字 0 开头表示。
十六进制: 0-9及 A (10)-F(15)，满16进1.以 Ox 或 OX 开头表示。此处的 A-F 不区分大小写。

四、控制结构

4.1 顺序控制

4.2 分支控制if-else

单分支 if

双分支 if-else

多分支 if-else if-else else只能有一个执行入口。如果没有 else，如果所有条件表达式都不成立则执行入口都没有，如果有所有条件表达式都不成立，则执行默认 else。

4.3 嵌套分支

规范：不要超过3层（可读性不好）

4.4 switch分支结构

关键字，表示 swtich 分支
表达式对应一个值
case常量1:当表达式的值等于常量1，就执行语句块1.
break :表示退出 swtich
如果和 case 常量1匹配，就执行语句块1，如果没有匹配，就继续匹配 case 常量2
如果一个都没有匹配上，执行default

4.4.1 细节

表达式数据类型要和 case 后的常量类型一致，或者可以自动转化相互比较的类型
switch 表达式中的返回值必须是：（byte、short、int、char、enum、String）
case 子句中的值必须是常量
default 子句可选
使用 break 跳出 switch 循环，没有程序会顺序执行 switch。

4.5 for循环控制

4.5.1 基本语法

for(循环变量初始化;循环条件;循环变量迭代){
   
			循环操作(语句);
}

循环初始值可以有多条初始化语句，但要求类型一样,并且中间用逗号隔开.循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开.

4.6 增强for循环

4.6.1 基本语法

//执行流程是 依次从nums数组中取出数据，赋给i，如果去除完毕，则退出for循环
for(int i :nums){
   

}

4.7 while循环控制

4.7.1 基本语法

循环变量初始化;
while (循环条件){
   
	循环体;
	循环变量迭代
}

while是先判断再循环

4.8 do-while循环控制

4.8.1 基本语法

循环变量初始化;
do{
   
	循环体;
	循环变量迭代;
} while(循环条件);

do-while是先执行再判断

4.9 多重循环控制

一般是两层，不超过3层

4.10 break

循环内不知循环次数，使用break，当达到条件时，终止循环

4.11 continue

continue语句用于结束本次循环,继续执行下一次循环。

五、数组（array）

数组名.length得到数组的长度

5.1 语法

第一种：

数据类型 数组名[]=new 数据类型 [大小]

第二种：

数据类型 数组名[];
数组名 = new 数组类型[大小];

第三种：

数据类型  数组名[]= {
     元素值};

默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值

数组反转

5.1.1注意

char 类型的数组，在底层代码中做了处理，可以直接打印数组名查看数组中具体元素，除了char 类型以外的数组如果想要查看数组中的具体元素则需要使用数组的工具类：Arrays

具体方式：Arrays.toString（数组名）

数组一旦创建，长度不可改变，如果想要增加/删减数组中的元素，只能先黄建一个姓长度的数组，再将原来的数复制过去。

Arrays.copyOf（复制数组，数组长度）

copyOfRange(参数1，参数2，参数3)用于完成数组的截取

参数1：要截取那个数组[原数组]

参数2：数组下标开始(包含此下标对应的元素)

参数3：数组下表结束(不包含此下标对应的元素)

5.2 排序

5.2.1冒泡排序

public class Bubbling {
   
    public static void main(String[] args) {
   
        System.out.println("请输入有几个数要冒泡");
        Scanner sc = new Scanner(System.in);
        int input=sc.nextInt();
        int[] a = new int [input];
        System.out.println("输入这"+input+"个数的数：");
        for (int i = 0; i <a.length ; i++) {
   
            a[i]=new Scanner(System.in).nextInt();
        }
        int[] b = sort.Sort(a);
        for (int i = 0; i < b.length; i++) {
   
            System.out.print(b[i] + "\t");
        }
    }
}

class sort {
   
    public static int[] Sort(int[] a) {
   
        int temp = 0;
        for (int i = 0; i < a.length - 1; i++) {
   
            for (int j = 0; j < a.length - i - 1; j++) {
   
                if (a[j] > a[j + 1]) {
   
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
            System.out.println("=========第" + (i + 1) + "轮排序=======");
            System.out.println(Arrays.toString(a));
        }
        return a;
    }
}

5.2.2 冒泡排序的优化

public class BubblingOptimize {
   
    public static void main(String[] args) {
   
        System.out.println("请输入有几个数要冒泡");
        Scanner sc = new Scanner(System.in);
        int input = sc.nextInt();
        int[] a = new int[input];
        System.out.println("输入这" + input + "个数的数：");
        for (int i = 0; i < a.length; i++) {
   
            a[i] = new Scanner(System.in).nextInt();
        }
        int[] b = sort.Sort(a);
        for (int i:b) {
   
            System.out.print(i + "\t");
        }
    }
}

class sort {
   
    public static int[] Sort(int[] a) {
   
        int temp = 0;
        int LastIndex = 0;//最后交换的下标
        int arrBoundary = a.length - 1;//边界，j到此为止
        for (int i = 0; i < a.length - 1; i++) {
   
            System.out.println("========第" + (i + 1) + "趟排序===");
            boolean flag = true;//设置标志位flag为true
            for (int j = 0; j < arrBoundary; j++) {
   
                if (a[j] > a[j + 1]) {
   
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = false;//有元素交换，所以不是有序的，变为false
                    LastIndex = j;
                }
                System.out.println("第" + (j + 1) + "轮排序为：" + Arrays.toString(a));
            }
            arrBoundary = LastIndex;
            if (flag) {
   //当标志位为true时，证明没有元素交换，则跳过此循环
                break;
            }
        }
        return a;
    }
}

5.3 查找

5.3.1 二分法（折半查找）

public class Dichotomy {
   
    public static void main(String[] args) {
   
        int arr[] = {
   88, 99, 46, 75, 65, 32, 45, 67, 75};
        System.out.println("输入要查找的数");
        int input = new Scanner(System.in).nextInt();
        Arrays.sort(arr);
        int min = 0;
        int max = arr.length - 1;
        while (min <= max) {
   
            int mid = (min + max) / 2;
            if (input == arr[mid]) {
   
                System.out.println("找到了");
                return;
            } else if (input > arr[mid]) {
   
                min = mid + 1;
            } else if (input < arr[mid]) {
   
                max = mid - 1;
            }
        }
        System.out.println("没找到！");
    }
}

5.3.2 差值查找

public class InterpolationIookup {
   //插值查找法
    public static void main(String[] args) {
   
        int arr[] = {
   88, 99, 46, 75, 65, 32, 45, 67, 75};
        System.out.println("输入要查找的数");
        int input = new Scanner(System.in).nextInt();
        Arrays.sort(arr);
        int min = 0;
        int max = arr.length - 1;
        System.out.println(interpolation(arr,input,min,max));
    }
    private static int interpolation