java（四）--- 流程控制/数组的操作

最新推荐文章于 2023-11-09 09:38:05 发布

黑夜里的月亮

最新推荐文章于 2023-11-09 09:38:05 发布

阅读量247

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_39926166/article/details/108621227

版权

java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

一、输入/输出

1、输出

代码打印输出，总是 System.out.println() 来输出一些内容并显示出来；其中 println 是 print line 的缩写，表示的是输出并换行的意思，如果输出不换行的话，可使用 print()

public class Hello{
	public static void main(String[] args){
			System.out.println("Hello");
			System.out.print("World");
			System.out.println("abc");
	}
}

//输出：
/*
Hello
Worldabc
*/

2、格式化输出

如果要把数据显示成我们期望的格式，就需要使用格式化输出的功能，格式化输出使用 System.out.printf()，printf（）可以把后面的参数格式化成指定的格式

		double pi = 3.1415926;  
		String strs = "Thanks!";   
		int ints = 3000;  
		//"%"表示进行格式化输出，"%"之后的内容为格式的定义
		System.out.printf("%.2f\n", pi);//f 表示格式化浮点数，并保留两位; 输出：3.14
		//3.14
		System.out.printf("%10.3f\n",pi); // 10.3 中的10表示输出长度，并且保留3位小数
		//     3.142
		System.out.printf("%+10.3f\n",pi); // "+" 输出带正号
		//    +3.142
		System.out.printf("%-10.3f\n",pi); //"-" 表示输出的数左对齐（默认的是右对齐）
		//3.142  
		System.out.printf("%+-10.3f\n",pi); //"+-" 表示输出数带正号且左对齐
		//+3.142  
		System.out.printf("%d\n",ints); //%d 表示输出的是十进制
		//3000
		System.out.printf("%o\n",ints); //%o 表示输出的是八进制
		//5670
		System.out.printf("%x\n",ints); //%x 表示输出十六进制整数
		//bb8
		System.out.printf("%#x\n",ints); // %#x 表示输出十六进制标志的整数
		//0xbb8
		System.out.printf("%s\n", strs); // s 表示输出字符串
		//Thanks!
		System.out.printf("浮点数：%f，一个整数：%d，字符串：%s\n",pi,ints,strs); //注意变量的顺序
		//浮点数：3.141593，一个整数：3000，字符串：Thanks!
		System.out.printf("字符串;%2$s,%1$d的八进制是：%1$o\n",ints,strs); //"n$"表示第几个变量
		//字符串;Thanks!,3000的八进制是：5670

3、输入

通过 import 导入 java.util.Scanner,注意 import语句一定要放开头，创建一个 Scanner 对象，将 System.in 传入其中，已经知道了 System.out 作为输出流，那么这里的 System.in 就作为的是输入流，就需要Scanner 来简化后续的代码；有了Scanner 对象，通过scanner.nextLine() 来读取用户输入的字符串, scanner.nextInt() 用来读取用户输入的整型。 Scanner会自转换数据类型的

import java.util.Scanner; //
public class inputs {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);  //创建一个Scanner的输入对象
		System.out.print("输入名字："); //打印需要输入的信息
		String name = scanner.nextLine(); //读取输入的一行字符串
		System.out.print("输入年龄：");//打印需要输入的信息
		int age = scanner.nextInt(); //读取一行输入并获取整数
		System.out.printf("name：%s, 年龄：%d", name,age);
		
	}
}
//输出：
/*
输入名字：tom
输入年龄：12
name：tom, 年龄：12
*/

二、if判断语句

1、if判断

语法

if(条件) {
//满足条件时运行}


public class Ifs {
		public static void main(String[] args) {
			int a = 1;
			//条件
			if(a > 0) {
				System.out.println("a 大于0的");
			}//if运行结束	
		}
}
//输出：a 大于0的

当 a>0 时结果为true，if语句将执行，打印出 a 大于0的；当if语句中有多条语句时，只要满足条件都会打印出来的；只有一条语句时，可以省略花括号 {},省略后若再加加入语句就不是很方便了

public class Ifs {
		public static void main(String[] args) {
			int a = 1;
			//条件
			if(a > 0.5)
				System.out.println("a 大于0.5的");//到这里if运行结束	
		}
}
//输出:a 大于00.5的

2、else：如果if不通就运行else的代码块

public class Ifs {
		public static void main(String[] args) {
			int n = 59;
			if(n >= 60) {
				System.out.println("及格了");
				}
			else { //如果if不通 就运行else的代码块
				System.out.println("不及格");
			}
			
		}
}

如果出现多个条件时，需要用到 else if 进行串联；注意的是判断范围是从大到小小一次判断的（或者从小到大的）按顺序写，不然结果会有问题，使用if时需要注意边界问题

public class Ifs {
		public static void main(String[] args) {
			int n = 90;
			if(n >= 90) {
				System.out.println("优秀");
				}
			else if( n >= 60){
				System.out.println("及格");
			}
			else {
				System.out.println("不及格");
			}
	}
}
//输出：优秀

另外注意的是在对浮点数进行判断是不能直接使用 “==” 来判断，因为浮点数在进行计算时会出现误差；使用两浮点数之差的绝对值是否小与一个最小值来进行判断，例子：

。。。
			double x = 1- 9.0/10;
			//判断x是否等于 0.1
			if(Math.abs(x - 0.1) < 0.000001) {
				System.out.println("x is 0.1");
			}else {
				System.out.println("x与0.1不等");
			}
//输出：x is 0.1

3、判断引用类型是否相等

判断时引用类型（如字符串类型 String）是否相等，使用equals（）方法，不能使用 == 判断；要注意判断的字符换类型不能为null，为null的画会报错，避免报错可以加一个判断，！=null

public class equals {
	public static void main(String[] args) {
		String s1 = "tom";
		String s2 = "TOM".toLowerCase(); //toLowerCase()方法是将字符串中的字符母都转换为小写
		//System.out.println(s1);
		//System.out.println(s2);
		if(s1 != null && s1.equals(s2)) { //为避免s1为null时报错，加一个 s1 != null的条件来避免报错
			System.out.println("s1与s2相等");
		}else {
			System.out.println("s1与s2不相等");
		}
	}

}
//输出：s1与s2相等

三、switch多重选择

switch语句是通过某个表达式的结果，分别去表达不同分支，switch语句根据switch表达式计算结果，然后跳转到匹配到的case结果，一直运行到break结束
语法:(只要保证有break, case的顺序不影响结果)

switch(option){
	case a:
		...
		break;
	case b:
		...
		break;
	default: //作为没有匹配到时,执行
		...
		break;
}

package switchs;
import java.util.Scanner;//有输入内容需要导入此模块

public class switchs {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字: ");//提示行
		int num = scanner.nextInt(); //读取输入的数字num
		switch(num) {
		case 1: //如果匹配的是1,将输出下面一句话
			System.out.println("你输入的数字是1");
			break;
		case 2: //如果匹配的是1,将输出下面一句话
			System.out.println("你输入的数字是1");
			break;
		case 3: //如果匹配的是1,将输出下面一句话
			System.out.println("你输入的数字是3");
			break;
		case 4: //如果匹配的是1,将输出下面一句话
			System.out.println("你输入的数字是4");
			break;
		case 5: //如果匹配的是1,将输出下面一句话
			System.out.println("你输入的数字是5");
			break;
		}
	}

}
//输出:
/*
请输入数字: 
1
你输入的数字是1
*/

其中输入的num将去判断匹配case,如果输入的num没有匹配当中 1-5 任意一个case,时 switch语句将不会执行任何语句;当default,当没有匹配到任意 case时,回执行default;需要注意的是case 中需要加break; 虽然不会报错但是输出的结果意思就变了

package switchs;
import java.util.Scanner;

public class switchs {
	public static void main(String[] args) {
		//int numc = 7;
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字: ");
		int num = scanner.nextInt(); 
		switch(num) {
		case 1:
			System.out.println("你输入的数字是1");
			break;
		case 2:
			System.out.println("你输入的数字是1");
			break;
		case 3:
			System.out.println("你输入的数字是3");
			break;
		case 4:
			System.out.println("你输入的数字是4");
			break;
		case 5:
			System.out.println("你输入的数字是5");
			break;
		default: //当输入的num 不包含在上面case中时将执行default
			System.out.println("其中的case 没有被匹配到");
			break;
		}
	}

}
//输出:
/*
请输入数字: 
10
其中的case 没有被匹配到
*/

如果有几个case 语句执行同一语句块,可以像下面这么写:

import java.util.Scanner;
public class switchs {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字: ");
		int num = scanner.nextInt(); 
		switch(num) {
		case 1:
			System.out.println("你输入的数字是1");
			break;
		/*
		case 2:
			System.out.println("你输入的数字是1");
			break;
		*/
		case 2:
		case 3:
			System.out.println("你输入的数字是2或3"); //输入的2 还是 3 都会输出这句话
			break;
		default:
			System.out.println("其中的case 没有被匹配到");
			break;
		}
	}
}
//输出:
/*
请输入数字: 
2
你输入的数字是2或3
*/

switch语句中可以匹配字符串

public class switchstr {
	public static void main(String[] args) {
		String s = "China";
		switch (s) {
		case "China":
			System.out.println("中国");
			break;
		case "Beijing":
			System.out.print("北京");
			break;
		}
	}
}
//输出:
//中国

拓展 : 在java13开始switch语句可以用以下写法,不需要break语句

public class switchstr {
	public static void main(String[] args) {
		String s = "China";
		switch (s) {
		case "China" -> System.out.println("中国");
		case "Beijing" -> System.out.print("北京");
		case "Chengdu" ->{ //当有多条语句时,需要用花括号
				System.out.print("武侯");
				System.out.print("高新");
			}
		default -> System.out.print("外国");
		}
	}
}

switch 中的赋值

public class switchaddvar {
	public static void main(String[] args) {
		int nums = 0;
		String food = "cucumber";
		switch (food) {
		case "bread":
			nums = 1;
			break;
		case "cucumber":
			nums = 2;
			break;	
		}
		System.out.println(nums); // 2
	}
}

yield
在复杂的语句中 ,可将 yield 返回一个作为switch语句的返回值 (在java14中包含此功能)，在java8中应该是没有此功能的

四、while循环

1、while语法

while（//条件）{
	//循环语句
}

例子：计算1到100累加的和
注意：while循环是先判断的是条件，再执行其中的循环语句，因此也可能不执行；也要注意while中的循环语句的执行顺序，如下面，都会先执行 n++ 后执行 sum = sum + n；如果顺序有换那么结果就不正确了

public class whiless {
	public static void main(String[] args) {
		int sum = 0; //初始化sum为0，不然会报错
		int n = 1;
		while(n <= 100) { //循环循环条件
			sum = sum + n; //总和累加
			n ++; //自增1
		}
		System.out.println(sum);
	}
}
//5050

五、do while循环

在Java中while循环实现判断条件，再执行循环语句，另一种 do while 循环则是先执行循环，在判断条件，条件满足继续执行循环，当条件不满足时退出循环
语法：

do {
	//循环语句
} while(//条件语句)

那么1到100之和用 do while循环来表示如下：

public class whiless {
	public static void main(String[] args) {
		int sum = 0; //初始化sum为0，不然会报错
		int n = 1;
		do{ 
			sum = sum + n; //总和累加
			n ++; //自增1
			System.out.println(n);
		} while(n <= 10);
		System.out.println(sum);//循环循环条件
	}
}

六、for 循环

1、for循环语法

for(初始条件;循环条件;循环后的更新计时){
		//循环语句
}

先用for循环计算 1 到 100 之和：

public class fors {
	public static void main(String[] args) {
		int sum = 0;
		for(int i = 1;i <= 100;i++) { //注意用分号隔开
			sum = sum + i;
		}
		System.out.println(sum);
	} 
}
//5050

如果for循环对一个整型数组求和

public class arrays {
	public static void main(String[] args) {
		int sum = 0;
		int[] arraes = {1,2,3,4,5}; 
		for(int i=0; i<arraes.length;i++) { //数组是从0开始索引的，范围因该是0-4，不包含5的，
			sum = sum + arraes[i]; 
		}
		System.out.println(sum); //15
		
}

2、for ‘each’循环

for循环经常用来遍历数组，可以根据计数器缩影访问数组中的每个元素

for循环：

public class arrays {
	public static void main(String[] args) {
		int[] arraes = {1,2,3,4,5}; 
		for(int i=0; i<arraes.length;i++) {
			System.out.println(arraes[i]);
		}
	}
}
/* 输出：
1
2
3
4
5
*/

使用for ‘each’循环遍历数组，其中的 i 不再是计数器了，是直接对应的每个元素，这种写法代码更简洁，在世这种方法不能是指定遍历顺序，也无法获取数组的索引

public class foreach {
	public static void main(String[] args) {
		int[] arrays = {1,2,3,4,5};
		for (int i:arrays) {
			System.out.println(i);
		}
	}
}
/* 输出：
1
2
3
4
5
*/

练习1：使用for循环倒序输出数组

public class prectice {
	public static void main(String[] args) {
		int[] arraes = {1,2,3,4,5};
		for(int i = arraes.length - 1;i >=0 ;i--) {
			System.out.println(arraes[i]);
		}
	}
}

输出:
在这里插入图片描述

七、break / continue

在while 与 for循环中，有连个特别的语句分别是 break 和 continue 语句；

1、break：跳出循环，整个循环都不会执行了

在循环过程中可以使用 break 来跳出循环；如求出 1到100之和

public class breaks {
	public static void main(String[] args) {
		int sum = 0;//初始化和
		for (int i = 1;;i++) {
			sum = sum + i; //和进行累加
			if(i == 100) {
				break; //break跳出循环
			}
		}
		System.out.println(sum);//最后输出：5050
	}
}

2、continue: 是结束某次循环，且继续执行

public class ctinue {
	public static void main(String[] args) {
		int sum = 0;
		for(int i=1; i<=10; i++) {
			if (i % 2 == 0) {
				continue; //如果是偶数，结束本次循环
			}
			System.out.println("奇数是：" + i);
		}
	}
}

输出:
在这里插入图片描述

八、数组的操作

1、遍历数组

第一种方法：

public class arrayss {
	public static void main(String[] args) {
		int[] arraes = {1,2,3,4,5};
		for(int i=0; i<arraes.length; i++) { // .length获取数组的长度
			System.out.println(arraes[i]);
		}
	}
}

输出
在这里插入图片描述

第二种遍历方法

这里利用的是for ‘each’遍历

public class arrasetwo {
	public static void main(String[] args) {
		int[] arraies = {1,2,3,4,5};
		for(int i : arraies) {
			System.out.print(i + " "); //i在这里相当于对应数组中每个元素; 使用print时不换行
		}
	}
}

输出：
在这里插入图片描述

第三种方法：直接利用java中的库

在使用for循环遍历，还是使用for each 进行遍历数组都比较麻烦，这时java 自带了一个库 Arrays.toString(array)，进行快速打印

import java.util.Arrays; //导入标准库
public class criterions {
	public static void main(String[] args) {
		int[] arras = {1,2,3,4,5};
		System.out.println(Arrays.toString(arras));
	}
}

输出:
在这里插入图片描述

2、数组的排序

a、冒泡排序

import java.util.Arrays;
public class bubble {
	public static void main(String[] args) {
		int[] arrayss = {36,167,34,21,314,521,22,78,123};
		for (int i=0; i< arrayss.length - 1; i++) { //比较轮数 8
			for(int j=0; j < arrayss.length - 1 - i; j++) { //每轮比较次数 第轮8次比较，第二轮 9-1-1=7次比较 ,第三轮 9-1-2 = 6次比较。。。  
				if (arrayss[j] > arrayss[j+1]) { //如果想做倒序的话，直接将 > 改为 <
					//如果前一个元素大于后一个元素；将arrayss[j],arrayss[j+1]换位置
					int tmp = arrayss[j];
					arrayss[j] = arrayss[j+1];
					arrayss[j+1] = tmp;
				}
			}
		}
		System.out.println(Arrays.toString(arrayss));
	}
}
//输出：[21, 22, 34, 36, 78, 123, 167, 314, 521]

注意在做交换时，需要一个临时变量, 下面这种方法

int a = x;
x = y;
y = a;、
执

b、 java内部模块进行排序

在Java的标准库中有内置的排序功能，只需要调用即可，Arrays.sort()

import java.util.Arrays;

public class ranks {
	public static void main(String[] args) {
		int[] arrayss = {36,167,34,21,314,521,22,78,123};
		System.out.println("-----排序前------");
		System.out.println(Arrays.toString(arrayss));
		Arrays.sort(arrayss); //先使用Arrays.sort()排序
		System.out.println("-----排序后------");
		System.out.println(Arrays.toString(arrayss)); //再使用 Arrays.toString进行遍历
	}
}

输出：
在这里插入图片描述

3、多维数组

二维数组表示方式：类型 [ ][ ]

import java.util.Arrays;
public class hyperspace {
	public static void main(String[] args){
		int[][] arrayss = {
				{ 1, 2, 3, 4, 5 },
				{ 6, 7, 8, 9, 10},
				{ 11, 12, 13 }
		};
		//将arrayss[0]赋值赋值给stri的普通数组
		int[] stri = arrayss[0];//将arrayss数组的第一个元素赋值给stri数组中
		//打印遍历出stri数组
		System.out.println(Arrays.toString(stri)); // [1, 2, 3, 4, 5]
		System.out.println(arrayss.length); // 3
		//访问二维数组中的元素
		System.out.println(arrayss[1][2]); // 8  
	}
}

二维数组的打印：可以使用双重for循环打印

public class for_array {
	public static void main(String[] args) {
		int[][] arrayss = {
				{ 1, 2, 3, 4, 5 },
				{ 6, 7, 8, 9, 10},
				{ 11, 12, 13 }
		};
		for(int arr[] : arrayss) { //第一层输出还是数组 正能是数组类型的
			for(int n : arr) {
				System.out.print(n + " "); //第二层循环打印数组中的数组，不换行操作
			} 
			System.out.println(); //第一轮循环换行操作
		}
	}

二维数组也可使用java中自带的标准库进行打印，其中库Arrays.deepToString();

import java.util.Arrays;
public class arr {
	public static void main(String[] args) {
		int[][] arrayss = {
				{ 1, 2, 3, 4, 5 },
				{ 6, 7, 8, 9, 10},
				{ 11, 12, 13 }
		};
		System.out.println(Arrays.deepToString(arrayss)); //使用deepToString()直接可以打印
	}
}

三维数组

如表示方式：

public class dimension {
	public static void main(String[] args) {
		int[][][] arra = {
				{
					{1, 2, 3},
					{4, 5, 6},
					{7, 8, 9}
				},
				{
					{10,11,12},
					{13,14}
				},
				{
					{15,16,17,18},
					{19,20}
				}
		};
	}
}

若需访问的话同二维数组，跟上索引就行了，注意数组是从0开始的

System.out.println(arra[0][1][1]); //5

理论上我们可以定义N维数组
练习：计算二维数组中所有元素的平均值

public class avg {
	public static void main(String[] args) {
		int[][] scores = {
				{60, 85,78},
				{90, 65, 84},
				{72, 67, 89}	
		};
		double avgs = 0;
		int sum = 0;
		double nsnum = 0;
		for(int ns[] : scores) {
			for(int i=0; i<ns.length; i++) {
				sum = sum + ns[i];
			}
			nsnum = nsnum + ns.length;
			avgs = sum/nsnum;
		}
		System.out.println(nsnum);
		System.out.print(avgs);
	}
}
//输出：
//9
//76.66666666666667