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);
}
}
--------------------------------------------------------------------------------------------------