/*
1 标识符
1.1. 在程序中所定义的一些名称，由26个英文字母大小写，数字0-9,符号：_$组成
1.2 定义合法的标识符规则：
a.数字不可以开头
b.不可以使用关键字
c.Java中严格区分大小写，在起名字时，为了提高阅读性，尽量起有意义的名字。
2 常量与变量
2.1 常量：常量表示不能改变的数值
2.2. Java中的常量分类：
a.整数常量。所有整数
b.小数常量。所有小数
c.布尔型常量。较为特有，只有2个数值。true false
d.字符常量。将一个数字字母或者符号用单引号(‘’)标识。
e.字符串常量。将一个数字字母或者符号用双引号(“”)标识。
f.null常量。只有一个数值就是null
g.对于整数Java有三种表现形式：
a)十进制：0-9满10进1。
b)八进制：0-7满8进1，用0开头表示。
c)十六进制：0-9，A-F，满16进1，用0x表示。
3 进制转换
a.十进制转二进制： 原理：对十进制数进行除2运算
b.二进制转十进制： 原理：二进制乘以2的过程
c.转八进制： 原理：先转换成二进制，在转成八进制，3个代表一位
d.转十六进制： 原理：先转换成二进制，在转成十六进制，4个代表一位(可以做最低四位与运算)
e.负数的二进制表现形式： 原理：将二进制的0变成1,1变成0
============================================================================
例子：-6，在内存中的实际是如下样子的 取反+1 反码是-1取反
-6在内存中的表现形式: 0000-0000 0000-0000 0000-0000 0000-0110
对他进行取反运算： 1111-1111 1111-1111 1111-1111 1111-1001
然后在加1： 0000-0000 0000-0000 0000-0000 0000-0001
---------------------------------------------------
1111-1111 1111-1111 1111-1111 1111-1010 = -6
=============================================================================
f.整数的最高位是0，负数的最高位是1,1是由取反取来的。
4 变量
a.变量：就是将不确定的数据进行存储。也就是需要在内存中开辟一个空间。
例：
*/
class VarDemo
{
public static void main(String[] args)
{
//定义变量的格式:
//数据类型 变量名 = 初始化值
//Or
//数据类型 变量名
//变量名 = 初始化值
}
}
/*
b.数据类型:
byte (number, 1 byte)
short (number, 2 bytes)
int (number, 4 bytes)
long (number, 8 bytes)
float (float number, 4 bytes)
double (float number, 8 bytes)ee
char (a character, 2 bytes)
boolean (true or false, 1 byte)
5 类型转换
a.自动类型转换：
*/
class TypeDemo1
{
public static void main(String[] args)
{
byte b = 3;
b = b + 2;
System.out.println(b);
/*会报错，这是因为JAVA是强类型语言导致的
两个不同类型的数值进行运算会进行自动类型提升，默认是小的类型往大
的转换
*/
}
}
//b.强制类型转换：
class TypeDemo2
{
public static void main(String[] args)
{
byte b = 3;
b = (byte)(b + 2); //这里将b+2的和强制转换成byte类型再赋值给B
System.out.println(b);
}
}
//c.引出的疑问
class TypeDemo3
{
public static void main(String[] args)
{
System.out.println(‘a‘ + 1); //打印98，是因为ascii码的原因
System.out.println((char)(‘a‘ + 1)) //这里强制转换，打印b
}
}
//6 运算符
//6.1 算术运算符
class OperateDemo1 //算术运算符+-*/
{
public static void main(String[] args)
{
int x = 4270;
x = x / 1000 * 1000;
System.out.println(x); //2个int数据进行运算还是int行,结果为4000
}
}
class OperateDemo2 //取模运算%
{
public static void main(String[] args)
{
System.out.println(10%4); //取模，实际就是取余数，左边小于右边，结果是左边，左边等于右边结果是0，右边是1结果是0
System.out.println(1%-4); //结果等于1
System.out.println(-1%4); //结果等于-1，由以上得出，对一个负数取模，只看左边
}
}
class OperateDemo3 //自曾自减++
{
public static void main(String[] args)
{
int a = 3,b; //定义了2个变量，a初始化值为3，b没有值，不能直接被使用
b = a++; //对a进行+1操作，并把+1后的值重新赋值给a
System.out.println(b); //3
System.out.println(a); //4
System.out.println("a=" + a + ",b=" + b); //利用字符串连接符打印
/*
由上引出的疑问，为什么b是3？
原因是b = a++ 是先把a的值赋值给b然后a再进行++运算
而b = ++a 是先把a的值进行++运算，再赋值给b
*/
}
}
class OperateDemo4 //字符串连接符+
{
public static void main(String[] args)
{
System.out.println("haha" + "haha"); //字符串和任何数据使用+都是相连接，最终都会变成字符串
System.out.println("MyNameIs" + 5 + 5); //打印MyNameIs55，把固定的值放到""里面去，把不固定的用+相连接就可以了
}
}
//6.2 转意字符
class OperateDemo5 //通过\来转变后面字母或者符号的含义
{
public static void main(String[] args)
{
System.out.println("Hello \nWorld!"); //用2行来输出，现在我们想载Hello World中间进行换行那么就在\n
System.out.println("MyNameis Crow!");
System.out.println("\"Hello World!\""); //用\来转意"
/*
\n: 换行
\b: 退格，相当于backspace
\r: 按下回车键，Linux用\r,Windows系统中回车符是由2个字符表示的\r\n
\t: 制表符，相当于tab键
*/
}
}
//6.3 赋值和比较运算符
//a.赋值运算符
class OperateDemo6 // += -= *= /= %=
{
public static void main(String[] args)
{
int x = 3; //把右边赋值给左边
x+=4; //x = x + 4把右边和左边的和赋值给左边,其他同理
}
}
//b.比较运算符
class OperateDemo7 //> < >= <= == !=
{
public static void main(String[] args)
{
if(4 == 3) //相等于，运算完的结果要么是true要么是false
{
System.out.println("true");
}else
{
System.out.println("false");
}
if(4 != 3) //不等于，运算完的结果要么是true要么是false
{
System.out.println("true");
}else
{
System.out.println("false");
}
}
}
//6.4 逻辑运算符
class OperateDemo8 //逻辑运算符用来连接boolean类型的表达式
{
public static void main(String[] args)
{
/*
& And(与)说白了就是并且的意思
无论左边是true还是false,右边都运算
| Or (或)
两边都参与运算
^ Xor(异或)
! Not(非) 取反,一元运算符
&&And(短路)
当左边为false时,右边不运算
||Or (短路)
当左边为true时,右边不运算
int x = 4;
x>3 & x<6 = true & true = true;
true & true = true;
true & false = false;
false & true = false;
false & false = false;
& : 只要两边的boolean表达式结果，有一个为false，结果就为false,只有两边都为true，结果才为true
true | true = true;
true | false = true;
false | true = true;
false | false = false;
| : 只要两边的boolean表达式结果,有一个为true,结果为true,只有两边都为false,结果才为false
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
^: 就是和|有点不一样,当true ^ true时候为false,两边相同结果为false,两边不同结果是true
*/
}
}
//6.5 位运算符
class OperateDemo9
{
public static void main(String[] args)
{
3<<2 //3左移2位，打印12，最高位原来的值是什么，就补什么
//0000-0000 0000-0000 0000-0000 0000-0011
//0000-0000 0000-0000 0000-0000 0000-1100 左移以后为12,左移就是乘以2的n次方
6>>2 //6又移2位
//0000-0000 0000-0000 0000-0000 0000-0110
//0000-0000 0000-0000 0000-0000 0000-0001 //右移以后为1,右移就是除以2的n次方
//>>> 无符号右移，不管最高位原来值是什么，都拿0补齐
}
}
class OperateDemo10
{
public static void main(String[] args)
{
/*
6 & 3 = 2 //只要一边为false,结果就为false
110 0 代表false
&011 1 代表true
-----
010 = 2
6 | 5 = 7 //只要一边为true,结果就为true
110
|101
----
111 = 7
6 ^ 5 = 3 //两边相同为false
110
^101
----
011 = 3
~ //反码，就是二进制-1再取反
System.out.println(~6); //-7
*/
}
}
class OperateDemo11 //简单的思考，有趣的问题
{
public static void main(String[] args)
{
/*
7 ^ 4 ^ 4= 7
111
^100
---
011
^100
---
111 = 7 //7^4^4结果=7
//一个数异或同一个数2次，结果还是那个数，这个特性可以用来做简单的加密
*/
}
}
//6.6 位运算符练习
//a.对2乘以8进行运算
//a)因为是2的倍数，最有效的方式是用<<运算。
//b.对两个整数的值进行互换
class OperateDemo12
{
public static void main(String[] args)
{
int n = 3, m = 8;
//1通过第三方变量
int temp;
temp = n;
n = m;
m = temp;
//2不用第三方变量,如果n和m的值非常大，容易超出int范围
n = n + m; //n = 11
m = n - m; //m = 3
n = n -m //n = 8
n = n ^ m;
m = n ^ m; //(n^m)^m
n = n ^ m; //n^(n^m)
}
}
/*
6.7 三元运算符
格式:
(条件表达式)?表达式1:表达式2
如果条件结果为true,那么执行表达式1
如果条件结果为false,那么执行表达式2
三元运算符：
好处:可以简化代码
弊端:因为是一个运算符，所以运算为必须要有一个结果
*/
class OperateDemo13
{
public static void main(String[] args)
{
int x = 3,y;
y = (x>1)?100:200; //如果x的值>1那么把100赋值给y,如果<=1那么把200赋值给y
System.out.println(y);
}
}
//7 流程控制语句
//7.1 判断结构
//if 有3种形式
//a)
class IfDemo1
{
public static void main(String[] args)
{
int x = 3;
if(x>1)
{
System.out.println("Yes");
}
System.out.println("Over"); //这里无论If是否满足都执行，因为此句不再if控制区间内
}
}
//b)
class IfDemo2
{
public static void main(String[] args)
{
int x = 3;
if(x>1)
{
System.out.println("Yes");
}else
{
System.out.println("No"); //这里受else控制
}
}
}
//c)
class IfDemo3
{
public static void main(String[] args)
{
int x = 3;
if(x>1)
{
System.out.println("x > 1");
}else if (x == 1){
System.out.println("x == 1");
}else{
System.out.println("No");
}
}
}
/*
7.2 选择结构
缺点:if能够判断区间，case不能，因为要判断区间必须把值全写出来，很费劲
switch不能判断boolean值的类型
switch(表达式) //表达式的值只能是4种类型byte short int char
{
case 取值1: //case和default的顺序是随意的，但是执行是从case开始的
执行语句;
break;
case 取值2:
执行语句;
break;
......
default:
执行语句;
break; //语句可以从break跳出，也可以从}结束
}
*/
//a)
class SwitchDemo1
{
public static void main(String[] args)
{
int x = 2;
switch(x)
{
case 1:
System.out.println("1");
break;
case 2:
System.out.println("2");
break;
case 3:
System.out.println("3");
break;
case 4:
System.out.println("4");
break;
default:
System.out.println("default");
break; //最后这个break可以省略
}
}
}
//b)
class SwitchDemo2
{
public static void main(String[] args)
{
//需求，根据用户指定月份，打印该月份所属的季节
//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12 1 2 冬季
int x = 4;
switch(x)
{
case 3:
case 4:
case 5:
System.out.println(x + "月是春季");
break;
case 6:
case 7:
case 8:
System.out.println(x + "月是夏季");
break;
case 9:
case 10:
case 11:
System.out.println(x + "月是秋季");
break;
case 12:
case 1:
case 2:
System.out.println(x + "月是冬季");
break;
default:
System.out.println("NoNo");
}
}
}
/* switch应用场景:如果判断的具体数值不多,而且符合byte short int char这四种类型,虽然两个语句都
可以使用，建议使用switch语句，因为效率稍高。
其他情况:对区间判断，对结果为boolean类型判断，使用if,if的使用范围更广
*/
/*
7.3 循环结构
循环语句的特点：当一个语句需要循环很多次的时候使用，while或者for语句
只是考虑变量的作用域问题
a.while语句
定义初始化表达式
while(条件表达式)
{
执行语句;
}
*/
//a)
class WhileDemo1
{
public static void main(String[] args)
{
int x = 1;
while(x < 3) //条件满足，执行控制区间中的语句
{
System.out.println("Hello World!"); //打印2次
x++;
}
}
}
/*
b.do while语句
定义初始化表达式
do
{
执行语句;
}
while(条件表达式); //do while最后判断条件，也就意味着do while无论如何都会执行至少一次
*/
//a)
class WhileDemo2
{
public static void main(String[] args)
{
int x =1;
do
{
System.out.println("Hello World!"); //打印2次
x++;
}
while(x < 3);
}
}
//b)while无限循环最简单的表现形式
class WhileDemo3
{
public static void main(String[] args)
{
while(true){}
}
}
/*c.for语句
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;
}
*/
//a)
class ForDemo1
{
public static void main(String[] args)
{
for(int x = 0; x<3; x++)
{
System.out.println("Hello World!");
}
}
}
/*
for和while的区别:
for的变量作用域范围只能载for语句中有效，那么对于变量来讲，如果这个变量只作用与循环的增量
来存在的话，那么建议使用for
*/
//b)
class ForDemo2
{
public static void main(String[] args)
{
int x = 1;
for(System.out.println("a"); x<3; System.out.println("c")) //疑问，有结果吗？结果是什么？
{
System.out.println("d");
x++;
}
}
}
//由上可只for必须要有真假,不要一位写for循环就一定要写int x = 1;只要是合法的表达式就可以
//c)
class ForDemo3
{
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");
}
}
}
//d)for无限循环最简单的表现形式
class ForDemo4
{
public static void main(String[] args)
{
for(;;){} //对于for来讲,如果不写循环条件表达式，默认为true
}
}
//e)获取1～10的和，并打印
//e.a)利用while循环来实现
class ForDemo4
{
public static void main(String[] args)
{
int sum = 0;
int x = 1;
while(x <= 10)
{
sum = sum + x;
x++;
}
System.out.println("sum= " + sum);
}
}
//e.a)利用for循环来实现
class ForDemo5
{
public static void main(String[] args)
{
int sum = 0;
for(int x = 1; x <= 10; x++)
{
sum += x;
}
System.out.println("sum= " + sum);
}
}
//e)for语句嵌套
class ForDemo6
{
public static void main(String[] args)
{
for(int x = 0; x < 3; x++)
{
for(int y = 0; y < 4; y++) //此循环体结束后才会执行父循环体
{
System.out.println("ok");
}
}
}
}
//7.4 其他流程控制语句
//a.break(跳出)
class BreakDemo1
{
public static void main(String[] args)
{
for(int x = 0; x<3; x++)
{
System.out.println("x= " + x);
break; //跳出,这时候循环语句就结束了,break只能跳出当前循环
}
}
}
class BreakDemo2
{
public static void main(String[] args)
{
w:for(int x = 0; x<3; x++) //这里可以给for循环加标记
{
for(int y = 0; y<4; y++)
{
System.out.println("x= " + x);
break w; //这里跳转到指定标记
}
}
}
}
//b.continue(继续)
class ContinueDemo1
{
public static void main(String[] args)
{
for(int x = 0; x<3; x++)
{
if(x%2==1)
{
continue; //continue结束本次循环，继续下一次循环，continue也可以加标记
}
System.out.println("x= " + x);
}
}
}
/*
8 函数
8.1 什么是函数?
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法
8.2 函数的格式:
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2, ...)
{
执行语句;
return 返回值;
}
返回值类型: 函数运行后的结果的数据类型
参数类型: 是形式参数的数据类型
形式参数: 是一个变量，用于存储调用函数时传递给函数的实际参数
实际参数: 传递给形式参数的具体数值
return: 用于结束函数
返回值: 该值会返回给调用者
8.3 example:
*/
//a.需要定义一个功能，打印x*3+5
class FunctionDemo1
{
public static void main(String[] args)
{
int x = getResult(4); //这里调用函数
}
public static int getResult(int x) //函数定义在类中，被调用才执行
{
return x * 3 + 5;
}
}
/*
8.4 函数的特点
定义函数可以将功能代码进行封装，便于对该功能进行复用
函数只有被调用才会执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的
return语句如果在最后一行可以省略不写
注意:
函数中只能调用函数，不可以在函数内部定义函数
定义函数时，函数结果应该返回给调用者，交由调用者处理
8.5 没有具体返回值的情况
a.//void练习，当函数没有返回值的时候,return可以不写
*/
class FunctionDemo2
{
public static void main(String[] args)
{
getResult(4); //这里调用函数
}
public static void getResult(int x) //当函数运算后没有具体的返回值时，这是返回值类型用void来标识
{
System.out.println(x * 3 + 5;);
}
}
/*
8.6 函数的重载
在同一个类中，允许存在一个以上同名函数,只要它们的参数个数或者参数类型不同即可重载
重载示例:
//返回两个整数的和
int add(int x, int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z)return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}
9 数组
9.1 数组的定义:同一种类型的数据的集合，其实数组就是一个容器
9.2 数组的好处:可以自动的给数组中的元素从0开始编号，方便操作这些元素
9.3 数组的格式:
a.格式1:
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例: int[] arr = new arr[5];
b.格式2:
元素类型[] 数组名 = new 元素类型[]{元素1,元素2,......};
示例: int[] arr = new arr[]{3,5,1,7};
int[] arr = {3,5,1,7};
9.4 example:
*/
//a.
class ArrayDemo1
{
public static void main(String[] args)
{
//需求，想定义一个可以存储3个整数的容器
int[] x = new int[2];
x[0] = 4;
x[1] = 6;
System.out.println(x[0]);
System.out.println(x[1]);
}
}
//9.5 数组操作常见的问题
//b.
class ArrayDemo2
{
public static void main(String[] args)
{
//Java中常见的错误
int[] arr = new int[3];
System.out.println(arr[3]); //这里编译不会报错，在运行的时候会报错
}
}
//c.
class ArrayDemo3
{
public static void main(String[] args)
{
int[] arr = new int[3];
arr = null; //这里把引用置空
System.out.println(arr[1]); //编译时不会报错，当程序执行到这里是报错
}
}
//9.6 数组的常见操作
/*
a.数组的遍历
获取数组的元素，通常利用for循环来解决
*/
class ArrayDemo4
{
public static void main(String[] args)
{
int[] arr = new int[]{22,412,23,441}; //这里一个一个数比较麻烦，载数组中有一个属性可以直接获取到数组元素的个数。length
//使用方法:数组名称.length =
for(int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]="+arr[x]";");
}
}
}
//定义功能:打印数组中的元素，元素之间用逗号隔开.
class ArrayDemo5
{
public static void main(String[] args)
{
int[] arr = new int[4];
arr[0] = 32;
arr[1] = 47;
arr[2] = 76;
arr[3] = 51;
printArray(arr);
}
public static void printArray(int[] arr)
{
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
{
System.out.print(arr[x] + ",");
}else
{
System.out.println(arr[x]);
}
}
}
}
//给定一个数组{2,1,5,8,3,0,7},获取数组中的最大值，最小值
class ArrayDemo6
{
public static void main(String[] args)
{
int[] arr = new int[]{2,1,5,8,3,0,7};
/*
1.获取最值需要进行比较，每次比较都会有一个较大的值，因为该值不确定，那么通过变量进行临时存储
2.让数组中每一个元素都和这个变量中的值进行比较，如果大于变量中的值，就用该变量记录较大的值。
3.当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值。
*/
int max = getMax(arr);
System.out.println("max = " + max);
}
public static int getMax(int[] arr)
{
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
{
max = arr[x];
}
}
return max;
}
}
//思考：可不可以将临时变量初始化为0呢？
class ArrayDemo7
{
public static void main(String[] args)
{
int[] arr = new int[]{2,1,5,8,3,0,7};
int max = getMax(arr);
System.out.println("max = " + max);
}
public static int getMax(int[] arr)
{
//int max = arr[0];
int max = 0 //这里把它初始化为0，是可以的，因为是把它看成初始化为数组中任意一个下标
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
{
max = x;
}
}
return arr[max]; //这里返回数组是max下标的元素
}
}
//获取最小值，作为练习
/*
数组的排序
a.选择排序
*/
class ArrayDemo8
{
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])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
public static void printArray(int[] arr)
{
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
{
System.out.println("Arr[]={" + arr[x] +"},");
}else
{
System.out.println("Arr[]={" + arr[x] +"}");
}
}
}
public static void main(String[] args)
{
int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
System.out.println("=============排序前=================");
printArray(arr);
System.out.println("=============排序后=================");
SelectSort(arr);
printArray(arr);
}
}
/*
数组的排序
b.冒泡排序
*/
class ArrayDemo9
{
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)
{
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
{
System.out.println("Arr[]={" + arr[x] +"},");
}else
{
System.out.println("Arr[]={" + arr[x] +"}");
}
}
}
public static void main(String[] args)
{
int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
System.out.println("=============排序前=================");
printArray(arr);
System.out.println("=============排序后=================");
BubbleSort(arr);
printArray(arr);
}
}
/*
数组的排序
c.封转位置置换功能
*/
class ArrayDemo10
{
public static void main(String[] args)
{
}
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
//数组的查找
class ArrayDemo11
{
public static void main(String[] args)
{
int[] arr = new int[]{1,5,3,6,8,7,0,9,2};
int index = getIndex(arr,3);
System.out.println("index=" + index);
}
//定义功能:获取key第一次出现在数组中的位置，如果返回值是-1,那么代表该key在数组中不存在.
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
}
//a.折半查找
class ArrayDemo12
{
public static void main(String[] args)
{
int[] arr = new int[]{1,3,5,6,7,8,9};
int index = halfSearch(arr,7);
System.out.println("index=" + index);
}
//折半查找，可以提高效率，但是必须要保证该数组是有序的数组.
public static int halfSearch(int[] arr,int key)
{
int max,mid,min;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
}
//b.折半查找的第二种方式
class ArrayDemo13
{
public static void main(String[] args)
{
int[] arr = new int[]{1,3,5,6,7,8,9};
int index = halfSearch_2(arr,7);
System.out.println("index=" + index);
}
//折半查找，可以提高效率，但是必须要保证该数组是有序的数组.
public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid;
while(min<=max)
{
mid = (max+min)>>1;
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
}
//利用程序进行进制转换
//a.第一种方法
class ToBin1
{
public static void main(String[] args)
{
toBin(6);
}
//十进制转二进制
public static void toBin(int num)
{
while(num>0)
{
System.out.println(num%2);
num = num / 2;
}
}
}
//b.第二种方法
class ToBin2
{
public static void main(String[] args)
{
toBin(6);
}
//十进制转二进制
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer(); //利用StringBuffer方法进行存储
while(num>0)
{
sb.append(num%2);
num = num / 2;
}
System.out.println(sb.reverse());
}
}
//十进制转十六进制
class ToBin3
{
public static void main(String[] args)
{
toHex(60);
}
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;
}
}
}
/*
查表法
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
将所有元素临时存储起来，建立对应关系。每一次&15后的值作为索引
去查建立好的表。就可以找到对应的元素,这样就比-10+‘a‘简单的多
通过数组的形式建立表
*/
class ToBin4
{
public static void main(String[] args)
{
toHex(60);
}
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;
}
}
}
//对结果还是不满意，我们需要只显示有效位，并且反转结果
class ToBin5
{
public static void main(String[] args)
{
toHex(60);
}
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;
}
//存储数据的arr数组遍历
for(int x=pos; x<arr.length; x++ ) //这里数组指针倒着存
{
System.out.print(arr[x] + ",");
}
}
}
时间： 2024-11-12 11:03:52