Java - 流程控制-循环结构 + 数组

最新推荐文章于 2021-10-12 17:44:15 发布

xjfy.h

最新推荐文章于 2021-10-12 17:44:15 发布

阅读量374

点赞数

分类专栏：【笔记】BigData校内培训-Java入门、进阶

本文链接：https://blog.csdn.net/weixin_42526141/article/details/82768704

版权

【笔记】BigData校内培训-Java入门、进阶专栏收录该内容

10 篇文章 2 订阅

订阅专栏

1、流程控制

流程控制指的是对java代码执行顺序的控制，在控制中加上我们的逻辑处理，从而完成相应的目标。在java中，流程控制可以分为三类：顺序、分支、循环。

顺序执行，表示逐行执行相应的语句，从前往后执行，不涉及任何的关键字
分支控制，是条件控制，需要按照判断条件动态的去执行符合条件的语句，if switch
循环控制，则需要按照循环判断条件动态的去执行循环语句，for while do-while

在代码编写过程中，我们通常用一对花括号将若干语句括起来，目的是从语法上将多条语句解释为一条语句

1.1、分支流程控制语句：

if语句

if选择结构是根据条件判断结果选择不同的处理，if如果条件满足，则执行if中的代码块

 if ( 条件 boolean ) { 
        //代码块 
}

满足前提条件则执行语句，这是最简单的流程控制语句之一了。注意的一点事“前提条件”的结果必须为boolean型。true则执行。

if-else语句

if-else语句规定在满足前提条件的情况下执行某些操作， if如果条件满足，则执行if中的代码块，否则，执行else中的代码。

if ( 条件 ) { 
      //代码块1  
 } else { 
     //代码块2 
}

说明：满足前提条件（true）则执行语句1，否则执行语句2。

嵌套if控制语句可以通过外层语句和内层语句的协作，增强程序的灵活性，适合某个变量处于某个连续区间时的情况。

//多分支if-else
if ( 条件 ) { 
      //代码块1  
} else if() { 
     //代码块2 
} else {
    //代码块3
}

switch语句

switch语句是一种具有处理多分支能力的流程控制语句，只能处理等值条件判断的情况。

switch (表达式) {         //表达式可以是int、short、byte、char和枚举类型
    case 常量 1:          //如果等于常量1
        语句;
		break;

    case 常量 2:          //如果等于常量2
		语句;
		break;
	…
	
	default:            //如果没有找到匹配的值
		语句;
}

其中，要注意的一点是表达式的值必须是int、short、byte、char和枚举类型，jdk1.7之后可以使用String；常量值不能重复，值1和值2之间不能互相影响；在每个case后不要忘记写break。

switch语句的执行过程是：首先计算表达式的值，再与每个case后面的值作比较，若相同，则执行这个case后面的语句，直到遇到break或switch语句结束。若与所有的case后面的值比较后仍然没有相等的选项，则执行default后面的语句。default块顺序可以变动，但要注意其执行顺序。通常，default块放在末尾，也可以省略。

如果需要每个case执行完后跳出，在每个case后不要忘记写break。

1.2、循环流程控制语句

当要用编程的方式完成一个大量、重复功能的需求时，我们可以用循环来解决这件事。

while语句

while ( 循环条件 ) {      //符合条件，循环继续执行；否则，循环退出
	    
       // 循环操作          //循环中被重复执行的操作

}

执行过程：先判断，后执行。判断循环条件，为true则执行语句，再回来判断循环条件……直到循环条件为false。因此，循环条件的结果必须为boolean值。

do-while语句

do {

	   //循环操作             //先执行一遍循环操作


}while ( 循环条件 );          //符合条件，循环继续执行；否则，循环退出

执行过程：执行循环体（语句序列），随后判断“循环条件”，为true则继续循环，为false则跳出。故此处循环条件结果依然为boolean值。而循环体至少执行了一次。

while循环和do-while循环的区别:

语法不同
执行顺序不同
初始情况不满足循环条件时

while循环一次都不会执行，先判断，再执行

do-while循环不管任何情况都至少执行一次，先判断，再执行

for语句

格式：for(初始化表达式;检测表达式;更新表达式)语句;

执行过程：先判断，后执行。“初始化表达式”是for语句第一个执行且只执行一次的语句。检测表达式必须是boolean型，用于决定是否继续循环，更新表达式在每次循环体执行完毕后自动执行。

执行顺序：

while 循环：先判断，再执行
do-while循环：先执行，再判断
for循环：先判断，再执行

适用情况：

循环次数确定的情况，通常选用for循环
循环次数不确定的情况，通常选用while和do-while循环

EG：循环嵌套：求若干个学生的成绩总和和平均分

public static void main(String[] args) {
		String end=null;
		do{
			int score;                   // 每门课的成绩
			int sum = 0;                 // 成绩之和
			double avg = 0.0;             // 平均分
			Scanner input = new Scanner(System.in);
			System.out.print("输入学生姓名: ");
			String name = input.next();

			for (int i = 1; i <= 5; i++) {     // 循环5次录入5门课成绩
				System.out.print("请输入5门功课中第" + i + "门课的成绩： ");
				score = input.nextInt();    // 录入成绩
				sum = sum + score;       // 计算成绩和
			}

			avg = sum / 5;               // 计算平均分
			System.out.println(name + "的平均分是：" + avg);
			System.out.print("\n继续输入吗(y/n)?");
			end= input.next() ;
		} while(end.equals("y") || end.equals("Y"));

		System.out.println("成绩录入结束");
}

1.3、中断流程控制语句

Java中，中断流程控制语句主要包括break，continute和return。

break语句

break表示跳出当前循环，通常在循环中与条件语句一起使用，break可以用在switch\while\do...while\for语句中，可跳出循环而执行循环后面的语句，遇到break，立即跳出switch语句遇到break。

continue语句

continue和break类似，continue语句与break语句最大的区别是，break语句是跳出循环，而continue语句是提前结束此次循环，提早进入下次循环。

continue语句只能在循环中使用，作用是跳过循环体中剩余的语句而执行下一次循环。通常与条件语句一起使用，加速循环。

使用场合

break可用于switch结构和循环结构中
continue只能用于循环结构中

作用（循环结构中）

break语句终止某个循环，程序跳转到循环块外的下一条语句
continue跳出本次循环，进入下一次循环

练习0：打印“加法表”

package com.liudm.demo2;

import java.util.Scanner;

public class SecondDemo {
	//输出一个加法表
	public static void main(String[] args) {
		System.out.println("请输入一个自然数：");
		
		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();
		
		
		for (int i = 0, j = num; i<=num && j >= 0;i++,j--){
			System.out.println(i + "+" + j + "=" + (i+j));
		}
	}
}

练习1：打印如下图所示“星星”

练习2：打印如下图所示“星星”

练习3：打印如下图所示“星星”

练习4：打印如下图所示“菱形”

观察*的规律，发现每行的*数量都呈奇数增长（1，3，5，7，9），当增至第5行，从第6行开始，*个数逐渐递减（7，5，3，1）

所以我们把菱形看成上下，上五下四,所以第一个for有5次，第二个for4次。

在第一个for循环中：再嵌套2个for循环，第一个控制空格的个数，第二个控制*的个数

同理，在第二个for循环中：再嵌套2个for循环，第一个控制空格的个数，第二个控制*的个数

package com.liudm.demo3;

public class lingxing{
	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
			for (int j = 1; j <= 5-i; j++)
				System.out.print(" ");

			for (int k = 1; k <= i*2-1; k++)
			//for(int k = 0; k <= i*2-2; k++)
				System.out.print("*");

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

			for (int k = 7; k >=i*2-1; k--) 
				System.out.print("*");

			System.out.println();
		}
	}
}

//参考
package my.processcontrol;  
public class Multi99 {  
    public static void main(String[] args) {  
        // 首先把菱形看成上下，上五下四,所以第一个for有5次，第二个for4次  
        for (int i = 1; i <= 5; i++) {  
            // 将空格和*分开看，看" "的变化i=1时，他是4 ，2的时候是3找规律  
            for (int j = 1; j <= 5 - i; j++)  
                System.out.print(" ");  
            for (int k = 1; k <= 2 * i - 1; k++) // 找规律，i是 1 3 5 7 基数  
                System.out.print('*');  
            // 换一行  
            System.out.println();  
        }  
        for (int i = 1; i <= 4; i++) {  
            for (int j = 1; j <= i; j++) // 空格 1 2 3 4 so  
                System.out.print(" ");  
            for (int k = 7; k >= 2 * i - 1; k--) // * 7 5 3 1倒着来的基数  
                System.out.print('*');  
            System.out.println();  
        }  
    }  
}

练习5：打印“九九乘法表”

总共有9行，每行乘法的个数都是对应的行的个数，所以我们可以使用两个for循环来达到控制的目的；第一个for循环来控制行数，循环9次；第二个for循环来控制每行的个数，循环的次数随着行数的增多而增多，所以可以用外层for循环的行数来控制内层循环。

package com.liudm.demo3;

public class chengfabiao {
	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) + "\t");
			}
			System.out.println();
		}
	}
}

//参考
package my.processcontrol;  
public class Multi99 {  
    public static void main(String[] args) {  
        for (int a = 1; a <= 9; a++) {//控制行数  
            for (int b = 1; b <= a; b++) {//控制每行的个数  
                System.out.print(a+"X"+b+"="+a*b+"\t");  
            }  
            System.out.println();  
        }  
    }  
}

练习6：求1~1000以内的质数（质数也称合数、素数）

质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。所以分局素数的特点，用while循环和if条件结构来完成此目的。

package my.processcontrol;  
public class Multi99 {  
public static void main(String[] args) {  
        for(int i=2;i<=1000;i++){  
            int num=2;  
            boolean isSu=true;  
            while(num<i){  
                if(i%num==0){  
                    isSu=false;  
                }  
                num++;  
            }  
            if(isSu){  
                System.out.println("这是素数"+i);  
            }  
        }  
    }  
}

练习7：求若干个学生的成绩总和和平均分。要求：循环从控制台录入若干个学生的成绩，求每个学生5门课程中总分、平均分，在控制台输出。

package com.liudm.demo3;

import java.util.Scanner;

public class demo1 {
	public static void main(String[] args) {
		String name;
		float score;
		String ans;
		do{
		    float sum = 0;
			System.out.println("请输入学生姓名：");
			Scanner sc = new Scanner(System.in);
			name = sc.next();
			
			System.out.println("请输入5门课程的成绩：");
			for (int courseNum = 1; courseNum <= 5; courseNum++) {
				System.out.println("请输入第" + courseNum + "门课程的成绩：");
				Scanner input = new Scanner(System.in);
				score = input.nextFloat();
				
				sum = sum + score;
			}
			
			System.out.println("这5门课程的总成绩为：" + sum);
			System.out.println("这5门课程的平均分为：" + sum/5);
	
			System.out.println("是否继续？[Y/N]");
			Scanner get = new Scanner(System.in);
			ans = get.next();
			
		}while("Y".equals(ans));
	}
}

练习8：求1+2!+3!+...+20!的和。

练习9：从控制台输入三个整数x,y,z，请把这三个数由小到大输出。

2、数组

数组对于每一门编程语言来说都是重要的数据结构之一,Java 语言中提供的数组是用来存储固定大小的同类型元素，是有序数据的集合，可以用一个统一的数组名和下标来唯一地确定数组中的元素。数组有一维数组和多维数组。

数组的定义：

数组是一个变量，存储相同数据类型的一组数据，声明一个数组就是在内存空间划出一串连续的空间

数组的结构和基本要素：

标识符：数组的名称，用于引用不同的数组
数组元素：向数组中存放的数据
元素下标：对数组元素进行编号，数组下标从0开始
元素类型：数组元素的数据类型

//定义数组并赋值
int[ ] score = {89, 79, 76};
int[ ] score = new int[]{89, 79, 76};

//动态赋值
Scanner input = new Scanner(System.in);
for(int i = 0; i < score.length; i ++){
     score[i] = input.nextInt();
}

使用数组三步走：定义数组、分配空间、赋值。

注意：

1. 数组一旦定义，就会在Java堆内存中申请一串连续的内存空间。

2. Array.length 表示数组的容量，只要数组创建了，每一个索引被初始化为默认值。int类型的数组初始值默认为0，引用类型默认为null。

3. 数组索引起始为0，最大索引为length-1，负数索引无效的，会抛出ArrayIndexOutOfBoundException异常。

4. 数组一个固定长度的数据结构，一旦声明，将不能改变数组的长度。

5. 可以使用for循环初始化整个数组、访问的每个索引或更新、获取数组元素。

数组的常用操作：

冒泡排序：

public static void main(String[] args) {
		int []nums={2,5,9,7,1};
		for (int i = 0; i < nums.length-1; i++) {
			for (int j = 0; j <nums.length-1-i; j++) {
				int temp=0;
				if(nums[j]>nums[j+1]){
					temp=nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
			}
		}
	}
	System.out.println(Arrays.toString(nums));
}

EG：求学生的总分数、平均分、最大值、最小值

        //动态赋值  
		public static void main(String[] args) {
			//循环录入成绩，将成绩放入数组中
			int[] scores = new int[5];
			//总成绩
			float total = 0;
			//平均成绩
			float avg = 0;
			Scanner input = new Scanner(System.in);
			
			//给出提示
			System.out.println("请输入5个学生的笔试成绩：");
			for(int i = 0; i < scores.length; i++) {
				scores[i] = input.nextInt();
			}
			
			int max=scores[0];
			int min=scores[0];
			
			//计算总成绩
			for (int j = 0; j < scores.length; j++) {
				//总成绩
				total += scores[j];
				if(max<scores[j]){
					max=scores[j];
				}
				if(min>scores[j]){
					min=scores[j];
				}
			}
			//计算平均成绩
			avg = total / scores.length;
			System.out.println("总成绩：" + total);
			System.out.println("平均分：" + avg);
			System.out.println("最大值："+max);
			System.out.println("最小值"+min);
		}

定义二维数组：

二维数组实际上是一个一维数组，它的每个元素又是一个一维数组。

<数据类型>  [ ][ ]  数组名; 
int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

或者 

<数据类型>  数组名 [ ][ ];
int scores[][] = { { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

EG：计算每个班级的学员总成绩

int [][] array = new int[][]{{80,66},{70,54,98},{77,59}};    //三个班的成绩
int total; //保存总成绩
for(int i = 0; i < array.length; i++) {   //外层循环班级个数
    String str = (i+1) + "班";
    total = 0; //每次循环到此都将其归0
    for(int j = 0; j < array[i].length; j++) {    //内层循环具体成绩
        total += array[i][j]; //成绩叠加
    }
    System.out.println(str+"总成绩：" + total);
}

操作数组的Arrays类：

练习1：请将’A’,’B’,’C’从控制台输入存入数组，然后再输出到控制台。

package com.liudm.demo4;

import java.util.Scanner;

public class test2 {
	public static void main(String[] args) {
		String [] a = new String[3];
		System.out.println("请输入三个字符：");
		for (int i = 0; i < a.length; i++) {
			Scanner input = new Scanner(System.in);
			a[i] = input.next();
		}
		System.out.print("\n您输入的字符是：");
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "  ");
		}
	}
}

参考源代码：

package my.array;  
import java.util.Scanner;  
public class ArrayDemo {  
    static Scanner sc=new Scanner(System.in);  

    //题目要求是：请将’A’,’B’,’C’从控制台输入存入数组，然后再输出到控制台，
    //所以我们需要定义一个数组,利用for循环从控制台输入A、B、C，再使用增强for循环来遍历数组。

    public static void main(String[] args) {  
        String [] cs=new String[3];  
        String c=null;  
        for (int i = 0; i < cs.length; i++) {  
            System.out.println("请输入 "+(char)(i+65)+" 存入数组中");  
            c=sc.next();  
            cs[i]=c;  
        }  
        //遍历数组  
        System.out.println("增强for循环遍历数组：  ");
        for (String str : cs) {  
            System.out.print(str+" ");
        }
    }
}

练习2：声明一个数组，在此数组的单元格中放入”我爱章鱼大数据 ”7个字符，然后使用循环将它反序输出。如”据数大鱼章爱我”

package com.liudm.demo4;

public class test {
	public static void main(String[] args) {
		String [] n7 = new String [] {"我","爱","章","鱼","大","数","据"};
		System.out.println("数组中原字符是：");
		for (int i = 0; i < n7.length; i++) {
			System.out.print(n7[i]);
		}
		System.out.println();
		
		System.out.println("反序输出的结果是：");
		for (int i = 6; i >= 0; i--) {
			System.out.print(n7[i]);
		}
	}
}

参考源代码：

package my.array;  
import java.util.Arrays;  
import java.util.Scanner;  
public class ArrayDemo {  
    static Scanner sc=new Scanner(System.in);  

    //声明一个数组，在此数组的单元格中放入”我爱章鱼大数据 ”7个字符，
    //在这里，我们可以使用普通for循环，循环次数是数组的长度，从数组.length-1开始循环，
    //循环次数逐渐递减，从而根据角标拿到数组中的值。

    public static void main(String[] args) {  
        String [] cs=new String[7];  
        cs[0]="我";  
        cs[1]="爱";  
        cs[2]="章";  
        cs[3]="鱼";  
        cs[4]="大";  
        cs[5]="数";  
        cs[6]="据";  
        System.out.println("Arrays类的方法正序输出数组。。。。");  
        System.out.println(Arrays.toString(cs));  
  
        System.out.println("普通for循环逆序输出数组。。。。");  
        for (int i = cs.length-1; i >=0; i--) {  
            System.out.print(cs[i]+"   ");  
        }  
    }  
}

练习3：输入10个整数存入数组，然后复制到b数组中输出。

package com.liudm.demo4;

import java.util.Arrays;
import java.util.Scanner;

public class zuoye1 {
	public static void main(String[] args) {
		System.out.println("请输入10个整数：");
		int [] array = new int[10];
		for (int i = 0; i < array.length; i++) {
			Scanner input = new Scanner(System.in);
			array[i] = input.nextInt();
		}
		
		int[] new_array = Arrays.copyOf(array, 10);
		
		System.out.println("拷贝数组：");
		for (int j = 0; j < new_array.length; j++) {
			System.out.print(new_array[j] + "\t");
		}
	}
}

练习4：在歌唱比赛中，共有10位评委进行打分，在计算歌手得分时，去掉一个最高分，去掉一个最低分，然后剩余的8位评委的分数进行平均，就是该选手的最终得分。输入每个评委的评分，求某选手的得分。

package com.liudm.demo4;

import java.util.Scanner;

public class zuoye2 {
	public static void main(String[] args) {
		double [] score = new double[10];
		System.out.println("请输入10位评委的打分：");
		for (int i = 0; i < score.length; i++) {
			Scanner input = new Scanner(System.in);
			score[i] = input.nextDouble();
		}
		
		for (int i = 0; i < score.length-i; i++) {
			for (int j = 0; j < score.length-i-1; j++) {
				if (score[j] > score[j+1]) {
					double t;
					t = score[j+1];
					score[j+1] = score[j];
					score[j] = t;
				}
			}			
		}
		System.out.println("去掉一个最低分：" + score[0]);
		System.out.println("去掉一个最高分：" + score[9]);
		double sum = 0;
		for (int i = 1; i <= 8; i++) {
			sum += score[i];
		}
		System.out.print("该选手的最终得分为：" + sum/8);
	}

}

练习5：将一个数组的重复元素保留一个其他的清零（数组遍历、元素访问）。

练习6：给定一维数组{-10,2,4,78,765,9},计算数组中的总和、平均值、最大值、最小值（数组遍历、数组元素访问）。

练习7：现在给出两个数组：数组A：{1,5,8,3,9,65}，数组B：{76,34,23,98}，两个数组合并为数组C，按升序排列。

xjfy.h

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java - 流程控制-循环结构 + 数组

1、流程控制流程控制指的是对java代码执行顺序的控制，在控制中加上我们的逻辑处理，从而完成相应的目标。在java中，流程控制可以分为三类：顺序、分支、循环。顺序执行，表示逐行执行相应的语句，从前往后执行，不涉及任何的关键字分支控制，是条件控制，需要按照判断条件动态的去执行符合条件的语句，if switch 循环控制，则需要按照循环判断条件动态的去执行循环语句，for whil...
复制链接

扫一扫

专栏目录