Java的流程控制与数组
1.用户的接受输入
用户创建输入类时，要记得导包：import java.util.Scanner;
Scanner input = new Scanner(System.in);
//用于接收各种数据类型，next后面可以接double，byte等
//System.out.println("请输入数字：");
//int i = input.nextInt();
//System.out.println(i);
字符串类型：
//next不能显示空格，nextLine可以显示空格
//System.out.println("请输入next接收的内容：");
//String str1 = input.next();
System.out.println("请输入next接收的内容：");
String str2 = input.nextLine();
//System.out.println(str1);
System.out.println(str2);
2.程序的执行结构
1996 年，计算机科学家 Bohm 和 Jacopini 证明了：任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本 结构组合而成。
1.顺序结构
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作
2.分支结构
分支结构又被称为选择结构，根据条件成立与否来执行操作
2-1.if条件语句
if(条件语句){…}
if (条件语句){…}else{…}
if (条件语句){…}else if(条件语句){…}
if (条件语句){…}else if(条件语句){…}else{…}
示例：用户输入学生成绩，判断成绩是否及格，判断条件为 优良： > 90、良好：70-90、中：60-70、不及格：<60
package practice4;
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
//输入学生成绩，判断是否合格
System.out.println("请输入学生成绩：");
Scanner input = new Scanner(System.in);
int i = input.nextInt();
if(i>=90) {
System.out.println("学生成绩为优秀。");
}
else if(i>=70 && i<90) {
System.out.println("学生成绩为良好。");
}
else if(i>=60 && i<70) {
System.out.println("学生成绩为及格。");
}
else
System.out.println("学生成绩为不及格。");
}
}
2-2.switch语句
switch(表达式){
case 取值 1: 语句块 1;break;
case 取值 n: 语句块 n;break;
default: 语句块 n+1;break;
}
switch 语句有关规则
- 表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
- case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；
- default 子句是可选的；
- break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果 case 后面没有写 break 则直接往下面执行！
- Case 后面的执行体可写{ }也可以不写{ }
示例：根据月份判断季节
package practice4;
import java.util.Scanner;
public class Demo3 {
public static void main(String[] args) {
// 根据月份判断季节
System.out.println("请输入月份：");
Scanner input = new Scanner(System.in);
String text = input.next();
switch (text) {
case "3":
case "4":
case "5":System.out.println("春季");
break;
case "6":
case "7":
case "8":System.out.println("夏季");
break;
case "9":
case "10":
case "11":System.out.println("秋季");
break;
case "12":
case "1":
case "2":System.out.println("冬季");
break;
default:System.out.println("你输入有误，请检查。");
break;
}
}
}
3.循环结构
循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
3-1.while循环
符合条件，循环继续执行；否则，循环退出 。特点：先判断，再执行
语法：while(条件表达式){
//语句块；
}
使用 while 循环的步骤
1.分析循环条件和循环操作
2.套用 while 语法写出代码
3.检查循环是否能够退出
示例：录入班级人数和学员成绩，计算班级学员的平均成绩
package practice4;
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入班级学生人数：");
//定义变量studentNum，记录班级总人数
int studentNum = input.nextInt();
//定义变量i，控制循环次数
int i = 0;
//定义变量sum，记录班级总成绩
int sum = 0;
while(i<studentNum) {
i++;
System.out.println("请输入第"+i+"个学生的成绩");
int s = input.nextInt();
sum += s;
}
System.out.println("学生的平均成绩为："+sum/studentNum);
}
}
3-2.do-while循环
先执行一遍循环操作，符合条件，循环继续执行；否则，循环退出 。特点：先执行，再判断
语法： do {
循环操作
}while ( 条件表达式 );
while 循环和 do-while 循环的区别：
while:先判断条件，如果条件满足，再执行循环操作
do while:先执行一遍循环操作，然后再判读条件，如果条件满足，继续执行循环操作。
3-3.for循环
语法：for(初始化参数;判断条件 ;更新循环变量){
循环体;
}
示例：输出10行10列的“”*
package practice4;
public class Demo5 {
public static void main(String[] args) {
//外层循环控制的是行数
for (int i = 0; i < 10; i++) {
//内层循环控制的是列数
for (int j = 0; j < 10; j++) {
System.out.print("* ");
}
System.out.println();//换行
}
}
}
3.循环退出
- break是用于终止本轮所有次循环。即不执行本次循环中break后面的语句,直接跳出循环。
- continue是用于终止本轮本次循环。即本次循环中continue后面的代码不执行,进行下一次循环的入口判断。
package practice4;
public class Demo6 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
//break;
continue;
}
System.out.println(i);
}
}
}
以上面的例子来说：使用continue时，输出012346789；使用break时，输出01234
多重循环的退出：
package practice4;
public class Demo7 {
public static void main(String[] args) {
Demo7:for (int i = 0; i < 10; i++) {//Demo7:
for (int j = 0; j < 10; j++) {
System.out.println("i="+i+" j="+j);
if (i==5 && j==5) {
break Demo7;//退出多重循环
}
}
}
}
4.数组
1.概述
数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个
元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
2.创建格式
最好是格式1和格式2
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 3. 数据类型[] 数组名;只创建了数组引用名， 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n}
数组创建时的常见问题：
1.数组下标越界问题
int [] age= {1,2,3,4};
System.out.println(age[5]);
2.空指针问题
int a[] = null;
System.out.println(a[0]);
3.下标
可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。
例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
4.数组常用算法
1.冒泡排序
原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
示例：
package practice5;
public class Demo5 {
//冒泡排序
public static void main(String[] args) {
int[] nums = {20,15,18,13,30,60};
int temp;
//外层循环控制的是， 比较的轮数。
//外层循环次数： length-1
for(int i=0;i<nums.length-1;i++) {
//内层循环控制的是，每轮比较的次数
//第i轮（i从0开始计算）， 比较次数为：length-i-1
for(int j=0;j<nums.length-i-1;j++) {
if(nums[j]>nums[j+1]) {
//两两相比， 满足移动条件
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
//排序已经完成。 下面是遍历打印查看的过程
for(int i=0;i<nums.length;i++) {
System.out.println(nums[i]);
}
}
}
2.二分查找（折半查找）
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用
中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查
找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功；直到子数组不存在为止，表示查找不成功。
示例：
package practice5;
public class Demo6 {
//二分查找（折半查找）
public static void main(String[] args) {
int[] nums = {10,20,30,40,50,60,70,80,90};
//要查找的数据
int num = 25;
//关键的三个变量：
//1. 最小范围下标
int minIndex = 0;
//2. 最大范围下标
int maxIndex = nums.length-1;
//3. 中间数据下标
int centerIndex = (minIndex+maxIndex)/2;
while(true) {
System.out.println("循环了一次");
if(nums[centerIndex]>num) {
//中间数据较大
maxIndex = centerIndex-1;
}else if(nums[centerIndex]<num) {
//中间数据较小
minIndex = centerIndex+1;
}else {
//找到了数据 数据位置：centerIndex
break;
}
if(minIndex > maxIndex) {
centerIndex = -1;
System.out.println("查找数字不存在");
break;
}
//当边界发生变化， 需要更新中间下标
centerIndex = (minIndex+maxIndex)/2;
}
System.out.println("位置："+centerIndex);
}
}
扫一扫
988
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
