五_Java基本语法与项目一

复习

class ReviewTest{

	public static void main(String[] args){
		int sum ;//变量在使用之前要赋值。
		//for(int i = 1;i <= 100;i++){
			if(4 % 2 != 0){
				//System.out.println(i);
				sum = 1;
			}else{
				sum = 2;
			}
		//}
		System.out.println(sum);

	
	}

}

2.5.4 程序流程控制：循环结构之for循环p39

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。

说明：break关键字的使用：一旦在循环中执行到break，就跳出循环

*/

import java.util.Scanner;
class ForTest{

	public static void main(String[] args){
	
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个正整数：");
		int m = scan.nextInt();
		
		System.out.println("请输入第二个正整数：");
		int n = scan.nextInt();
		
		//获取最大公约数
		//1.获取两个数中的较小值
		int min = (m <= n)? m : n;
		//2.遍历
		for(int i = min;i >= 1 ;i--){
			if(m % i == 0 && n % i == 0){
				System.out.println("最大公约数为：" + i);
				break;//一旦在循环中执行到break，就跳出循环
			}
		}
		
		//获取最小公倍数
		//1.获取两个数中的较大值
		int max = (m >= n)? m : n;
		//2.遍历
		for(int i = max;i <= m * n;i++){
			if(i % m == 0 && i % n == 0){
				
				System.out.println("最小公倍数：" + i);
				break;
			
			}
		}
		
	}

}

2.5.5 程序流程控制：循环结构之while循环p41

/*
While 循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、while循环的结构

①
while(②){
	③;
	④;
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！ 
  区别：for循环和while循环的初始化条件部分的作用范围不同。


算法：有限性。

*/
class  WhileTest{
	public static void main(String[] args) {
		
		//遍历100以内的所有偶数
		int i = 1;
		while(i <= 100){
			
			if(i % 2 == 0){
				System.out.println(i);
			}
			
			i++;
		}
		//出了while循环以后，仍可以调用。
		System.out.println(i);//101

	}
}

2.5.5 程序流程控制：循环结构之while循环p45

/*
do-while循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、do-while循环结构：

①
do{
	③;
	④;

}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while

*/
class DoWhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}

			num++;

		}while(num <= 100);
		

		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);

		//*************体会do-while至少执行一次循环体***************
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;
		}

		int number2 = 10;
		do{
			System.out.println("hello:do-while");
			number2--;
		}while(number2 > 10);

	}
}

2.5.6 程序流程控制：循环结构p47

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
     方式一：循环条件部分返回false
	 方式二：在循环体中，执行break
*/

import java.util.Scanner;

class ForWhileTest {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		int positiveNumber = 0;//记录正数的个数
		int negativeNumber = 0;//记录负数的个数

		for(;;){//while(true){
			
			int number = scan.nextInt();

			//判断number的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				//一旦执行break，跳出循环
				break;
			}

		}

		System.out.println("输入的正数个数为：" + positiveNumber);
		System.out.println("输入的负数个数为：" + negativeNumber);
		

	}
}

2.5.7 程序流程控制：嵌套循环结构p50

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次

4. 技巧：
   外层循环控制行数，内层循环控制列数
*/
class ForForTest {
	public static void main(String[] args) {
		
		//******
		//System.out.println("******");
		for(int i = 1;i <= 6;i++){
			System.out.print('*');
		}

		System.out.println("\n");

		/*
		******
		******
		******
		******
		*/
		for(int j = 1;j <= 4;j++ ){
			for(int i = 1;i <= 6;i++){
				System.out.print('*');
			}
			System.out.println();
		}

		/*			i(行号)		j(*的个数)
		*			1			1
		**			2			2
		***			3			3
		****		4			4
		*****		5			5
		*/

		for(int i = 1;i <= 5;i++){//控制行数
			for(int j = 1;j <= i;j++){//控制列数
				System.out.print("*");
			
			}
			System.out.println();
		}
		
		/*			i(行号)		j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
		****		1			4
		***			2			3
		**			3			2
		*			4			1
		*/	

		for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 5 - i;j++){
				System.out.print("*");	
			}
			System.out.println();
		}

		/*
		*
		**
		***
		****
		*****
		****
		***
		**
		*
		*/

		//略

/*

----* 
---* * 
--* * * 
-* * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 

*/

	//上半部分


	//下半部分
		
	}
}

2.5.7 程序流程控制：嵌套循环结构p50

/*

嵌套循环的应用1：

九九乘法表
1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81


*/
class NineNineTable {
	public static void main(String[] args) {
		
		for(int i = 1;i <= 9;i++){
			
			for(int j = 1;j <= i;j++){
				System.out.print(i + " * " + j + " = " + (i * j) + "  ");
			}

			System.out.println();
		}


	}
}

2.5.7 程序流程控制：嵌套循环结构p50

/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2
*/
class PrimeNumberTest {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值

		for(int i = 2;i <= 100;i++){//遍历100以内的自然数
			
		
			for(int j = 2;j < i;j++){
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
				}
				
			}
			//
			if(isFlag == true){
				System.out.println(i);
			}
			//重置isFlag
			isFlag = true;
		
		}
	}
}

2.5.7 程序流程控制：嵌套循环结构p50

/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest1 {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			//优化二：对本身是质数的自然数是有效的。
			//for(int j = 2;j < i;j++){
			for(int j = 2;j <= Math.sqrt(i);j++){
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
					break;//优化一：只对本身非质数的自然数是有效的。
				}
				
			}
			//
			if(isFlag == true){
				//System.out.println(i);//输出会拖慢了演示，所以改成count++
				count++;
			}
			//重置isFlag
			isFlag = true;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数（1s=1000ms）
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

2-5-8 特殊关键字的使用：break、continuep54

/*

break和continue关键字的使用

				使用范围			循环中使用的作用(不同点)		相同点
break:			switch-case			
				循环结构中			结束当前循环					关键字后面不能声明执行语句	



continue:		循环结构中			结束当次循环					关键字后面不能声明执行语句



*/
class BreakContinueTest {
	public static void main(String[] args) {

		for(int i = 1;i <= 10;i++){
		
			if(i % 4 == 0){
				break;//123
				//continue;//123567910
				//System.out.println("今晚迪丽热巴要约我！！！");
			}
			System.out.print(i);
		}

		System.out.println("\n");
		//******************************
		
		label:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
					//continue;

					//break label;//结束指定标识的一层循环结构（标识符可以任意取名）
					continue label;//结束指定标识的一层循环结构当次循环
				}
				
				System.out.print(j);
			}
			
			System.out.println();
		}
	}
}

质数输出最优解

/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			for(int j = 2;j <= Math.sqrt(i);j++){
				
				if(i % j == 0){ //i被j除尽
					continue label;
				}
				
			}
			//能执行到此步骤的，都是质数
			count++;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

3.4 数组中涉及到的常见算法p40

package com.atguigu.exer;

/*
 * 拓展：修改题目，实现 array2 对 array1 数组的复制
 * 
 * 其操作类似于网盘中的一个文件A，对他进行赋值，粘贴到桌面上，这样就有两套一模一样的文件了，对桌面
 * 上的文件进行操作，不影响文件A，即这两个文件就是真正的两套东西。
 * 
 */
public class ArrayExer3 {
	public static void main(String[] args) {
		//声明 array1 和 array2 两个 int[]变量
		int[] array1,array2;
		//array1 初始化
		array1 =new int[]{2,3,5,7,11,13,17,19};
		
		
		
		//显示 array1 的内容==遍历。
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
		
		
		//数组的复制
		array2 = new int[array1.length];
		for(int i = 0;i < array2.length;i++){
			array2[i] = array1[i];
		}
		
		
			
		//修改 array2 中的偶索引元素，使其等于索引值(如 array[0]=0,array[2]=2)。
		for(int i = 0;i < array2.length;i++){
			if(i % 2 == 0){
				array2[i] = i;
			}
		}
		System.out.println();
		
		
		
		//打印出 array1。
		for(int i = 0;i < array1.length;i++){
			System.out.print(array1[i] + "\t");
		}
	}
}

3.4 数组中涉及到的常见算法p36

package com.atguigu.java;

/*
 * 算法的考察：数组的复制、反转、查找(线性查找、二分法查找)
 */
public class ArrayTest2 {
	public static void main(String[] args) {
	
		String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
//数组的复制
		//通过new的方式，在堆空间中新开辟一个新数组。将array1数组
		//中的元素值一个一个地复制到array2数组中。
		//区别于数组变量的赋值：arr1=arr
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
			arr1[i] = arr[i];
		}
		
		
//数组的反转
		//方法一：
//		for(int i = 0;i < arr.length / 2;i++){
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i - 1];   //i+(arr.length-i-1)=常数arr.length-1
//			arr[arr.length - i - 1] = temp;
//		}
		
		//方法二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		
		
		
		
		
		
		//查找（或搜索）
		//线性查找
		String dest = "BB";	//要查找的元素
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
				System.out.println("找到了指定元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if(isFlag){
			System.out.println("很遗憾，没找到！");
		}
		
		//更进
		/*
		 * 	String dest = "BB";	//要查找的元素

		for(int i = 0;i < arr.length;i++){
			if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
				System.out.println("找到了指定元素，位置为：" + i);
				break;
			}
		}
		if(i==arr.length){
			System.out.println("很遗憾，没找到！");
		}
		 */
		
		
		
		
		
		
		//二分法查找：
				//前提：所要查找的数组必须有序
				int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
				
				int dest1 = -34;
				int head = 0;	//初始的首索引
				int end = arr2.length - 1;	//初始的末索引
				
				boolean isFlag1 = true;
				while(head <= end){
					int middle = (head + end)/2;
					
					if(dest1 == arr2[middle]){
						System.out.println("找到了指定元素，位置为：" + middle);
						isFlag1 = false;
						break;
					}else if(arr2[middle] > dest1){
						end = middle - 1;
					}else{	//arr2[middle] < dest1
						head = middle + 1;
					}	
				}
				
				if(isFlag1){
					System.out.println("很遗憾，没找到！");
				}
		
	}
}

3.4 数组中涉及到的常见算法：排序算法p47

package com.atguigu.java;
//p166
/*
 * 数组的冒泡排序的实现
 * 49 38 65 97 76 13 27 49
 * 38 49 65 76 13 27 49 97
 * 38 49 65 13 27 49 76 97
 * 38 49 13 27 49 65 76 97
 * 38 13 27 49 49 65 76 97
 * 13 27 38 49 49 65 76 97
 * 
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,92,-65,85,71,-42};
		
		//冒泡排序
		//string排序按照ABCD顺序排，中文按照Unicode值排序
		for(int i = 0;i < arr.length - 1;i++){//比较n-1轮
			
			for(int j = 0;j < arr.length - 1 - i;j++){
				
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			
		}
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
	}
}

3.5 Arrays工具类的使用p56

package com.atguigu.java;

import java.util.Arrays;
/*
 * java.util.Arrays:操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
 */
public class ArrayTest {
	public static void main(String[] args) {
	
//1.boolean equals(int[] a,int[] b)判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,2,9,3};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
//2.String toString(int[] a)输出数组信息。
		System.out.println(Arrays.toString(arr1));		
		
//3.void fill(int[] a,int val)将指定值填充到数组之中。
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));		
		
//4.void sort(int[] a)对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		
		
//5.int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。
		int[] arr3 = new int[]{43,32,76,92,-65,85,71,-42}; 
		Arrays.sort(arr3);//排序
		
		System.out.println(Arrays.toString(arr3));//输出
		
		int index = Arrays.binarySearch(arr3, 43);//返回的是个负数则没找到，返回下标
		
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到。");
		}		
	}
}

3.6 数组使用中的常见异常p58

package com.atguigu.java;

/*
 * 数组中的常见异常：
 * 1.数组角标越界的异常:ArrayIndexOutOfBoundsException
 * 
 * 2.空指针异常:NullPointerException
 * 
 */
public class ArrayExceptionTest {
	public static void main(String[] args) {
		
		//1.数组角标越界的异常:ArrayIndexOutOfBoundsException
		int[] arr = new int[]{1,2,3,4,5,6};
		
		//错误1：
//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}
		
		//错误2：
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");
		
		
		
		
		//2.空指针异常:NullPointerException
		//情况一:
//		int[] arr2= new int[]{1,2,3};
//		arr2 = null;//相当于栈中的arr2变量的指向堆中的指针被赋值为null,则堆中的数组不会被指了
//		System.out.println(arr2[0]);
		//情况二:
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三:
//		String[] arr3 = new String[]{"AA","QQ","YY","XX","TT","KK"};
//		arr3[0] = null;
//		System.out.println(arr3[0].toString());		
	}
}