练习

ASCII编码表

American Standard Code for Information Interchange，美国标准信息交换代码.
在计算机中，所有的数据在存储和运算时都要使用二进制数表示, a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示

数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，字母A-Z对应ASCII编码十进制为65-90

利用for循环打印ABCDEFG…XYZ，26个大写字母与26个小写字母

  题目分析：
    通过观察发现，本题目要实现打印26个大写字母、26个小写字母
    1.	一共26个大小写字母，那么，可以考虑循环26次。在每次循环中，完成指定字母的大小写打印
    2.	找出ABCDEFG…XYZ这些字母之间的变化规律
    通过ASCII表发现，后面的字母比它前面的字母，ASCII值大1
    下一个字母 = 上一个字母 + 1
    如： A	B	C	D
    	65	66	67	68
    3. 在每次循环中打印上一个字母大小写，并指定下一个字母
    
        解题步骤：
        1.	定义初始化大写变量，值为’A’； 初始化小写变量，值为’a’
        2.	使用for循环，进行26次循环
        3.	在每次循环中，打印大写字母、小写字母。
        每次打印完成后，更新大写字母值、小写字母值
    public class Test04 {
	public static void main(String[] args) {
		char da = 'A';
		char xiao = 'a';
		for (int i = 0; i < 26; i++) {
			System.out.println("大写字母 "+da+" ,小写字母 "+xiao);
			da++; //更新大写字母值
			xiao++; //更新小写字母值
		}
	}
}

/*
ASCII编码表演示
字符Java 数据类型,char
整数Java 数据类型,int

	int 类型和 char 数据类型转换
	char  两个字节, int 四个字节
	
	char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
	int转成char类型的时候,强制转换,会查询编码表
	
	char存储汉字,查询Unicode编码表
	
	char可以和int计算,提示为int类型, 内存中两个字节
	char取值范围是0-65535, 无符号的数据类型
*/
public class ASCIIDemo{
	public static void main(String[] args){
		char c = 'a';
		int i = c + 1;
		System.out.println(i);
		
		int j = 90;
		char h = (char)j;
		System.out.println(h);
		
		System.out.println( (char)6 );
		
		char k = '你';
		System.out.println(k);
		
		
		char m = -1;
	}
}

数组元素逆序

/*
   数组的逆序:
     数组中的元素,进行位置上的交换
	 逆序 不等于 反向遍历
	 就是数组中最远的两个索引,进行位置交换,实现数组的逆序
	 使用的是数组的指针思想,就是变量,思想,可以随时变换索引
	 反转 reverse
	 实现步骤:
	   1. 定义方法,实现数组的逆序
	   2. 遍历数组
	     实现数组的最远索引换位置
		 使用临时的第三方变量
*/
public class ArrayMethodTest_1{
	public static void main(String[] args){
		int[] arr = {3,5,7,1,0,9,-2};
		//调用数组的逆序方法
		reverse(arr);
		//看到数组的元素,遍历
		printArray(arr);
	}
	
	/*
	   定义方法,实现数组的逆序
	   返回值: 没有返回值
	   参数:   数组就是参数
	*/
	public static void reverse(int[] arr){
		//利用循环,实现数组遍历,遍历过程中,最远端换位
		//for的第一项,定义2个变量, 最后,两个变量++ --
		for( int min = 0 , max = arr.length-1 ; min < max  ; min++,max--){
			//对数组中的元素,进行位置交换
			//min索引和max索引的元素交换
			//定义变量,保存min索引
			int temp = arr[min];
			//max索引上的元素,赋值给min索引
			arr[min] =  arr[max];
			//临时变量,保存的数据,赋值到max索引上
			arr[max] = temp;
		}
	}
	
	/*
	   定义方法,实现功能
	   返回值: void
	   方法参数: 数组
	*/
	public static void printArray(int[] arr){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
			    System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

数组的排序

选择排序

冒泡排序

/*
  数组的排序: 一般都是升序排列,元素,小到大的排列
  
  两种排序的方式
     选择排序: 数组的每个元素都进行比较
	 冒泡排序: 数组中相邻元素进行比较
	 规则: 比较大小,位置交换
*/
public class ArrayMethodTest_2{
	public static void main(String[] args){
		int[] arr  = {3,1,4,2,56,7,0};
		//调用选择排序方法
		//selectSort(arr);
		
		//调用冒泡排序方法
		bubbleSort(arr);
		printArray(arr);
	}
	/*
	   定义方法,实现数组的冒泡排序
	   返回值: 没有
		参数:  数组
	*/
	public static void bubbleSort(int[] arr){
		for(int i = 0 ; i < arr.length - 1; i++){
			//每次内循环的比较,从0索引开始, 每次都在递减
			for(int j = 0 ; j < arr.length-i-1; j++){
				//比较的索引,是j和j+1
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	
	/*
	    定义方法,实现数组的选择排序
		返回值: 没有
		参数:  数组
		实现步骤:
		  1.嵌套循环实现排序
		    外循环,控制的是一共比较了多少次
			内循环,控制的是每次比较了多少个元素
		  2. 判断元素的大小值
		    小值,存储到小的索引
	*/
	public static void selectSort(int[] arr){
		for(int i = 0 ; i < arr.length - 1; i++){
			//内循环,是每次都在减少,修改变量的定义
			for(int j = i+1 ; j < arr.length ; j++){
				//数组的元素进行判断
				if(arr[i] > arr[j]){
					//数组的换位
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp; 
				}
			}
		}
	}
	
	/*
	   定义方法,实现功能
	   返回值: void
	   方法参数: 数组
	*/
	public static void printArray(int[] arr){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
			    System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

二分查找法

/*
   数组的查找功能
     在一个数组中,找一个元素,是否存在于数组中,如果存在,就返回索引
	 
	 普通查询:
	   找到元素在数组中出现的索引,如果没有这个 元素,结果就是负数
		
*/
public class ArrayMethodTest_3{
	 public static void main(String[] args){
		 int[] arr = {1,3,5,7,9,11,15};
		 int index = binarySearch(arr,10);
		 System.out.println(index);
		 
	 }
	 
	 /*
	     定义方法,实现,折半查找
		 返回值: 索引
		 参数: 数组,被找的元素 
		 实现步骤:
		   1. 需要的变量定义
		      三个,三个指针
			  
		   2. 进行循环折半
		      可以折半的条件  min <= max
		   
		   3. 让被找元素,和中间索引元素进行比较
		       元素 > 中间索引  小指针= 中间+1
			   元素 < 中间索引  大指针= 中间-1
			   元素 == 中间索引  找到了,结束了,返回中间索引
			   
		    4. 循环结束,无法折半
			  元素没有找到 ,返回-1
	 */
	 public static int binarySearch(int[] arr, int key){
		 //定义三个指针变量
		 int min = 0 ;
		 int max = arr.length -1 ;
		 int mid = 0;
		 //循环折半,条件 min<=max
		 while( min <= max){
			 //公式,计算中间索引
			 mid = (min+max)/2;
			 //让被找元素,和中间索引元素进行比较
			 if(key > arr[mid]){
				 min = mid + 1;
			 }else if (key < arr[mid]){
				 max = mid - 1;
			 }else{
				 //找到元素,返回元素索引
				 return mid;
			 }
		 }
		 return -1;
	 }
	 
	/*
	   定义方法,实现数组的普通查询
	   返回值: 索引
	   参数:   数组, 被找的元素
	   
	   实现步骤:
	     1. 遍历数组
		 2. 遍历过程中,使用元素和数组中的元素进行比较
		    如果相同,返回元素在数组中的索引
			如果不同,返回负数
	*/
	public static int search(int[] arr, int key){
		//遍历数组
		for(int i = 0 ; i < arr.length ; i++){
			//数组元素,被查找的元素比较
			if(arr[i] == key){
				//返回索引
				return i;
			}
		}
		return -1;
	}
}