JAVA语言基础组成
-
关键字:JAVA中已经定义好的有意义的单词
-
标识符:自定义的名称
规则:
a. 不能以数字开头
b. 不能是关键字
c. 严格区分大小写,取名尽量有意义 -
注释
作用:1.注解说明 2.调试
类型:
1.// 单行注释
2./**/ 多行注释多行注释不能嵌套多行注释(多行注释不能嵌套多行注释)
3./***/ 文档注释:java特有,通过javadoc.exe放在一个网页文件中生成说明书
-
书写规范:
/*
需求:
思路:
步骤:(思路和步骤可以合并)
*/
代码 -
常量
不能改变的数值
分类:
1.整数
2.小数
3.boolean型常量
4.字符常量
5.字符串常量
6.null常量-------只有引用数据类型可以使用
进制:
二进制: 满二进一 由0,1组成
十进制: 满十进一 由0~9 十个数字组成
八进制: 满八进一 由0~7 八个数字组成 以0开头
十六进制:满十六进一 由09十个数字和AF六个字母组成 以0x开头
负数:
凡是负数,二进制最高位一定为1
转换方式:正数二进制取反,+1负数转换回正数:-1.取反
例如:0000 0110 6
取反
1111 1001
+1
1111 1010 -6 -
变量
内存中的一个存储区域,数据不确定时,使用变量,用于存放同一类型的常量,可以重复使用
该区域有自己的数据类型和名称(数据类型+名称)
该区域可以存储同一类型范围内不断变化的数据(数据)
定义格式:
数据类型 变量名=初始化值
使用注意:
1.变量的作用范围(一对{}内有效)
2.初始化值 -
数据类型
基本数据类型
1.数值型
整数类型:byte ------ 1个字节(-128~127)
short ------ 2个字节
int ------- 4个字节(默认)
long ------ 8个字节(数尾带l)
浮点数类型:float -----4个字节(数尾带f)
double-----8个字节(默认)
2.字符型:char--------4个字节
3.布尔型:Boolean----只有true和false两个值
引用数据类型
1.类(class)
2.接口(interface)
3.数组([])
自动类型提升:(小转大)占据内存空间小的类型转换为占据空间大的类型
强制类型转换:(大转小)可能损失精度
例如:byte b=4;
byte a=5;
byte c=9;
a=b+c; /两个byte型数据相加,和可能大于byte最大存储/
int x;
x=b+x; /*正确 int4个字节大于byte */
总结:赋值语句右边不确定(即为变量),若右边大于左边,无法赋值;若右边小于左边,可以赋值======左边装不下右边,不能赋值;装得下,可以赋值。拓展:
I. 所有国家的编码表(美国:ASCII 中国:GBK)都是用Unicode(国际编码表)完成的
II.二个二进制数相加,结果为负数(要进一) -
运算符
8.1 算术运算符:+,-,,/,%,,++,–
+:1.加法符号
2.连接符
("5+5="5+5)
结果:5+5=55
步骤:1.5+5=5 2.5+5=55
%:取余(模运算)
涉及负数,符号与被模数(前一个)一致
8.2 赋值运算符:=,+=,-=,=,/=,%=
例1:int a,b,c;
a=b=c;
这样写是可以的
例2:short a=3;------------赋值,若不够,自动转换
s+=5;-----------------赋值,若不够,自动转换
s=s+3;----------------无法赋值,左边s不确定,若很大,会超出范围
8.3 转义字符:通过\来转变后面字母或字符的含义
\r:按下回车键
\n:换行
\b:退格(相当于backspace)
\t:制表符(相当于tab)
\:反斜杠
":双引号8.4 比较运算符:==(等等于),!=(不等于),<,>,<=,>= 8.5 逻辑运算符 &:与 false & true = false(只要有一个false就是false) |:或 false | true = true (只要有一个true就是true) ^:异或 false ^ true = true false ^ false= false(相同为假,不同为真) !:非 !true = false &&:双与(短路) false && true=false ||:双或(短路) false || true=true &与&&区别: &:无论左边是true还是false,右边都运算 &&:左边是false,右边不用运算,结果为false |与||区别: |:两边都参与运算 ||:左边为true时,右边不用运算,结果为true 8.6 位运算符 <<:左移 移后结果=原数*2^移位数 3<<2=12 <====>3*2*2=12 >>:右移 移后结果=原数/2^移位数 3>>1=1 <====>3/2=1 >>>:无符号右移 以后结果 同右移 3>>>1=1 <====>3/2=1 (>>与>>>区别:>>在移动过程中,最高位是0,就补0,最高位是1,就补1;>>>只补0) &:与 |:或 ^:异或 原数异或同一个数两次,结果为原数(可用于加密,异或的数是密钥) ~:反码 ~6=-7 某数的反码=某数的负数-1(因为负数=某数取反+1) 8.7 三元运算符 格式:(条件表达式)?表达式1:表达式2; 结果:条件为true,结果为表达式1 条件为false,结果为表达式2 优点:可用于简化if else语句 缺点:运算完必须有一个结果
-
程序流程控制
9.1 判断结构 if语句(适合判断区间和布尔型) 三种格式: 1. if(条件表达式) { 执行语句; } 2. if(条件表达式) { 执行语句; } else { 执行语句; } 3. if(条件表达式) { 执行语句; } else if { 执行语句; } else if { 执行语句; } …… else { 执行语句; } 练习: /* 需求:输入数字,输出对应的星期 思路:1.定义一个具有该功能的函数,其中用一个变量存储该数,if语句判断是否符合条件 2.符合输出对应的值,不符合输出对应提示 3.在主函数中调用 */ class PrintWeek { public static void main(String[] args) { int x=3; printWeek(x); } /* 1.该函数无返回值 2.输入的数字为未知 */ public static void printWeek(int x) { if(x<1 || x>7) System.out.println("请输入1~7的数字"); else print(x); } public static void print(int x) { if(x==1) System.out.println(x+"对应的星期是Monday"); else if(x==2) System.out.println(x+"对应的星期是Tuesday"); else if(x==3) System.out.println(x+"对应的星期是Wednesday"); else if(x==4) System.out.println(x+"对应的星期是Thursday"); else if(x==5) System.out.println(x+"对应的星期是Friday"); else if(x==6) System.out.println(x+"对应的星期是Saturday"); else System.out.println(x+"对应的星期是Sunday"); } } /* 需求:输入月份,输出对应季度 思路:1.定义一个具有该功能的函数,其中用一个变量存储该数,if语句进行判断 2.符合输出对应的值,不符合输出对应提示 3.在主函数中调用 */ class PrintSeason { public static void main(String[] args) { int x=3; printSeason(x); } /* 1.该函数无返回值 2.输入的月份为未知 */ public static void printSeason(int x) { if(x<1 ||x>12) System.out.println("请输入月份"); else if(x==2 || x==3 ||x==4) System.out.println(x+"对应的季度是春季"); else if(x==5||x==6||x==7) System.out.println(x+"对应的季度是夏季"); else if(x==8||x==9||x==10) System.out.println(x+"对应的季度是秋季"); else System.out.println(x+"对应的季度是冬季"); } } 9.2 选择结构 switch语句(适合具体数值且不多的情况,必须符合byte,short,int,char中的一种) 格式: switch(表达式) { case 取值2: 执行语句; break; case 取值1: 执行语句; break; case 取值3: 执行语句; break; …… default: 执行语句; break; } 注:1. case和default无序,可调换,但default一定最后执行 2. 若选择的取值没有break,会不在判断直接执行语句,直至遇到break后}退出 练习: /* 需求:输入数字,输出对应的星期 思路:1.定义一个具有该功能的函数,其中用一个变量存储该数,switch语句选择 2.符合输出对应的值,不符合输出对应提示 3.在主函数中调用 */ class PrintWeek { public static void main(String[] args) { int x=3; printWeek(x); } /* 1.该函数无返回值 2.输入的数字为未知 */ public static void printWeek(int x) { switch(x) { case 1: System.out.println(x+"对应Monday"); break; case 2: System.out.println(x+"对应Tuesday"); break; case 3: System.out.println(x+"对应Wednesday"); break; case 4: System.out.println(x+"对应Thursday"); break; case 5: System.out.println(x+"对应Friday"); break; case 6: System.out.println(x+"对应Saturday"); case 7: System.out.println(x+"对应Sunday"); break; default: System.out.println("请输入1~7内的数字"); break; } } } /* 需求:输入月份,输出对应季度 思路:1.定义一个具有该功能的函数,其中用一个变量存储月份,switch语句进行选择 2.符合输出对应的值,不符合输出对应提示 3.在主函数中调用 */ class PrintSeason { public static void main(String[] args) { int x=3; printSeason(x); } /* 1.该函数无返回值 2.输入的月份为未知 */ public static void printSeason(int x) { switch(x) { case 2: case 3: case 4: System.out.println(x+"对应春季"); break; case 5: case 6: case 7: System.out.println(x+"对应夏季"); break; case 8: case 9: case 10: System.out.println(x+"对应秋季"); break; case 11: case 12: case 1: System.out.println(x+"对应冬季"); break; default: System.out.println("请输入月份"); break; } } } 9.3 循环结构(当对某些语句执行很多次时,使用循环语句):while,do while ,for 9.3.1 while语句格式: while(条件表达式) { 执行语句; } 练习: /* 需求:求1~100之间6的倍数个数,用while结构 思路:1.通过while循环遍历,找出6的倍数 2.定义变量计数,累计6的倍数个数 */ class FindNum_6 { public static void main(String[] args) { int x=1,count=0; while(x<=100) { if(x%6==0) count++; x++; } System.out.println(count); } } 9.3.2 do while 语句格式 do { 执行语句; }while(条件表达式); 特点:无论条件是否满足,循环体至少执行一次 9.3.3 for语句格式 (w:)for(初始化表达式;循环条件表达式;循环后的操作表达式) { 执行语句; } 注:1.w;标记循环,合法名字即可 2.初始化表达式和循环后的操作表达式只要是合法的表达式就可以,若存在多个,可用“,”隔开,循环条件表达式结果必须是真或假,条件为假,循环结束 for与while区别: for中的变量(只为循环增量,控制循环次数)只能在for的{}中使用,超出无效 while在之前定义的变量可以一直使用 (for和while可以进行互换,如果需要定义循环增量,用for更为合适,因为用完自动消失,内存小) 拓展: 1.循环语句的嵌套(打印多行多列的图形) * ** *** 尖朝上:改变条件,让条件随外循环改变 **** 尖朝下:改变初始化,让初始化值随外循环改变 ***** 2. 无限循环的最简单表达形式 for(;;){} while(true){} 3.累加思想(变量+循环) 原理:通过变量记录住每次循环的结果 通过循环的形式进行累加的动作 4.计数器思想(变量+循环) 原理:通过一个变量记录住数据的状态变化 count++或count-- 通过循环完成 5.System.out.println(); 该句只有一个作用:换行 练习: /* 需求:求1~100之间6的倍数出现的次数 思路:1.for循环遍历1~100,找出6的倍数 2.定义一个变量,通过计数记录6的倍数出现的次数 */ class FindNum { public static int Find() { int count=0; for(int x=1;x<=100;x++) if(x%6==0) count++; return count; } public static void main(String[] args) { int x=Find(); System.out.println(x); } } /* for的可行格式+ */ class Demo { public static void main(String[] args) { int x=1; for(System.out.println("a");x<3;System.out.println("c"),x++) { System.out.println("d"); } } } /* 需求:获取1~10的和并打印,用for循环 思路:1.使用for遍历1~10 2.使用sum变量累计和 */ class GetSum { //定义一个功能函数,返回值类型为int,无未知数 public static int printSum() { int sum=0; for(int x=1;x<=10;x++) sum+=x; return sum; } public static void main(String[] args) { int x=printSum(); System.out.println(x); } } /* 需求:打印以下图形 ***** **** *** ** * 思路:有行有列,用循环嵌套 */ class ForFor { public static void main(String[] args) { for(int x=1;x<=5;x++) { for(int y=x;y<=5;y++) System.out.print("*"); System.out.println(); } } } /* 需求:打印九九乘法表 思路:1.定义一个功能函数,使用循环嵌套 2.外循环控制行,内循环控制列 */ class Print99 { public static void print() { for(int x=1;x<=9;x++) { for(int y=1;y<=x;y++) System.out.print(y+"*"+x+"="+x*y+"\t"); System.out.println(); } } public static void main(String[] args) { print(); } } /* 需求:打印矩形 思路:1.使用for循环嵌套,外循环表示行,内循环表示列 2.使用两变量row和col */ class JuXing { public static void print(int row,int col) { for(int x=1;x<=row;x++) { for(int y=1;y<=col;y++) System.out.print("*"); System.out.println(); } } public static void main(String[] args) { print(4,4); } } /* 需求:打印以下图形 * * * * * * * * * * * * * * * 思路:可以看成是一个倒三角和一个正三角,----* 正三角每次打印(*+空格)就可以变成图中图形 */ ---** class PrintTri --*** { -**** public static void print() { for(int x=0;x<5;x++) { for(int y=x;y<5;y++) System.out.print(" "); for(int z=0;z<=x;z++) System.out.print("* "); System.out.println(); } } public static void main(String[] args) { print(); } } 9.4 其他流程控制语句 9.4.1 break(跳出):应用于选择结构和循环结构 9.4.2 continue:结束本次循环,继续下一次循环 (相同点:单独存在时,下面的任何语句都无法执行)
-
函数(方法)
最小功能单位
10.1 函数的定义:函数就是定义在类中的具有特定功能的一段独立小程序
格式:
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2……)
{
执行语句;
return返回值;
}
(参数是有顺序的,参数名随意;若无返回值类型写void)
修饰符:(public)static
参数类型:形参的数据类型
形式参数:一个变量,用于存储调用函数是传递给函数的实参
实际参数:传递给形参的具体数值
return:用于结束函数
返回值:返回给调用者
使用:函数名(实参)
如:int x=函数名(实参);
10.2 函数的特点
1. 定义函数可以将功能进行封装
2.便于对该功能进行复用,提高代码的复用性
3.函数只有被调用才会被执行
4.若返回值类型为void,return语句在最后,return可以省略(因为系统会自动加)
5.函数中只能调用函数,不能定义函数(特别注意main函数)
6.定义函数时,函数的结果应该返回给调用者,交由调用者处理
10.3 函数的应用
定义函数原则:完成相应功能,不能定义多余功能
1.函数是一个独立的功能,先明确该功能的运算结果(返回值类型)
2.明确定义该功能过程中是否需要未知的内容(即调用者基于的内容)参与运算(列表参数即变量)
注:返回值为void(具有内部直接打印功能)的函数不能在主函数打印,只能直接调用
如:public static void get(int a,int b)
{
System.out.println(a+b);------完成了两个功能:加法运算+打印,定义了多余的功能
return;
}
主函数内:
System.out.println(get(3,5));-----false
get(3,5);------true
10.4 函数的重载(overload)
1.概念:在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或参数类型不同即可(与参数名无关,因为可以自定义)
2.特点:与返回值类型无关,只与参数列表有关
3.优点:便于阅读,优化了程序设计
4.什么时候用:当定义的多个函数功能相同,参与运算的未知内容不同,这时就定义一个函数名称以表示功能,方便阅读,通过参数列表的不同来区别多个同名函数
5.小练习:
判断是否重载
原函数:public static void show(int a,char b,double c){}
判断函数:public static double show(int x,char y,double z){}
结果:没有重载,该函数不可以和原函数同时存在与一个类中,因为返回值类型不同,JVM无法判断返回值类型 -
数组
11.1数组的定义
1.概念:同一种类型数据的集合,其实数组就是一个容器
2.好处:可以自动给数组中的元素从0开始编号,方便操作这些元素
3.格式:
I.元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
元素类型:存储元素类型
new:生成实体
例:int[] arr = new int[5];
II.元素类型[] 数组名 = new 元素类型[]{元素,元素,元素……};
例:int[] arr = new int[]{3,4,3,1,5};int[] arr = {3,4,3,1,5}; 4.拓展:ArrayIndexoutofBoundException:操作数组时,访问到了数组中不存在的角标 NullPointerException:空指针异常,即引用不再指向数组实体,还在用该引用操作实体 例:arry=null; System.out.println(arr[1]); 11.2 内存结构 JAVA程序在运行时,共在内存划分了5片区域进行数据的处理和存储。(每片区域都有特定的处理数据方式和内存管理方式) 栈内存,堆内存,方法区,本地方法区,寄存器 1、栈内存(存局部变量) 用于存储局部变量,当数据使用完吗,所占空间自动释放。 局部变量:定义在方法中的变量 定义在方法中的参数 定义在for循环中的变量 2、堆内存(存实体) I.数组和对象,通过new建立的实例兜存放在堆内存中 II.每一个实体都有内存地址值 III.实体中的变量都有默认的初始化值 int:0 float:0.0f double:0.0 Boolean:false IV.实体不再被使用,会在不确定的时间内被垃圾回收器回收(不一定马上执行) x=null; x不再指向数组,而是为空 3、拓展:两个引用数据类型指向同一实体时,一个导致实体改变,另一个是改变后的值,一个为null,实体不为垃圾,因为另一个引用指向该实体 例:int[] x = new int[3];-------将实体的首地址赋值给x引用 int[] y = x;----------------将x指向的实体首地址付给y(即x,y指向同一实体) y[1] = 89;---------------y[1]改变,x[1]=89 x = null;-------------因为y引用也指向该实体,所以无垃圾 11.3 数组的操作(操作前打印一次,操作,操作后打印一次) 11.3.1 获取数组中的元素(通常用到遍历)-------常用 数组名称.length------直接获取数组元素个数(即数组长度) /* 需求:获取数组中的元素 思路:通过for循环遍历,同时打印 */ class GetNum { public static void get(int[] arr) { System.out.print("["); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.print(arr[arr.length-1]+"]"); } public static void main(String[] args) { int[] arr=new int[]{4,6,6,1,4,6}; get(arr); } } 11.3.2 获取数组最大最小值 /* 需求:获取给定数组的最大最小值 思路:1.通过for循环遍历, 2.定义一个变量max/min,将a[0]赋给变量,然后在循环过程中逐个比较 */ class GetMaxMin { public static int GetMax(int[] arr) { int max=arr[0]; for(int x=0;x<arr.length;x++) { if(max<arr[x]) max=arr[x]; } return max; } public static int GetMin(int[] arr) { int min=arr[0]; for(int x=0;x<arr.length;x++) { min=arr[0]; if(min>arr[x]) min=arr[x]; } return min; } public static void main(String[] args) { int[] arr=new int[]{4,2,56,7,2,4,7,9}; int x=GetMax(arr); System.out.println(x); int y=GetMin(arr); System.out.println(y); } } 11.3.3 给数组排序(希尔排序最快:三层循环+位运算) 1.选择排序:内循环结束一次,最值出现在头角标上(先确定arr[0]) /* 需求:对数组进行选择排序,用位运算交换 思路:1、通过for循环嵌套控制排序过程,再将排好的数组打印出来 2.外循环控制循环次数,注意最大值为(arr.length-1),因为最后一个元素不需要排序 3.内循环通过累加使元素与其后面的元素挨个比较 4.若元素比后一元素大,交换 */ class SelectSort { public static void selectSort(int[] arr) { for(int x=0;x<arr.length-1;x++) { for(int y=x+1;y<arr.length;y++) { if(arr[x]>arr[y]) { arr[x]=arr[x]^arr[y]; arr[y]=arr[x]^arr[y]; arr[x]=arr[x]^arr[y]; } } } } public static void printArray(int[] arr) { System.out.print("["); for(int x=0;x<arr.length;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void main(String[] args) { int[] arr={3,6,1,6,3,2,1,4}; printArray(arr); selectSort(arr); printArray(arr); } } -------------------------------------------------------------------------------------- /* 把代码封装: */ class SelectSort { public static void selectSort(int[] arr) { for(int x=0;x<arr.length-1;x++) { for(int y=x+1;y<arr.length;y++) { if(arr[x]>arr[y]) { swap_wei(arr,x,y); } } } } public static void printArray(int[] arr) { System.out.print("["); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void swap_wei(int[] arr,int a,int b) { arr[a]=arr[a]^arr[b]; arr[b]=arr[a]^arr[b]; arr[a]=arr[a]^arr[b]; } public static void swap_temp(int[] arr,int a,int b) { int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; } public static void main(String[] args) { int[] arr={3,6,1,6,3,2,1,4}; printArray(arr); selectSort(arr); printArray(arr); } } (常见)2.冒泡排序:相邻两个元素进行比较,符合条件换位(第一圈,最值出现在最后,先确定尾角标) /* 需求:冒泡排序 思路:1.通过for循环嵌套完成 2,外循环控制次数,注意最后剩下的一个元素不用参与比较 3.内循环控制比较流程,相邻两个互相比较,因为比较后得到的是最大值,从后往前排,所以每次内循环要(-x),减少x的比较次数,又因为循环内为y和(y+1)比较,当y取最大值时,(y+1)会导致越界,所以次数还要(-1),不访问到最高下标 ,y<arr.length-x-1 */ class BubbleSort { public static void bubbleSort(int[] arr) { for(int x=0;x<arr.length-1;x++) { for(int y=0;y<arr.length-x-1;y++) { if(arr[y]>arr[y+1]) { int temp=arr[y]; arr[y]=arr[y+1]; arr[y+1]=temp; } } } } public static void printArray(int[] arr) { System.out.print("["); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void swap_temp(int[] arr,int a,int b) { int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; } public static void swap_wei(int[] arr,int a,int b) { arr[a]=arr[a]^arr[b]; arr[b]=arr[a]^arr[b]; arr[a]=arr[a]^arr[b]; } public static void main(String[] args) { int[] arr={5,3,6,1,7,5,8}; printArray(arr); bubbleSort(arr); printArray(arr); } } -------------------------------------------------------------------------------- 封装代码: /* 需求:冒泡排序 思路:1.通过for循环嵌套完成 2,外循环控制次数,注意最后剩下的一个元素不用参与比较 3.内循环控制比较流程,相邻两个互相比较,因为比较后得到的是最大值,从后往前排,所以每次内循环要(-x),减少x的比较次数,又因为循环内为y和(y+1)比较,当y取最大值时,(y+1)会导致越界,所以次数还要(-1),不访问到最高下标 ,y<arr.length-x-1 */ class BubbleSort { public static void bubbleSort(int[] arr) { for(int x=0;x<arr.length-1;x++) { for(int y=0;y<arr.length-x-1;y++) { if(arr[y]>arr[y+1]) { swap_temp(arr,y,y+1); } } } } public static void printArray(int[] arr) { System.out.print("["); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void swap_temp(int[] arr,int a,int b) { int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; } public static void swap_wei(int[] arr,int a,int b) { arr[a]=arr[a]^arr[b]; arr[b]=arr[a]^arr[b]; arr[a]=arr[a]^arr[b]; } public static void main(String[] args) { int[] arr={5,3,6,1,7,5,8}; printArray(arr); bubbleSort(arr); printArray(arr); } } (实际开发)3.代码: 最前面(写在类前):import java.util.*; 写在主函数里:Arrays.sort(arr); /* 需求:冒泡排序 思路:1.通过for循环嵌套完成 2,外循环控制次数,注意最后剩下的一个元素不用参与比较 3.内循环控制比较流程,相邻两个互相比较,因为比较后得到的是最大值,从后往前排,所以每次内循环要(-x),减少x的比较次数,又因为循环内为y和(y+1)比较,当y取最大值时,(y+1)会导致越界,所以次数还要(-1),不访问到最高下标 ,y<arr.length-x-1 */ import java.util.*; class Fast { public static void printArray(int[] arr) { System.out.print("]"); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void main(String[] args) { int[] arr={3,6,4,2,1,7,8}; printArray(arr); Arrays.sort(arr); printArray(arr); } } 4.数组中的查找操作(数据出现的第一个位置,如果返回-1,则数在数组中不存在) 折半查找:提高效率,但必须保证数组为有序数组 /* 需求:有一个有序的数组,想要将一个元素插入到该数组中且保证数组依然有序,如何获取该元素插入后在数组中的位置 思路:1、设置一个最小值,一个最大值,一个中间值,中间值=(最大值+最小值)/2(最大值,最小值,中间值都是下标) 2.只要(最小值<=最大值),通过while循环控制,首先求中间值,再在循环内用if语句判断,中间值(上的元素) 与要插入元素比较,如果比元素小,最小值=(中间值+1),如果大,最大值=(中间值-1),如果相等,返回中间值, 如此循环直至(最大值<最小值),返回最小值 */ class Search { public static int search(int[] arr,int key) { int min=0,mid,max=arr.length-1; while(min<=max) { mid=(max+min)>>1; if(key<arr[mid]) max=mid-1; else if(key>arr[mid]) min=mid+1; else return mid; } return min; } public static void printArray(int[] arr) { System.out.print("["); for(int x=0;x<arr.length-1;x++) System.out.print(arr[x]+","); System.out.println(arr[arr.length-1]+"]"); } public static void main(String[] args) { int[] arr={2,5,5,6,8,9,11,13}; printArray(arr); int x=search(arr,10); System.out.println(x); } } 11.4 数组中的数组 二维数组[][] 格式1:int[][] arr=new int[3][2]; (注:int[][] y;int y[][];int[] y[];均可) I.定义了名称为arr的二维数组 II.二维数组中有3个一维数组 III.每一个一位数组中有2个元素 IV.一维数组的名称分别为arr[0],arr[1],arr[2] V.给第一个一维数组1角标位赋值为78:arr[0][1]=78; 格式2:int[][] arr=new int[3][]; I.二维数组中有3个一维数组 II.每一个一维数组都是默认初始值为null III.可对这三个一维数组分别进行初始化 arr[0]=new int[3]; arr[1]=new int[1]; arr[2]=new int[2];
练习:
/*
需求:求60的二进制数对应的十六进制数(逆序+多余0)
思路:1.二进制每四位对应一个十六进制数,可以(&15)求得该数
2.求下个四位,先无符号右移(防止移不完)四位,再(&15)
3.将与后得到的大于9的数转换为字母
4.通过for循环控制
*/
class BinToHex
{
public static void toHex(int a)
{
for(int x=0;x<8;x++)
{
int n1=a&15;
if(n1>9)
System.out.println((char)(n1-10+65));
else
System.out.println(n1);
a=a>>>4;
}
}
public static void main(String[] args)
{
toHex(60);
}
}
-----------------------------------------------------------------
/*
需求:十进制转二进制(顺序+无多余0)
*/
class ToBin
{
public static void main(String[] args)
{
System.out.println(Integer.toBinaryString(60));
}
}
---------------------------------------------------------------------
/*
需求:十进制转二进制(逆序+无多余0)
思路:1.给一个数,通过模2求余数,打印
2.通过while控制,数除2商为0时停止
*/
class ToBin
{
public static void toBin(int num)
{
while(num>0)
{
System.out.println(num%2);
num=num/2;
}
}
public static void main(String[] args)
{
toBin(4);
}
}
-------------------------------------------------------------------------------
/*
需求:十进制转二进制(定义一个对象容器) 好处:顺序打印+无多余0
思路:1.定义一个容器,每次得的余数装在容器中
2.通过while控制,数除2商为0时停止
3.再反转
*/
class ToBin
{
public static void toBin(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}
public static void main(String[] args)
{
toBin(6);
}
}
------------------------------------------------------------------------------
/*
需求:十进制转二进制(查表+数组容器+指针) (顺序+无多余0)
思路:1.定义一张表,通过下表可以查到相应的值(注意表为字符类型的数组)
2.定义一个数组容器,存储余数,结束后打印(注意数组为字符类型)
3.定义一个指针,指向数组的最后
4.只要余数不等于0,就(&1),得到的数查表,再存储进数组
5.打印出数组中的元素
*/
class ToBin
{
public static void toBin(int num)
{
char[] chs={'0','1'};
char[] arr=new char[32];
int pos=arr.length;
while(num!=0)
{
int temp=num&1;
arr[--pos]=chs[temp];
num=num>>>1;
}
for(int x=pos;x<arr.length;x++)
System.out.println(arr[x]);
}
public static void main(String[] args)
{
toBin(6);
}
}
------------------------------------------------------------------------------
/*
需求:十进制转十六进制(顺序+无多余0)
*/
class ToHex
{
public static void main(String[] args)
{
System.out.println(Integer.toHexString(60));
}
}
/*
需求:十进制转十六进制(逆序+多余0)
思路:1输入一个数,(&15),得到的结果打印,如果大于9,转换为字母,否则,直接打印
2.打印完向右移四位,继续1操作
3.总流程用while控制,内部一个if语句判断
*/
class ToHex
{
public static void toHex(int num)
{
for(int x=0;x<8;x++)
{
int temp=num&15;
if(temp>9)
System.out.println((char)(temp-10+'A'));
else
System.out.println(temp);
num=num>>>4;
}
}
public static void main(String[] args)
{
toHex(60);
}
}
--------------------------------------------------------------------------------
/*
需求:十进制转十六进制(对象容器) (顺序+多余0)
思路:1定义一个对象容器,与15后的值都存在里面
2.最后反转
*/
class ToHex
{
public static void toHex(int num)
{
StringBuffer sb=new StringBuffer();
for(int x=0;x<8;x++)
{
int temp=num&15;
if(temp>9)
sb.append((char)(temp-10+'A'));
else
sb.append(temp);
num=num>>>4;
}
System.out.println(sb.reverse());
}
public static void main(String[] args)
{
toHex(60);
}
}
-----------------------------------------------------------
/*
需求:十进制转十六进制(查表) (逆序+多余0)
思路:1定义一张表(字符型数组)
2.将&15后的值当做下标去找对应值
3.打印
*/
class ToHex
{
public static void toHex(int num)
{
char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
for(int x=0;x<8;x++)
{
int temp=num&15;
System.out.println(chs[temp]);
num=num>>>4;
}
}
public static void main(String[] args)
{
toHex(60);
}
}
/*
需求:十进制转十六进制(查表+数组容器+指针) (顺序+无多余0)
思路:1.定义一张表,通过下表可以查到相应的值(注意表为字符类型的数组)
2.定义一个数组容器,存储余数,结束后打印(注意数组为字符类型)
3.定义一个指针,指向数组的最后
4.只要余数不等于0,就(&15),得到的数查表,再存储进数组
5.打印出数组中的元素
*/
class ToHex
{
public static void toHex(int num)
{
char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr=new char[8];
int pos=arr.length;
while(num!=0)
{
int temp=num&15;
arr[--pos]=chs[temp];
num=num>>>4;
}
for(int x=pos;x<arr.length;x++)
System.out.println(arr[x]);
}
public static void main(String[] args)
{
toHex(60);
}
}
--------------------------------------------------------------------------------------------------