Java笔记之基础语法

/*
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] + ",");
		}
	}
}