• Java方法和数组练习

    📋 个人简介
    💖 作者简介：大家好，我是W_chuanqi，一个编程爱好者
    📙 个人主页：W_chaunqi
    😀 支持我：点赞👍+收藏⭐️+留言📝
    💬 愿你我共勉：“没有什么比勇气更温文尔雅，没有什么比怯懦更冷酷无情!”✨✨✨

    Java方法和数组练习

    1.获取每月天数

    根据输入的年份，使用一维数组输出1~12个月每个月份的天数。

    🎇代码实现

    /**
 * @desc 获取每月天数
 * @author 007
 * @date 2022/8/5
 */
import java.util.Scanner;

public class GetDay {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入年份：");
		int year=sc.nextInt();//输入年份
		int day[];
		if(year%4==0&&year%100!=0||year%400==0) {//判断是否为闰年
			System.out.println(year+"年是闰年");
			day=new int[] {31,29,31,30,31,30,31,31,30,31,30,31};
		}else {
			System.out.println(year+"年不是闰年");
			day=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
		}
		System.out.println("----------------------");
		for (int i=0;i<12;i++) {
			System.out.println((i+1)+"月有"+day[i]+"天");
		}
		sc.close();
	}

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    🎇运行结果

    image-20220805210120564

    2.输出矩阵

    在键盘输入矩阵的行数m和列数n，输出一个m行n列都为0的矩阵

    🎇代码实现

    /**
 * @desc 输出矩阵
 * @author 007
 * @date 2022/8/5
 */
import java.util.Scanner;

public class Matrix { // 创建类
	public static void main(String[] args) { // 主方法
		Scanner sc=new Scanner(System.in);
		System.out.println("输入行数："); 
		int m=sc.nextInt();
		System.out.println("输入列数："); 
		int n=sc.nextInt();
		int a[][] = new int[m][n]; // 定义二维数组
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) { // 循环遍历数组中的每个元素
				System.out.print(a[i][j]); // 将数组中的元素输出
			}
			System.out.println(); // 输出空格
		}
		sc.close();
	}
	
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    🎇运行结果

    image-20220805211656707

    3.输出古诗

    创建Poetry类，声明一个字符型二维数组，将古诗《春晓》的内容赋值于二维数组，然后分别用横版和竖版两种方式输出

    🎇代码实现

    /**
 * @desc 输出古诗
 * @author 007
 * @date 2022/8/5
 */
public class Poetry {
	public static void main(String[] args) {
		char arr[][] = new char[4][]; // 创建一个4行的二维数组
		arr[0] = new char[] { '春', '眠', '不', '觉', '晓' }; // 为每一行赋值
		arr[1] = new char[] { '处', '处', '闻', '啼', '鸟' };
		arr[2] = new char[] { '夜', '来', '风', '语', '声' };
		arr[3] = new char[] { '花', '落', '知', '多', '少' };
		/* 横版输出 */
		System.out.println("-----横版-----");
		for (int i = 0; i < 4; i++) { // 循环4行
			for (int j = 0; j < 5; j++) { // 循环5列
				System.out.print(arr[i][j]); // 输出数组中的元素
			}
			if (i % 2 == 0) {
				System.out.println(","); // 如果是一、三句，输出逗号
			} else {
				System.out.println("。"); // 如果是二、四句，输出句号
			}
		}
		/* 竖版输出 */
		System.out.println("\n-----竖版-----");
		for (int j = 0; j < 5; j++) { // 列变行
			for (int i = 3; i >= 0; i--) { // 行变列，反序输出
				System.out.print(arr[i][j]); // 输出数组中的元素
			}
			System.out.println(); // 换行
		}
		System.out.println("。，。，"); // 输出最后的标点
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    🎇运行结果

    在这里插入图片描述

    4.成绩排名

    10名学生在一次英语竞赛中的成绩分别为71、89、67、53、78、64、92、56、74和85，使用冒泡排序编写一个程序，将这10名学生的英语竞赛成绩由小到大进行排序。

    🎇代码实现

    /**
 * @desc 成绩排名
 * @author 007
 * @date 2022/8/7
 */
public class Scores {
	public static void main(String[] args) {
		// 创建一个数组，将10名学生的英语竞赛成绩存储在这个数组里
		int[] array = { 71, 89, 67, 53, 78, 64, 92, 56, 74, 85 };
		// 创建分数类的对象
		Scores scores = new Scores();
		// 调用排序方法将数组排序
		scores.sort(array);
	}

	/**
	 * 冒泡排序
	 * 
	 * @param array 要排序的数组
	 */
	public void sort(int[] array) {
		for (int i = 1; i < array.length; i++) {
			// 比较相邻两个元素，较大的数往后冒泡
			for (int j = 0; j < array.length - i; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j]; // 把第一个元素值保存到临时变量中
					array[j] = array[j + 1]; // 把第二个元素值保存到第一个元素单元中
					array[j + 1] = temp; // 把临时变量（也就是第一个元素原值）保存到第二个元素中
				}
			}
		}
		showArray(array); // 输出冒泡排序后的数组元素
	}

	/**
	 * 显示数组中的所有元素
	 * 
	 * @param array 要显示的数组
	 */
	public void showArray(int[] array) {
		for (int i : array) { // 遍历数组
			System.out.print(" >" + i); // 输出每个数组元素的值
		}
		System.out.println();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    🎇运行结果

    image-20220807152436540

    5.数独

    将 1~9 的数字放入一个 3x3 的数组中，判断数组每行每列以及每个对角线的值相加是否都相同。

    🎇代码实现

    /**
 * @desc 数独
 * @author 007
 * @date 2022/8/7
 */

public class NineGrids {
	public static void main(String[] args) {
		int arr[][] = { { 2, 7, 6 }, { 9, 5, 1 }, { 4, 3, 8 } };

		boolean result = true;
		int sum = arr[0][0] + arr[1][1] + arr[2][2];// 计算一条斜边和
		if (sum != arr[0][2] + arr[1][1] + arr[2][0]) {
			result = false;

		} else {
			for (int x = 0; x < 3; x++) {
				// 计算行、列的和
				if (sum != arr[x][0] + arr[x][1] + arr[x][2] || sum != arr[0][x] + arr[1][x] + arr[2][x]) {
					result = false;
					break;
				}
			}
		}

		if (result) {
			System.out.println("数组行、列、对角线的和相等");
		} else {
			System.out.println("数组行、列、对角线的和不相等");
		}
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    🎇运行结果

    image-20220807153529250

    6.矩阵转置

    交换二维数组int[][] array={{91,25,8},{56,14,2},{47,3,67}};的行、列数据。矩阵转置实际上就是将矩阵的行列进行互换，但主对角线上的元素不发生改变，我们只需要将6个元素的位置进行改变，也就是交换三次。

    🎇代码实现

    /**
 * @desc 矩阵转置
 * @author 007
 * @date 2022/8/7
 */
public class SwapRC {// 交换二维数组的行列数据
	public static void main(String[] args) {
		int i, j;// 定义两个变量，分别用来作为行和列的循环变量
		// 初始化一个静态的int型二维数组
		int[][] array = { { 8, 75, 23 }, { 21, 55, 34 }, { 15, 23, 20 } };
		System.out.println("—————原始数组—————");// 提示信息
		// 遍历原始的二维数组
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				System.out.print(array[i][j] + "\t");// 输出原始数组中的元素
			}
			System.out.println();// 换行
		}
		int temp;// 临时变量
		// 通过循环调换元素的位置
		for (i = 0; i < 3; i++) {
			for (j = 0; j < i; j++) {
				temp = array[i][j];// 把数组元素赋给临时变量
				// 交换行列数据
				array[i][j] = array[j][i];
				array[j][i] = temp;
			}
		}
		System.out.println("——调换位置之后的数组——");// 提示信息
		// 遍历调换位置之后的二维数组
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				System.out.print(array[i][j] + "\t");// 输出调换位置后的数组元素
			}
			System.out.println();// 换行
		}
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    🎇运行结果

    image-20220807155020333

    7.杨辉三角

    使用二维数组实现如下图所示的杨辉三角。

    image-20220807155705351

    🎇代码实现

    /**
 * @desc 杨辉三角
 * @author 007
 * @date 2022/8/7
 */

public class YangHui {// 杨辉三角算法的实现
	public static void main(String[] args) {
		// 定义一个长度为10的二维数组
		int[][] Array_int = new int[10][];
		// 向数组中记录杨辉三角形的值
		for (int i = 0; i < Array_int.length; i++) {// 遍历行数
			Array_int[i] = new int[i + 1];// 定义二维数组的列数
			// 遍历二维数组的列数
			for (int j = 0; j < Array_int[i].length; j++) {
				if (i <= 1) {// 如果是数组的前两行
					Array_int[i][j] = 1;// 将其设置为1
					continue;
				} else {
					// 如果是行首或行尾
					if (j == 0 | j == Array_int[i].length - 1)
						Array_int[i][j] = 1;// 将其设置为1
					else// 根据杨辉算法进行计算
						Array_int[i][j] = Array_int[i - 1][j - 1] + Array_int[i - 1][j];
				}
			}
		}
		for (int i = 0; i < Array_int.length; i++) {// 输出杨辉三角
			for (int j = 0; j < Array_int[i].length; j++)
				System.out.print(Array_int[i][j] + "\t");
			System.out.println();
		}
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    ​ 实现杨辉三角，首先我们先观察到每一行的第1个数和最后1个数都为1，其余的数都是有规律可循的：第n+1行的第i个数等于第n行的第i-1个数和第i个数之和。利用这个性质我们可以构建杨辉三角

    8.推箱子游戏

    编写一个简易的推箱子游戏，使用 10×8 的二维字符数据表示游戏画面，H 表示墙壁；&表示玩家角色；o 表示箱子，*表示目的地。玩家可以通过输入 A、D、W、S 字符控制角色移动，当箱子推到目的地时显示游戏结束，运行结果如下图所示。

    image-20220807162625499

    🎇代码实现

    /**
 * @desc 推箱子游戏
 * @author 007
 * @date 2022/8/7
 */
import java.util.Scanner;

public class Sokoban {

    public static void main(String[] args) {
        char map[][] = new char[8][10];// 地图
        Scanner sc = new Scanner(System.in);// 控制台输入扫描器
        int x = 1, y = 1;// 玩家角色坐标
        boolean finish = false;// 游戏是否结束

        for (int i = 0; i < map.length; i++) {// 地图外边墙壁
            if (i == 0 || i == 7) {
                for (int j = 0; j < map[i].length; j++) {
                    map[i][j] = 'H';
                }
            } else {
                map[i][0] = 'H';
                map[i][9] = 'H';
            }
        }
        map[1][3] = 'H';// 地图内墙壁
        map[2][3] = 'H';
        map[3][3] = 'H';
        map[2][5] = 'H';
        map[3][5] = 'H';
        map[3][6] = 'H';
        map[3][8] = 'H';
        map[4][8] = 'H';
        map[6][4] = 'H';
        map[5][4] = 'H';
        map[5][5] = 'H';
        map[5][6] = 'H';
        map[x][y] = '&';// 玩家角色
        map[2][2] = 'o';// 箱子
        map[6][5] = '*';// 目的地

        while (true) {// 循环游戏
            /* 打印游戏画面 */
            System.out.println("--------------------");
            for (char row[] : map) {
                for (char column : row) {
                    System.out.print(column + " ");
                }
                System.out.println();
            }
            System.out.println("--------------------");

            if (finish) {// 如果游戏结束则停止循环
                break;
            }

            System.out.println("A左移，D右移，W上移，S下移，请输入你的指令：");
            String code = sc.nextLine();// 获取玩家输入的指令

            switch (code.toLowerCase()) {// 将执行转为小写并判断
                case "a" :// 如果输入的是a
                    if (map[x][y - 1] == 0) {// 如果玩家左边是空区
                        map[x][y] = 0;// 原位置变为空区
                        map[x][y - 1] = '&';// 玩家移动到新位置
                        y--;// 玩家坐标左移
                    } else if (map[x][y - 1] == 'o') {// 如果玩家左边是箱子
                        if (map[x][y - 2] != 'H') {// 如果箱子左边不是墙
                            if (map[x][y - 2] == '*') {// 如果箱子左边是目的地
                                finish = true;// 游戏结束
                            }
                            map[x][y] = 0;// 原位置变为空区
                            map[x][y - 1] = '&';// 玩家移动到新位置
                            map[x][y - 2] = 'o';// 箱子移动到新位置
                            y--;// 玩家位置左移
                        }
                    }
                    break;// 结束判断
                case "d" :// 如果输入的是d
                    if (map[x][y + 1] == 0) {// 如果玩家右边是空区
                        map[x][y] = 0;// 原位置变为空区
                        map[x][y + 1] = '&';// 玩家移动到新位置
                        y++;// 玩家坐标右移
                    } else if (map[x][y + 1] == 'o') {// 如果玩家右边是箱子
                        if (map[x][y + 2] != 'H') {// 如果箱子右边不是墙
                            if (map[x][y + 2] == '*') {// 如果箱子右边是目的地
                                finish = true;// 游戏结束
                            }
                            map[x][y] = 0;// 原位置变为空区
                            map[x][y + 1] = '&';// 玩家移动到新位置
                            map[x][y + 2] = 'o';// 箱子移动到新位置
                            y++;// 玩家坐标右移
                        }
                    }
                    break;// 结束判断
                case "w" :// 如果输入的是w
                    if (map[x - 1][y] == 0) {// 如果玩家上方是空区
                        map[x][y] = 0;// 原位置变为空区
                        map[x - 1][y] = '&';// 玩家移动到新位置
                        x--;// 玩家坐标上移
                    } else if (map[x - 1][y] == 'o') {// 如果玩家上方是箱子
                        if (map[x - 2][y] != 'H') {// 如果箱子上方不是墙
                            if (map[x - 2][y] == '*') {// 如果箱子上方是目的地
                                finish = true;// 游戏结束
                            }
                            map[x][y] = 0;// 原位置变为空区
                            map[x - 1][y] = '&';// 玩家移动到新位置
                            map[x - 2][y] = 'o';// 箱子移动到新位置
                            x--;// 玩家坐标上移
                        }
                    }
                    break;// 结束判断
                case "s" :// 如果输入的是s
                    if (map[x + 1][y] == 0) {// 如果玩家下方是空区
                        map[x][y] = 0;// 原位置变为空区
                        map[x + 1][y] = '&';// 玩家移动到新位置
                        x++;// 玩家坐标下移
                    } else if (map[x + 1][y] == 'o') {// 如果玩家下方是箱子
                        if (map[x + 2][y] != 'H') {// 如果箱子下方不是墙
                            if (map[x + 2][y] == '*') {// 如果箱子下方是目的地
                                finish = true;// 游戏结束
                            }
                            map[x][y] = 0;// 原位置变为空区
                            map[x + 1][y] = '&';// 玩家移动到新位置
                            map[x + 2][y] = 'o';// 箱子移动到新位置
                            x++;// 玩家坐标下移
                        }
                    }
                    break;// 结束判断
                default :// 如果输入的是其他指令
                    System.out.println("您输入的指令有误！");
            }

        }
        System.out.println("游戏结束");
        sc.close();
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139

    9.五子棋游戏

    编写一个简易五子棋游戏，棋盘在控制台上绘制，棋盘每一个点都有对应的坐标，下棋者输入两位数字表示落棋子的坐标。其中，第一个数字表示横坐标，第二个数字表示纵坐标，运行结果如图所示。

    image-20220807164005853

    🎇代码实现

    /**
 * @desc 简易五子棋
 * @author 007
 * @date 2022/8/7
 */
import java.util.Arrays;
import java.util.Scanner;

public class Gobang {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        boolean finish = false; // 游戏是否结束
        int turn = 1; // 当前下棋者标记,1则PLAYER1下棋，-1则PLAYER2下棋
        int x = 0, y = 0; // 当前棋子的横纵坐标
        final char PLAYER1 = '*';// 玩家1使用的字符
        final char PLAYER2 = 'o';// 玩家2使用的字符
        final char EMPTY = '-';// 空棋盘使用的字符

        /* 棋盘初始化 */
        char checkerboard[][] = new char[10][10];
        for (int i = 0; i < checkerboard.length; i++) {
            Arrays.fill(checkerboard[i], EMPTY);
        }

        game : while (!finish) {
            /* 打印棋盘 */
            System.out.println("---------------------");
            System.out.println("  0 1 2 3 4 5 6 7 8 9");
            for (int i = 0; i < checkerboard.length; i++) {
                System.out.print(i + " ");
                for (int j = 0; j < checkerboard[i].length; j++) {
                    System.out.print(checkerboard[i][j] + " ");
                }
                System.out.println();
            }
            System.out.println("---------------------");

            /* 判断当前下棋者 */
            if (turn == 1) {
                System.out.println("请" + PLAYER1 + "输入棋子坐标：");
            } else {
                System.out.println("请" + PLAYER2 + "输入棋子坐标：");
            }

            /* 输入棋子坐标 */
            String str = sc.nextLine();

            x = Integer.parseInt(String.valueOf(str.charAt(0)));
            y = Integer.parseInt(String.valueOf(str.charAt(1)));

            /* 判断坐标是否在棋盘之内 */
            if (x < 0 || x > 8 || y < 0 || y > 8) {
                System.out.println("***您输入的坐标有误请重新输入！***");
                continue;
            }

            /* 判断坐标上是否有棋子 */
            if (checkerboard[x][y] == EMPTY) {
                if (turn == 1) {
                    checkerboard[x][y] = PLAYER1;
                } else {
                    checkerboard[x][y] = PLAYER2;
                }
            } else {
                System.out.println("***您输入位置已经有其他棋子，请重新选择！***");
                continue;
            }

            /* 五子棋输赢算法那*/
            for (int i = 0; i < checkerboard.length; i++) {
                for (int j = 0; j < checkerboard[i].length; j++) {
                    char flagch = checkerboard[i][j];
                    if (flagch == EMPTY) {// 如果此处没有棋子
                        continue;// 不进行输赢判断
                    }
                    /* 判断棋子左侧 */
                    if (y - 4 >= 0) {
                        if (checkerboard[i][j - 1] == flagch
                                && checkerboard[i][j - 2] == flagch
                                && checkerboard[i][j - 3] == flagch
                                && checkerboard[i][j - 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }

                    /* 判断棋子右侧 */
                    if (y + 4 <= 9) {
                        if (checkerboard[i][j + 1] == flagch
                                && checkerboard[i][j + 2] == flagch
                                && checkerboard[i][j + 3] == flagch
                                && checkerboard[i][j + 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子上方 */
                    if (x - 4 >= 0) {
                        if (checkerboard[i - 1][j] == flagch
                                && checkerboard[i - 2][j] == flagch
                                && checkerboard[i - 3][j] == flagch
                                && checkerboard[i - 4][j] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子下方 */
                    if (x + 4 <= 9) {
                        if (checkerboard[i + 1][j] == flagch
                                && checkerboard[i + 2][j] == flagch
                                && checkerboard[i + 3][j] == flagch
                                && checkerboard[i + 4][j] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子西北 */
                    if (x - 4 >= 0 && y - 4 >= 0) {
                        if (checkerboard[i - 1][j - 1] == flagch
                                && checkerboard[i - 2][j - 2] == flagch
                                && checkerboard[i - 3][j - 3] == flagch
                                && checkerboard[i - 4][j - 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子西南 */
                    if (x + 4 <= 9 && y - 4 >= 0) {
                        if (checkerboard[i + 1][j - 1] == flagch
                                && checkerboard[i + 2][j - 2] == flagch
                                && checkerboard[i + 3][j - 3] == flagch
                                && checkerboard[i + 4][j - 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子东北 */
                    if (x - 4 >= 0 && y + 4 <= 9) {
                        if (checkerboard[i - 1][j + 1] == flagch
                                && checkerboard[i - 2][j + 2] == flagch
                                && checkerboard[i - 3][j + 3] == flagch
                                && checkerboard[i - 4][j + 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                    /* 判断棋子东南 */
                    if (x + 4 <= 9 && y + 4 <= 9) {
                        if (checkerboard[i + 1][j + 1] == flagch
                                && checkerboard[i + 2][j + 2] == flagch
                                && checkerboard[i + 3][j + 3] == flagch
                                && checkerboard[i + 4][j + 4] == flagch) {
                            finish = true;
                            break game;
                        }
                    }
                }
            }
            turn *= -1; // 更换下棋者标记
        }

        /* 输出最后胜利的棋盘 */
        System.out.println("---------------------");
        System.out.println("  0 1 2 3 4 5 6 7 8 9");
        for (int i = 0; i < checkerboard.length; i++) {
            System.out.print(i + " ");
            for (int j = 0; j < checkerboard[i].length; j++) {
                System.out.print(checkerboard[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("---------------------");
        /* 输出赢家 */
        if (turn == 1) {
            System.out.println("*棋胜利！");
        } else {
            System.out.println("o棋胜利！");
        }
        sc.close();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183

    10.统计学生成绩

    输入学生的学号及语文、数学、英语成绩，输出学生各科成绩信息、平均成绩和总成绩。

    🎇代码实现

    /**
 * @desc 统计学生成绩
 * @author 007
 * @date 2022/8/7
 */
import java.util.Scanner;

public class SchoolReport {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入本班学生总数：");
		int studentcout = sc.nextInt();
		int achivement[][] = new int[studentcout][4];
		for (int i = 0; i < studentcout; i++) {
			System.out.println("请输入第" + (i + 1) + "个学生的编号：");
			achivement[i][0] = sc.nextInt();
			System.out.println("请输入语文成绩：");
			achivement[i][1] = sc.nextInt();
			System.out.println("请输入数学成绩：");
			achivement[i][2] = sc.nextInt();
			System.out.println("请输入英语成绩：");
			achivement[i][3] = sc.nextInt();
		}
		System.out.println("学生成绩结果如下");
		System.out.println("---------------------------------------------");
		System.out.println("学生编号\t语文成绩\t数学成绩\t英语成绩\t平均成绩\t总成绩");

		for (int i = 0; i < achivement.length; i++) {
			double sum = 0;	//总成绩
			double ave = 0;	//平均成绩
			for (int j = 0; j < achivement[i].length; j++) {
				System.out.print(achivement[i][j] + "\t");
				if (j > 0) {
					sum += achivement[i][j];
				}
			}
			ave = sum / 3;
			System.out.print(String.format("%.2f", ave) + "\t" + (int) sum
					+ "\n");
		}
		sc.close();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    🎇运行结果

    image-20220807165601366

    11.自动批卷程序

    现有学号为1~8的8名学生和10道题目(标准答案为{ “B”, “A”,“ D”, “C”, “C”, “B”, “C”, “A”, “D”, “B” })，将学生的答案储存在一个二维数组中通过学号找到并输出该学生的答案以及回答正确的题目总数。

    🎇代码实现

    /**
 * @desc 自动批卷程序
 * @author 007
 * @date 2022/8/7
 */
import java.util.Scanner;
public class Answers {// 创建Scores类
	public static void main(String[] args) {
		// 初始化String类型的一维数组（设为题目的标准答案）
		char right[] = { 'B', 'A', 'D', 'C', 'C', 'B', 'C', 'A', 'D', 'B' };
		// 初始化String类型的二维数组（记录8名学生的答案）
		char choice[][] = {
				{ 'B', 'A', 'D', 'C', 'A', 'B', 'C', 'C', 'D', 'B' },
				{ 'B', 'A', 'D', 'B', 'A', 'B', 'C', 'A', 'C', 'B' },
				{ 'A', 'A', 'D', 'C', 'B', 'A', 'C', 'A', 'D', 'B' },
				{ 'B', 'C', 'D', 'C', 'A', 'B', 'C', 'B', 'D', 'A' },
				{ 'B', 'C', 'D', 'A', 'C', 'B', 'D', 'A', 'D', 'A' },
				{ 'B', 'A', 'D', 'A', 'C', 'B', 'D', 'A', 'C', 'B' },
				{ 'A', 'B', 'A', 'C', 'D', 'B', 'C', 'A', 'D', 'B' },
				{ 'B', 'A', 'D', 'C', 'D', 'B', 'A', 'C', 'D', 'B' }};
		while (true) {// 实现多次控制台输入信息
			System.out.println("您想调取第几位学生的答题结果"
							 + "(有效数字为1至8)：");// 提示信息
			Scanner sc = new Scanner(System.in);// 控制台输入
			int num = sc.nextInt();// 接收控制台输入的信息
			int sum = 0;// 声明int类型的全局变量sum（答对的题目总数）
			System.out.println("第" + num + "位同学的全部答案为：");// 提示信息
			for (int j = 0; j < choice[num - 1].length; j++) {
				System.out.print(choice[num - 1][j] + " ");// 输出数组的元素
				// 判断键入的信息是否为正确答案
				if (choice[num - 1][j] == right[j]) {
					sum++;// 答对的题目总数
				}
			}
			System.out.println();// 换行
			// 控制台输出答对的题目总数
			System.out.println("第" + num + "位同学一共答对了" + sum 
							 + "道题" + "\n");
		}
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    🎇运行结果

    在这里插入图片描述

    12.登录注册小程序

    🎇任务描述

    编写程序实现简单的登录注册功能。程序包含以下4个功能：

    （1）登录功能，用户输入正确的账号密码进行成功；

    （2）注册功能，输入用户名和密码进行注册；

    （3）查看功能，查看所有的用户名与密码；

    （4）退出功能，退出系统。

    用户可以输入对应的编号进行相应的功能操作。例如，输入2进入注册功能，输入用户名和密码进行注册。

    🎇思路分析

    (1) 在存储账号密码时，如果对每一个用户的账号密码都定义两个变量存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，可以使用数组解决多个数据的存储问题。创建一个可以存储多个用户账号数组和一个可以存储多个用户密码的数组。需要注意的是，需要在两个数组前加上static属性，这样做是为了让本类都可以使用到这两个数组。

    (2) 从运行结果可以看出，我们首先打印出了可以操作的列表以及序列号，我们可以定print方法来实现打印。

    (3) 从运行结果可以看出，查看功能是将已有的用户信息打印，我们需要使用for循环打印我们已有的账号数组和密码数组。

    (4) 注册功能是在定义好的账号数组和密码数组添加新的数据，这里我们会需要的增加账号和密码数组的长度。增加原有数组长度时，需要先定义两组新的数组，在原有数组的长度上增加长度，并将原有的数组复制进新的数组。

    将原有的数组复制进新的数组时需要使用到System的arraycopy方法，arraycopy方法的用法如下所示。

       arrayCopy(arr1, 2, arr2, 5, 10);

    • 1

    此句代码是将arr1数组里从索引为2的元素开始, 复制到数组arr2里的索引为5的位置, 复制的元素个数为10个。

    (5) 登录功能可以使用for循环判断用户输入的字符与数组中的字符是否匹配，以此来判断是否登录成功。

    (6) 退出功能可以使用System的exit方法。

    (7) "登录注册"程序明确的分为4个功能，如果将多个独立的功能代码写在一起，代码将会相对冗长，可以使用针对不同功能将其封装到不同的方法中，将完整独立的功能分离出来，然后只需要在程序的main()方法中调用方法即可。

    🎇代码实现

    /**
 * @desc 登录注册小程序
 * @author 007
 * @date 2022/8/5
 */
import java.util.Scanner;

public class user {
	// 存储用户名和密码
	public static String arr1[] = new String[3];
	public static String arr2[] = new String[3];
	static int index = 0;

	public static void main(String[] args) {
		arr1[0] = "zhangsan";
		arr2[0] = "123456";
		while (true) {
			print();
			Scanner scan = new Scanner(System.in);
			System.out.println("请选择功能：");
			String str = scan.next();
			if (str.equals("1")) {
				login();
			} else if (str.equals("2")) {
				register();
			} else if (str.equals("3")) {
				show(); // 用户退出
				break;
			} else if (str.equals("0")) {
				System.exit(0);
			} else {
				System.out.println("输入错误");
			}
		}
	}

	/*
	 * 登录功能，键盘输入用户名与密码 使用for循环加if判断验证输入的用户名与密码是否正确
	 */
	public static void login() {
		for (int i = 0; i < 3; i++) {
			Scanner scan1 = new Scanner(System.in);
			System.out.println("请输入用户名：");
			String str1 = scan1.next();
			Scanner scan2 = new Scanner(System.in);
			System.out.println("请输入密码：");
			String str2 = scan2.next();
			for (int i1 = 0; i1 < arr2.length; i1++) {
				if (str1.equals(arr1[i1]) && str2.equals(arr2[i1])) {
					System.out.println("登录成功！");
					return;
				}
			}
			System.out.println("登录失败，请重新输入！");
		}
	}

	/*
	 * 注册功能，键盘输入用户名与密码 定义一个boolean变量，使用for循序判断用户是否存在 如果用户不存在，在数组中插入注册的账号密码时
	 * 可能会有数组长度不够的情况，所以需要使用到 增加数组的长度，这里调用增加数组长度的方法add()。
	 */
	public static void register() {
		Scanner scan1 = new Scanner(System.in);
		System.out.println("请输入用户名：");
		String str1 = scan1.next();
		Scanner scan2 = new Scanner(System.in);
		System.out.println("请输入密码：");
		String str2 = scan2.next();
		boolean flag = true;
		for (int i = 0; i < arr1.length; i++) {
			if (str1.equals(arr1[i])) {
				System.out.println("用户名已存在");
				flag = false;
			}
		}
		if (flag == true) {
			index++;
			if (index < arr1.length) {
				arr1[index] = str1;
				arr2[index] = str2;
				System.out.println("注册成功！");
			} else {
				add();
				arr1[index] = str1;
				arr2[index] = str2;
				System.out.println("注册成功！");
			}
		}
	}

	/*
	 * 查看功能 使用for循环打印两个数组的长度
	 */
	public static void show() {
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != null) {
				System.out.println("用户名：" + arr1[i] + "," + "密码：" + arr2[i] + "\n");
			}
		}
	}

	/*
	 * 增加数组长度 先定义两个新的数组并在原有的数组长度上加3 使用System的arraycopy方法复制原有的数组到新的数组
	 * 最后将新的数组赋值给原有的arr1与aar2
	 */
	public static void add() {
		String newarray1[] = new String[arr1.length + 3];
		String newarray2[] = new String[arr1.length + 3];
		System.arraycopy(arr1, 0, newarray1, 0, arr1.length);
		System.arraycopy(arr2, 0, newarray2, 0, arr1.length);
		arr1 = newarray1;
		arr2 = newarray2;
		show();
	}

	/*
	 * 可操作功能的显示
	 */
	public static void print() {
		System.out.println("--------------------账户管理系统--------------------");
		System.out.println(" 1.登录功能 (login) ");
		System.out.println(" 2.注册功能(register) ");
		System.out.println(" 3.查看(show) ");
		System.out.println(" 0.退出(exit) ");
		System.out.println("--------------------账户管理系统--------------------");
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128

    🎇运行结果

    image-20220805162624683

    image-20220805162642360

    image-20220805162721558

    13.抽取幸运观众

    🎇任务描述

    在一些节目活动中，经常会有抽取幸运观众环节。本案例要求编写程序实现幸运观众的抽取，在指定人群中随机抽取一名幸运观众。

    案例功能要求如下：

    （1） 从键盘输入3名观众。

    （2） 存储观众姓名。

    （3） 总览观众姓名。

    （4）随机选取一名观众，并打印出该观众姓名。

    🎇思路分析

    (1) 在存储观众姓名时，如果对每个观众都定义一个变量进行姓名存储，则会出现过多鼓励的变量，很难一次性将全部数据持有。此时，可以使用数组解决多个数据的存储问题。创建一个可以存储多个观众姓名的数组，这里我们设置数组的长度为3。

    (2) 键盘输入观众姓名。将输入的姓名依次赋值给数组各元素，此时便存储了所有观众姓名。键盘输入需要使用Scanner类，以下代码能够从键盘输入中读取一个字符串。

    Scanner sc=new Scanner(System.in);
String str=sc.next()；

    • 1
    • 2

    (3) 对数组进行遍历，打印出数组每个元素的值，即实现了对每个观众姓名的总览。

    (4) 根据数组长度，获取随机索引，这里我们的数组长度为3，所以获取的随机索引只能在0-2之间，通过随机索引获取数组中的姓名，该姓名也就是随机的姓名。获取随机索引可以使用Random类中的nextInt(int n）方法。

    (5) "抽取幸运观众"明确第分为了3个功能，如果将多个独立功能的代码写在一起，代码相对冗长，可以针对不同的功能将其封装到不同的方法中，将完整独立的功能分离出来，然后只需要在程序的main()方法中调用这3个方法即可。

    🎇代码实现

    /**
 * @desc 抽取幸运观众
 * @author 007
 * @date 2022/8/5
 */
import java.util.Random;
import java.util.Scanner;

public class audience {
	/*
	 * 存储姓名 创建一个存储多个姓名的容器（数组） 键盘输入每个同学的姓名，存储到容器中（数组）
	 */
	public static void addAudience(String[] audience) {
		// 键盘输入多个姓名到容器中
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < audience.length; i++) {
			System.out.println("存储第" + (i + 1) + "个姓名：");
			// 接收控制台录入的姓名字符串
			audience[i] = sc.next();
		}
		sc.close();
	}

	/*
	 * 总览全部姓名
	 */
	public static void printAudience(String[] audience) {
		// 遍历数组，得到每个观众姓名
		for (int i = 0; i < audience.length; i++) {
			String name = audience[i];
			System.out.println("第" + (i + 1) + "个观众姓名:" + name);
		}
	}

	/*
	 * 随机点名
	 */
	public static String randomAudience(String[] audience) {
		// 根据数组的长度，获取睡觉索引
		int index = new Random().nextInt(audience.length);
		// 通过随机索引从数组中获取姓名
		String name = audience[index];
		// 返回随机到的姓名
		return name;
	}

	public static void main(String[] args) {
		System.out.println("--------抽取幸运观众---------");
		// 创建一个长度为3的数组存储观众姓名
		String[] audience = new String[3];
		// 存储观众姓名
		addAudience(audience);
		// 总览观众姓名
		printAudience(audience);
		// 随机抽取一名幸运观众
		String randomName = randomAudience(audience);
		System.out.println("随机抽取的幸运观众是：" + randomName);
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    🎇运行结果

    image-20220805203728376

  • 相关阅读:
    WuThreat身份安全云-TVD每日漏洞情报-2023-10-11
    Java练手任务总结【18】
    练习31-35：多表关联查询、多条件自连接查询、子查询、窗口函数等
    字符串压缩（一）之ZSTD
    3126: 【C2】【结构体】小明做调查
    城镇供水产销差问题分析与对策
    AWS:EC2实例创建步骤
    细说MySQL数据类型
    TCP三次握手四次分手不一样的解释
    哪个版本的JVM最快？
  • 原文地址：https://blog.csdn.net/W_chuanqi/article/details/126213869