笔记字体颜色说明

黑色：日期，表格

蓝色：大标题

红色：说明，例子，细节标题

粉色：细节，需要注意的地方

紫色：代码和运算之类的

注意：此说明为一般情况下都是这样，但可能会出现特殊情况那就是我懒不想改༼ •̀ ₒ •́ ༽

10.31

基本数据类型转换

数据类型按精度（大小）排序

char-int-long-float-double

byte-short-int-long-float-double

例子

int a='a';

double d=80;

细节

11.2

强行类型转换

细节

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

例子

11.3

算数运算符

运算符	运算	范例	结果
+	正号	+1	1
-	负号	b=11，-b	-11
+	加	9+9	18
-	减	9-8	1
*	乘	7*8	56
/	除	9/9	1
%	取余（取模）	20%8	4
++ ++	自增（前）：先运算后取值 自增（后）：先取值后运算	a=2;b=++a; a=2;b=a++	a=3,b=3 a=3,b=2
-- --	自减（前）：先运算后取值 自减（后）：先取值后运算	a=2;b=--a; a=2;b=a--;	a=1,b=1 a=1,b=2
+	字符串相加	"w"+"h"	"wh"

例子

例子

例子

• 基本赋值运算符：=
• 复合赋值运算符：+=，-=，*=，/=，%=

例子

a+=b;//(等于a=a+b；)

细节

• 运算顺序从右往左 int num=【a+b+c】；//先计算（a+b+c）再赋给num；
• 赋值运算符的左边 只能是变量，右边可以是变量、表达式、常量值

int num=20; //常量值 int nmu2=7*8-8;//表达式 int num3=a;//变量

• 复合赋值运算符等价于下面的效果

a+=3等于a=a+3;

• 复合赋值运算符会进行类型转换（包括强制转换）

byte b=2; b+=3;//等价于b=(byte)（b+2）； b++;//b=（byte）（b+1）；

三元运算符

基本语法

• 条件表达式？表达式1：表达式2；
• 1.如果条件表达式为ture，运算后的结果是表达式1；
• 2.如果条件表达式为false，运算后的结果是表达式2；

例子

int a=10;

int b=99;

int result=a>b?a++:b--;

细节

• 1.表达式1和表达式2要为赋给接收变量的类型(或可以自动转换)
• 2.三元运算符可以转成if--else

int res=a>b? a++:b--;

if(a>b)res=a++;

else res=b--;

运算符的优先级

	. () {} ; ,
R——>L	++ -- ~ 　！（data type）
L——R	*　　　　　/　　　　％
L——R	+　　　　-
L——R	＜＜　　　　＞＞　　　＞＞＞　　　位移
L——R	＜　　＞　　＜＝　　＞＝　　　 instanceof
L——R	== ！=
L——R	&
L——R	^
L——R	|
L——R	&&
L——R	||
L——R	? :
R——L	= *= /= %=
	+= -= <<= >>=
	>>>= &= ^= |=

键盘输入

使用说明

例子

进制

• 二进制：0，1 满2进1,以0b或0B开头
• 十进制：0-9，满10进1
• 八进制：0-7，满8进1.以数字0开头表示
• 十六进制：0-9以及A（10）-F（15），满16进1.以0x或0X开头表示。此处的A-F不区分大小写

例子

int n1=ob1010；//二进制

int n2=1010;//十进制

int n3=01010;//八进制

int n4=0x10101//十六进制

• 二转十（八转十，十六转十同理，把二换成八或十六）

0b1010=10//运算过程1*2^3+0*2^2+1*2^1+0*2^0

• 十转二（十转八，十转十六同理，把二换成八或十六）
• 10=0b（1010）（以下为过程，结果：下面的高位到上面的低位，鼠标好难画qaq）

• 二转八（二转十六为4位一组）

0b1010=（012）;=001010分开算(001)=1，（010）=2；=12//3位一组转八进制数

• 八转二（十六转二同理）

（012）=0b1010；12=1=（001）2=（010）=001010=1010

位运算

源码 反码 补码

1. 二进制的最高位是符号位：0代表正数，1代表负数
2. 正数的源码 反码 补码都是一样的
3. 负数的反码=它的源码符号位不变，其他位取反
4. 负数的补码=它的反码+1负数的反码=负数的补码-1
5. 0的反码 补码都是0
6. java没有无符号数，换言之，java中的数都是有符号的
7. 当计算机运算的时候，都是以补码的方式运算的
8. 当我们看运算结果的时候，要看他的源码

位运算符

• java中有7个运算符（&、|、^、~、>>、<<、>>>）
• 分别是按位与&、按位或|、按位异或^、按位取反~，它们的运算规则是：
• 按位与& ：两位全为1，结果为1，否则为0
• 按位或| ：两位有一个为1，结果为1，否则为0
• 按位异或 ^ ：两位一个为0，一个为1，结果为1，否则为0
• 按位取反~: 0->1 1->
• 算数右移>>：低位溢出，符号位不变，并用符号位补溢出的高位
• 算数左移<<:符号位不变，低位补0
• >>>逻辑右移/无符号右移，低位溢出，高位补0

例子

11.4

分支控制（if，else，switch）

基本语法

嵌套分支

介绍

在一个分支中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支外面的分支结构称为外层分支。规范包括第一个if不要超过4层，（可读性不好）

基本语法

switch分支结构

基本语法

switch（表达式）{

case常量：

语句块1；

break;

case常量2：

语句块2;

break;

.....

case常量n：

语句块n:

break;

说明

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

细节

1. 表达式数据类型，应和case后的常量类型一致，或者可以自动转换成可以相互比较的类型，比如输入的是字符。而且常量是int
2. switch（表达式）中表达式的返回值必须是（byte,short,int,char,enum,String）
3. case字句中的值必须是常量，而不能是变量
4. default字句是可选的，当没有匹配的case时，执行default
5. break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾

for循环

基本语法

• for（循环变量初始化；循环条件；循环变量迭代）{
• 循环操作（可以多个语句）；
• }
• 或
• 循环变量初始化；
• for（循环条件；）{
• 循环操作（可以多个语句）；
• 循环变量迭代
• }

细节

1. 循环条件是返回一个布尔值的表达式
2. for（；循环判断条件；）中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略。
3. 循环初始值可以是多条初始化语句，但要求类型一样，并且逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

例子

11.5

while循环控制

基本语法

循环变量初始化；

while（循环条件）{

循环体（语句）；

循环变量迭代；

}

说明

• while循环也有四要素
• 只是四要素放置的位置，不一样。

例子

do...while循环控制

基本语法

循环变量初始化；

do{

循环体（语句）；

循环控制迭代；

}while（循环条件）；

说明

• do while是关键字
• 也是循环四要素，只是位置不一样
• 先执行，后判断，也就是说，一定会执行一次
• 最后 有一个分号；
• while和do.....while区别为do。。while先直接执行一次语句

多重循环控制

基本语法例子

for（int i=0；i<2;i++）{

for(int j=0; j<3;j++){

System.out.println("i="+i+"j="+j);

}

}

循环题目在java题目文章里

跳转控制语句-break

基本语法

{ .......

break;

.........

}

例子

for(int i=0;i<10;i++){
   if(i==3){break;}
   System.out.println("ok"+i);
}

细节

break语句现在在多层循环的语句块中时，可以通过标签指明要终止的是哪一层语句块

标签的基本使用

label1：{.............

label2 : {.......

label3: {..........

break label2;

..................

}

}

}

1. break语句可以指定退出哪层
2. label1是标签，由程序员指定。（名字可以自己定）
3. break后指定到哪个label就退出到哪里
4. 在实际开发中，尽量不要使用标签。（可读性会变差）
5. 如果没有指定break，默认退出最近的循环体

控制跳转语句—continue

基本介绍

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

continue语句出现在多层嵌套的循环语句体中，可以通过标签指名要跳过的是哪一层循环，这个可以和前面的标签的使用的规则一样。

基本语法

{........

continue;

.........

}

例子

int i=1;
while(i<=4){
i++;
if(i==2){
   continue;
  }
System.out.println("i="+i);
}

跳转控制语句-return

介绍

return写在mian方法，退出程序.....

例子

for（int =1；i<=5;i++){
     if(i==3){
System.out.println("祈曦"+i)；
return;
}
System.out.println("Hello World");
}
rintln("go on..");

11.9

数组

数组介绍

数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。

既：数据就是一组数据

数组的使用

使用方法1-动态初始化1

数组的定义

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

int a[]=new int[5];//创建了一个数组，名字a，存放5个int

例子

int w[]=new int[];

使用方法2-动态初始化2

先声明数组

语法：数据类型 数组名[]；也可以 数据类型[] 数组名；

int a[];或者 int []a；

创建数组

语法：数组名=new 数据类型[大小]；

a=new int[];

例子

int a[];

a=new int[];

使用方法3-静态初始化

语法：数据类型 数组名[]={元素值，元素值....}

int a[]={5,6,2,5,6,8,5,50}

细节

1. 数组是多个相同类型的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值int 0，short 0，long 0，float 0.0,double 0.0, char \u0000,boolean false, String null
4. 使用数组的步骤 1.声明数组并开辟空间 2.给数组各个元素赋值3使用数组
5. 数组的下标是从0开始的。
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如int[]arr=new int[5]；则有效下标为0-4
7. 数组属引用类型，数组型数据是对象（object）

数组赋值机制

• 基本数据类型赋值，这个值就是具体的数据，而且互相不影响。int n1=2；int n2=n1;
• 数组在默认情况下引用传递，赋的值是地址。如

• 这样的话改变i2 i1也会被改变

数组拷贝

将int[] arr1={10,20,30}；拷贝到arr2数组

例子

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[] arr1={10,20,30};
			int [] arr2=new int[arr1.length];//定义一个新的数组  大小和arr1一样
			for(int i=0;i<arr1.length;i++){
				arr2[i]=arr1[i];//把arr1的值拷贝给arr2
			}
			arr1[2]=50;//把50赋值给arr2[2]
		for(int w=0;w<arr1.length;w++){
			System.out.print(arr1[w]);
			}//输出为10 20 50
		System.out.println("");
		for(int h=0;h<arr2.length;h++){
			System.out.print(arr2[h]);
			}	//输出为 10 20 30
		}
	}

数组反转

方法1

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			int[]  w={10,20,30,40,50,60};
			/*w[0]和w[5]转换   
			 * w[1]-w[4]
			 * w[2]-w[3]
			 * 一共三次所以w.length/2
			 * w[i]=012  w[arr.length-1-i]
			 */
			int e=0;
			for(int i=0;i<w.length/2;i++){
				e=w[i];
				w[i]=w[w.length-1-i];
				w[w.length-1-i]=e;
			}
			for(int o=0;o<w.length;o++){
				System.out.println(w[o]);
			}
		}
	}

方法2

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			int[]  w={10,20,30,40,50,60};
			int[] w2=new int[w.length];
			for(int p=w.length-1,u=0;p>=0;p--,u++){
				w2[u]=w[p];
				
			}
			
			for(int r=0;r<w2.length;r++){
			System.out.print(w2[r]+" ");
			}w=w2;//把w2地址给w
			for(int t=0;t<w.length;t++){
				System.out.print(w[t]+" ");}//输出结果60 50 40 30 20 10
		}
	}

数组扩容

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
		int[] hw={1,2,3,4};//定义数组的元素
		
		abc:do{
			int[] ww=new int[hw.length+1];//定义ww数组让他比hw数组大一个元素的空间
			
		for(int i=0;i<hw.length;i++){
			ww[i]=hw[i];//把hw的元素拷贝给ww
		}
		System.out.println("请输入你想添加的数");
		int hu=ow.nextInt();//定义一个键盘让用户可以自己添加想添加的数
		ww[ww.length-1]=hu;
		hw=ww;//把ww的数组地址给hw这样hw就成功扩容
		System.out.println("以下为现在hw数组的元素");
		
		for(int j=0;j<hw.length;j++){//查看 现有元素
		System.out.print(hw[j]+" ");
			}
		
		System.out.println(" ");
		System.out.println("是否继续添加 y/n");//询问是否要继续扩容
		char lp=ow.next().charAt(0);
		
	if(lp=='n'){
			break;//退出循环
		
			}
		}while(true);//继续信号
		System.out.println("添加结束");	
	}
}

数组删减

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
		int[] hw={1,2,3,4};//定义数组的元素
		int l=0;
		abc:do{
			int[] ww=new int[hw.length-1];
			
		for(int i=0;i<hw.length-1;i++){
			ww[i]=hw[i];
		}		
		hw=ww;
		l++;
		System.out.println("以下为现在hw数组的元素");
		
		for(int j=0;j<hw.length;j++){//查看 现有元素
		System.out.print(hw[j]+" ");
			}
		if(l==4-1){
		System.out.println("只剩下一个元素了，你不能再继续删减了");
		break abc;
		}
		System.out.println(" ");
		System.out.println("是否继续删减 y/n");//询问是否要继续扩容
		char lp=ow.next().charAt(0);
		
	if(lp=='n'){
			break;//退出循环
		
			}
		}while(true);
		System.out.println("删除结束");	
	}
}
		

				
			

排序的介绍

排序是将一群数据，依指定的顺序进行排序的过程。

排序的分类：

1.内部排序：

指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）；

2.外部排序法：

数据量过大，无法全部加载到内存中。需要借助外部储存进行排序。包括（合并排序法和直接合并排序法）。

冒泡排序法

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int o=0;//用于储存元素
			int[] w={60,20,50,30,90};//定义一个静态数组
		for(int k=0;k<w.length;k++){	//换w.length次才能全部排序完
			for(int i=0;i<w.length-1-k;i++){//比较几次才能比较完
				if(w[i]>w[i+1]){//如果第一个元素比第二个元素大，那么让两个元素互换位置
					o=w[i];
					w[i]=w[i+1];
					w[i+1]=o;
					}
			}

		}
			for(int l=0;l<w.length;l++){//看效果
				System.out.println(w[l]);	//输出为	20  30  550  60  90		
		
				}		
	
	}
}

查找

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			String[] name={"英梨梨","和泉纱雾","香风智乃","四糸乃"};
			System.out.println("请输入老婆名字");
			String name1=ow.next();//键盘输入
			int p=-1;
			for(int i=0;i<name.length;i++){
				if(name1.equals(name[i])){//equals为 判断字符串
					System.out.println("名字正确");
					p=i;//查找到了p保存i的值
					break;
				}
			}
			if(p==-1){//p==-1说明没有查找到
				System.out.println("没有找到");
			}
	}
}

二维数组

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] op={{1,2,3,4},
					    {5,6,7,8}};
			for(int p=0;p<op.length;p++){//访问一维数组
				for(int u=0;u<op[p].length;u++){//访问一维数组的各个元素
						System.out.print(op[p][u]+" ");
				}
				System.out.println("");//换行
			}
	}	
}

二维数组的使用

使用方法1：动态初始化

语法:类型[][] 数组名=new 类型[大小][大小]

比如int a[][]=new int[2][3]

使用方法2：动态初始化

先声明：类型 数组名[][]；

再定义（开辟空间） 数组名=new 类型[][]

赋值（有默认值，比如int 类型就是0）

使用方法3：数列不确定

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] a=new int[3][];
			for(int i=0;i<a.length;i++){
				a[i]=new int[i+1];//new给一维数组开辟空间
				for(int j=0;j<a[i].length;j++){
					a[i][j]=i+1;//给一维数组赋值
				}
				
			}
			for(int i=0;i<a.length;i++){//看结果
				for(int j=0;j<a[i].length;j++){
					System.out.print(a[i][j]+" ");//输出为1     22    333		 
				}
			System.out.println("");//换行
			}
		}	
}

使用方法4：静态初始化

定义 类型 数组名[][]={{值1，值2},{值1，值2},{值1，值2}}

杨辉三角形

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] a=new int[10][];
			for(int i=0;i<a.length;i++){
				a[i]=new int[i+1];//new给一维数组开辟空间
				for(int j=0;j<a[i].length;j++){
					if(j==0||j==a[i].length-1){
						a[i][j]=1;//最左边和最右边都为1；
					}else{
						a[i][j]=a[i-1][j]+a[i-1][j-1];
						/*中间为上面的数加上面左边的一个数
						 * 比如
						 * 1
						 * 11
						 * 121
						 * 1331
						 * 14641
						 * 
						 * 2=1+1； 3=2+1  4=3+1  6=3+3
						 */
					}
					
				}
				
			}
			for(int i=0;i<a.length;i++){//看结果
				for(int j=0;j<a[i].length;j++){
					System.out.print(a[i][j]+" ");//输出为1     22    333		 
				}
			System.out.println("");//换行
			}
		}	
}

二维数组的细节

1.一维数组的声明方式有：

int[] x或者int x[]

2.二维数组的声明方式有：

int[][] y或者 int[] y[] 或者 int y[][]

3.二维数组实际上是由多个一维数组组成的，他的各个一维数组的长度可以相同。也可以不同。比如：mao[][] 是一个二维数组

mao[][]= {{1,2}，{3,4,5}}

由mao[0]是一个含有2个元素的一维数组，mao[1]是一含有三个元素的一维数组构成的，我们也称为列数不等的二维数组。