Java基础-数组循环综合练习2

已于 2023-05-15 16:28:54 修改
阅读量535 收藏 4
点赞数 1
分类专栏： JavaSE笔记 文章标签： java 算法 数据结构
于 2023-05-15 16:27:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52699757/article/details/130687369
版权

练习六：数字加密

需求：

​ 某系统的数字密码（大于0），比如1983，采用加密方式进行传输。

规则如下：

​ 先得到每位数，然后每位数都加上5 , 再对10求余，最后将所有数字反转，得到一串新数。

举例：

		1	9	8	3
+5		6   14  13  8
%10		6   4   3   8
反转	   8   3   4   6
加密后的结果就是：8346

代码示例：

package com.iflytek.day09;

import java.util.Scanner;

/**
 *  某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
 *  规则如下：
 *      每位数加上5
 *      再对10求余，
 *      最后将所有数字反转，
 *      得到一串新数。
 */
public class Test6 {
    public static void main(String[] args) {

        //1.把整数里面的每一位放到数组当中
        int[] arr = {1, 9, 8, 3};
        //2.加密
        //每位数加上5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
        }
        //再对10求余，
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10;
        }
        //将所有数字反转
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //8 3 4 6 --> 8346
        //3.把数组里面的每一个数字进行拼接，变成加密之后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
        System.out.println(number);
    }
}

练习六扩展：

需求：

把一个正整数转换成数组，也就是把整数上的每一位都添加到数组当中

 int number = 12345;
 转换为
 int[] arr = {1,2,3,4,5};

代码：

package com.iflytek.day09;

public class Test6_1 {
    public static void main(String[] args) {
       
        //反向推导
        //1.计算出数组的长度
        int number = 12345;
        //定义一个变量临时记录number的值，就是为了第三步的时候再次使用
        int temp = number;
        //定义一个变量进行统计
        int count = 0;
        while(number != 0){
            //每一次循环就去掉右边的一个数字
            number = number / 10;
            //去掉一位计数器就自增一次。
            count++;
        }
        //2.定义数组
        //动态初始化
        int[] arr = new int[count];
        //3.把整数上的每一位都添加到数组当中
        int index = arr.length -1;
        while(temp != 0){//12345
            //获取temp里面的每一位数组
            int ge = temp % 10;
            //再去掉右边的那位数字
            temp = temp / 10;
            //把当前获取到的个位添加到数组当中
            arr[index] = ge;
            index--;
        }
        //验证结果  1  2  3  4 5
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

其它实现方式：

package com.iflytek.day09;

public class Test6_2 {
    public static void main(String[] args) {

        //1.整数转字符串，遍历字符串，放置到新的数组中
        int number = 12345;
        String numStr = String.valueOf(number);
        int[] numArr = new int[numStr.length()];
        for (int i = 0; i < numStr.length(); i++) {
            numArr[i] = Integer.parseInt(String.valueOf(numStr.charAt(i)));
        }

        //验证结果  1  2  3  4 5
        for (int i = 0; i < numArr.length; i++) {
            System.out.print(numArr[i] + " ");
        }
    }
}

练习七：数字解密

需求：

把上一题加密之后的数据进行解密

比如1983加密之后变成8346，解密之后变成1983

代码示例：

package com.iflytek.day09;

/*某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
    规则如下：
        每位数加上5
        再对10求余，
        最后将所有数字反转，
        得到一串新数。
        按照以上规则进行解密：
        比如1983加密之后变成8346，解密之后变成1983
*/

public class Test7 {
    public static void main(String[] args) {

        //1.定义数组记录解密之后的结果
        int[] arr = {8, 3, 4, 6};
        //2.反转
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //3.由于加密是通过对10取余的方式进行获取的
        //所以在解密的时候就需要判断，0~4之间+10  5~9数字不变
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= 0 && arr[i] <= 4) {
                arr[i] = arr[i] + 10;
            }
        }
        //4.每一位减5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] - 5;
        }
        //5.获取数组里面的每一位数字拼接成最终的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
        System.out.println(number);

    }
}

练习六-七代码整合

package com.iflytek.day09;

public class Test {

    public static void main(String[] args) {

        int num = 1983;
//        int2Arr(num);
//        reverse(int2Arr(num));
        int encodeNum = encode(num);
        System.out.println(encodeNum);
        int decodeNum = decode(encodeNum);
        System.out.println(decodeNum);

    }

    /**
     * 1. 明确参数
     * 2. 明确返回值
     * 3. 起一个见名知意的方法名
     */

    /**
     * 整数转换为数组形式
     *
     * @param num 待转换的整数
     * @return 转换之后的数组
     */
    public static int[] int2Arr(int num) {

        int tempNum = num;
        // 例如：num-> 12345

        // 取得数字的长度
        int count = 0;
        while (tempNum != 0) {
            tempNum = tempNum / 10;
            count++;
        }

        // 根据数字的长度，构建出数组
        int[] arr = new int[count];
        // 12345%10 = 5 12345/10=1234
        // 1234%10 = 4 1234/10=123
        for (int i = arr.length - 1; i >= 0; i--) {
            arr[i] = num % 10;
            num = num / 10;
        }
        return arr;
    }


    // 2. 加密
    public static int encode(int num) {
        int[] arr = int2Arr(num);
        // 1. +5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
        }
        // 2. %10
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10;
        }
        // 3. 反转
        arr = reverse(arr);

        // 4. 数组转数字
        // 1 9 8 3
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            str += arr[i];
        }
        return Integer.parseInt(str);
    }


    public static int[] reverse(int[] arr) {

        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        return arr;
    }


    // 3. 解密
    public static int decode(int num) {
        int[] arr = int2Arr(num);
        // 1. 反转
        arr = reverse(arr);
        // 2. +10
        // 0-9 5-9=>10->14 0-4的需要+10
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= 0 && arr[i] <= 4) {
                arr[i] = arr[i] + 10;
            }
        }
        // 3. -5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] - 5;
        }

        //
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            str += arr[i];
        }
        return Integer.parseInt(str);
    }

}

练习八：抽奖

需求：

​ 一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：（随机顺序，不一定是下面的顺序）

888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出

解法一:

package com.iflytek.day09;

import java.util.Random;
/* 需求：
    一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
    请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
    打印效果如下：（随机顺序，不一定是下面的顺序）
        888元的奖金被抽出
        588元的奖金被抽出
        10000元的奖金被抽出
        1000元的奖金被抽出
        2元的奖金被抽出
    */
public class Test8 {
    public static void main(String[] args) {
        //1.定义数组表示奖池
        int[] arr = {2, 588, 888, 1000, 10000};
        //2.定义新数组用于存储抽奖的结果
        int[] newArr = new int[arr.length];
        //3.抽奖
        Random r = new Random();
        //因为有5个奖项，所以这里要循环5次
        for (int i = 0; i < 5; ) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //获取奖项
            int prize = arr[randomIndex];
            //判断当前的奖项是否存在，如果存在则重新抽取，如果不存在，就表示是有效奖项
            boolean flag = contains(newArr, prize);
            if(!flag){
                //把当前抽取到的奖项添加到newArr当中
                newArr[i] = prize;
                //添加完毕之后，移动索引
                i++;
            }
        }
        //4.遍历newArr
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }

    }

    //判断prize在数组当中是否存在
    //存在：true
    //不存在：false
    public static boolean contains(int[] arr,int prize){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == prize){
                return true;
            }
        }
        return false;
    }


}

解法二：

package com.iflytek.day09;

import java.util.Random;
/* 需求：
   一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
   请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
   打印效果如下：（随机顺序，不一定是下面的顺序）
       888元的奖金被抽出
       588元的奖金被抽出
       10000元的奖金被抽出
       1000元的奖金被抽出
       2元的奖金被抽出
*/
public class Test8_1 {
    public static void main(String[] args) {
        //1.把奖池里面的所有奖项打乱顺序
        int[] arr = {2, 588, 888, 1000, 10000};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着i跟随机索引randomIndex上的值进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        //2.遍历奖池,从0索引开始获取每一个奖项
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

练习九：双色球

需求

由系统随机6个红球 1个蓝球，红球范围在1-33，蓝球范围在1-16，红球每个数不能重复，蓝球可以与红球重复。由用户输入7个号码，来进行判断。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4dViQULs-1684139236340)(assets\图片1.png)]

需求分析

  1. 生成中奖号码
  2. 用户输入彩票号码，校验重复情况
  3. 判断用户的中奖情况

代码示例:

package com.iflytek.day09;

import java.util.Random;
import java.util.Scanner;

public class Test9 {
    public static void main(String[] args) {
        //1.生成中奖号码
        int[] arr = createNumber(); // 123456  7
        System.out.println("=======================");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("\n=======================");
        //2.用户输入彩票号码（红球 + 蓝球）//654321
        int[] userInputArr = userInputNumber();

        //3.判断用户的中奖情况
        //红球 蓝球
        int redCount = 0;
        int blueCount = 0;

        //判断红球
        for (int i = 0; i < userInputArr.length - 1; i++) {
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length - 1; j++) {
                if(redNumber == arr[j]){
                    redCount++;
                    //如果找到了，那么后面的数字就没有必要继续比较了
                    //跳出内循环，继续判断下一个红球号码是否中奖
                    break;
                }
            }
        }

        //判断蓝球
        int blueNumber = userInputArr[userInputArr.length-1];
        if(blueNumber == arr[arr.length - 1]){
            blueCount++;
        }

        //根据红球的个数以及蓝球的个数来判断中奖情况
        if(redCount == 6 && blueCount == 1){
            System.out.println("恭喜你，中奖1000万");
        }else if(redCount == 6 && blueCount == 0){
            System.out.println("恭喜你，中奖500万");
        }else if(redCount == 5 && blueCount == 1){
            System.out.println("恭喜你，中奖3000");
        }else if((redCount == 5 && blueCount == 0) ||  (redCount == 4 && blueCount == 1)){
            System.out.println("恭喜你，中奖200");
        }else if((redCount == 4 && blueCount == 0) ||  (redCount == 3 && blueCount == 1)){
            System.out.println("恭喜你，中奖10");
        }else if((redCount == 2 && blueCount == 1) ||  (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
            System.out.println("恭喜你，中奖5");
        }else{
            System.out.println("谢谢参与，谢谢惠顾");
        }

    }

    public static int[] userInputNumber() {
        //1.创建数组用于添加用户购买的彩票号码
        //6个红球 1个蓝球 数组长度：7
        int[] arr = new int[7];
        //2.利用键盘录入让用输入
        Scanner sc = new Scanner(System.in);
        //让用户输入红球号码
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球号码");
            int redNumber = sc.nextInt();
            //redNumber  在1~33  唯一不重复
            if (redNumber >= 1 && redNumber <= 33) {
                boolean flag = contains(arr, redNumber);
                if (!flag) {
                    //不存在
                    //有效的，可以添加到数组当中
                    arr[i] = redNumber;
                    i++;
                } else {
                    //存在
                    System.out.println("当前红球号码已经存在，请重新输入");
                }
            } else {
                System.out.println("当前红球号码超出范围");
            }
        }

        //让用户输入篮球号码
        System.out.println("请输入篮球号码");
        //1~16
        while (true) {
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[arr.length - 1] = blueNumber;
                break;
            } else {
                System.out.println("当前篮球号码超出范围");
            }
        }
        return arr;

    }

    public static int[] createNumber() {
        //1.创建数组用于添加中奖号码
        //6个红球 1个蓝球 数组长度：7
        int[] arr = new int[7];

        //2.随机生成号码并添加到数组当中
        //红球：不能重复的  1 2 3 4 5 6
        //蓝球：可以跟红球号码重复 5

        //生成红球号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber);
            if (!flag) {
                //把红球号码添加到数组当中
                arr[i] = redNumber;
                i++;
            }
        }

        //生成蓝球号码并添加到数组当中
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;
        return arr;
    }

    //用于判断数组在数组中是否存在
    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

二维数组

二维数组就是存储一维数组(内存地址/引用)的数组

二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组）

二维数组的定义

int[][] a=new int[10][10];
String[][] b=new String[10][10];

初始化二维数组

//静态初始化
int[][] a={{1,2,3,4},{4,5,6,7},{8,9,10,11}};
//动态初始化
String[][] b=new String[10][10];
b[0]=new String[]{"zahngsan","lisi","wangwu"};
b[1]=new String[]{"java","python","c++"};

二维数组的遍历

package com.iflytek.day09;

public class TwoDimensionDemo1 {
    public static void main(String[] args) {

        //1.二维数组静态初始化格式
        //数据类型[][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1, 元素2}};
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}};
        int[][] arr2 = {{1, 2, 3}, {4, 5, 6, 7, 8}};
        //以后建议这样定义，把每一个一维数组，单独写成一行
        //注意：每一个一维数组其实是二维数组中的元素，所以每一个一维数组之间需要用逗号隔开。最后一个一维数组后面不需要加逗号
        int[][] arr3 = {
                {1, 2, 3},
                {4, 5, 6, 7, 8}
        };
        //2.获取元素
        //arr[i][j]
        //arr：二维数组
        //i：二维数组的索引，获取出来的是里面的一维数组
        //j：表示一维数组中的索引，获取出来的就是真正的元素

        System.out.println(arr3);//表示获取二维数组中的第一个一维数组
        System.out.println(arr3[0]);//表示获取二维数组中的第一个一维数组
        //arr3[0]:二维数组中的第一个一维数组
        //arr3[0][0]：获取第一个一维数组中0索引的元素
        System.out.println(arr3[0][0]);//1
        System.out.println(arr3[1][4]);//打印数字8
//        System.out.println(arr3[2][0]);//ArrayIndexOutOfBoundsException

        //3、二维数组遍历
        //外循环：遍历二维数组，得到里面的每一个一维数组
        for (int i = 0; i < arr3.length; i++) {
            //i：表示二维数组中的每一个索引
            //arr3[i]: 表示二维数组中的每一个元素（一维数组）
            //内循环：遍历一维数组，得到里面的每一个元素
            for (int j = 0; j < arr3[i].length; j++) {
                //j:表示一维数组中的每一个元素
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }
    }
}

二维数组练习

需求：

某商城每个季度的营业额如下：单位(万元)
    第一季度：22,66,44    一维数组
    第二季度：77,33,88    一维数组
    第三季度：25,45,65    一维数组
    第四季度：11,66,99    一维数组

要求使用二维数组计算出每个季度的总营业额和全年的总营业额

代码：

package com.iflytek.day09;

/**
 * 某商城每个季度的营业额如下：单位(万元)
 * 第一季度：22,66,44    一维数组
 * 第二季度：77,33,88    一维数组
 * 第三季度：25,45,65    一维数组
 * 第四季度：11,66,99    一维数组
 * <p>
 * 要求计算出每个季度的总营业额和全年的总营业额
 */
public class TwoDimensionDemo2 {
    public static void main(String[] args) {

        //1.创建二维数组并存储数据
        int[][] yearArrArr = {
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}
        };

        //表示全年的营业额
        int yearSum = 0;
        //2.遍历二维数组，得到每一个一维数组并求和
        for (int i = 0; i < yearArrArr.length; i++) {
            //i 二维数组中的每一个索引
            //yearArrArr[i] 元素（一维数组）
            int[] quarterArr = yearArrArr[i];
            int sum = getSum(quarterArr);
            System.out.println("第" + (i + 1) + "个季度的总营业额为：" + sum);
            yearSum = yearSum + sum;
        }

        System.out.println("全年的总营业为:" + yearSum);

    }

    //定义一个方法，计算每一个季度的营业额
    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }
}

三维数组练习

开启套娃模式

尝试实现：

针对下列三维数组进行遍历，并在控制台输出以下格式，注意不要多打印“，”

{
  {
    {1,2,3},
    {4,5,6,9}
  },
  {
    {7,8,9},
    {10,11,12}
  },
  {
    {13,14,15},
    {16,17,18}
  }
}

package com.iflytek.day09;

public class TwoDimensionDemo3 {
    public static void main(String[] args) {

        // 一维数组
        int[] arr1_1 = {1, 2, 3};
        int[] arr1_2 = {4, 5, 6};
        int[] arr2_1 = {7, 8, 9};
        int[] arr2_2 = {10, 11, 12};
        int[] arr3_1 = {13, 14, 15};
        int[] arr3_2 = {16, 17, 18};

        // 二维数组
        int[][] arr1 = new int[][]{arr1_1, arr1_2};
        int[][] arr2 = new int[][]{arr2_1, arr2_2};
        int[][] arr3 = new int[][]{arr3_1, arr3_2};

        // 三维数组
        int[][][] array1 = new int[][][]{arr1, arr2, arr3};

        int[][][] array2 = {
                {{1, 2, 3}, {4, 5, 6}},
                {{7, 8, 9}, {10, 11, 12}},
                {{13, 14, 15}, {16, 17, 18}}
        };

        //三维数组遍历
        System.out.println("{");
        for (int i = 0; i < array1.length; i++) {
            System.out.println("  {");
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print("    {");
                for (int k = 0; k < array1[i][j].length; k++) {
                    //j:表示一维数组中的每一个元素
                    System.out.print(array1[i][j][k]);
                    if (k != array1[i][j].length - 1) {
                        System.out.print(",");
                    }
                }
                if (j != array1[i].length - 1) {
                    System.out.println("},");
                } else {
                    System.out.println("}");
                }
            }
            if (i != array1.length - 1) {
                System.out.println("  },");
            } else {
                System.out.println("  }");
            }
        }
        System.out.println("}");
    }
}

rintln(" {“);
for (int j = 0; j < array1[i].length; j++) {
System.out.print(” {“);
for (int k = 0; k < array1[i][j].length; k++) {
//j:表示一维数组中的每一个元素
System.out.print(array1[i][j][k]);
if (k != array1[i][j].length - 1) {
System.out.print(”,“);
}
}
if (j != array1[i].length - 1) {
System.out.println(”},“);
} else {
System.out.println(”}“);
}
}
if (i != array1.length - 1) {
System.out.println(” },“);
} else {
System.out.println(” }“);
}
}
System.out.println(”}");
}
}
晚风烟火
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 数组练习题（1）.docx
01-14
Java 数组练习题（1）.docx
Java学习关于循环和数组练习题整理
08-25
在本篇文章里小编给各位整理了关于Java学习关于循环和数组练习题相关内容，有兴趣的朋友们跟着参考学习下。
某系统的数字密码（大于0），采用加密方式进行传输。
m0_71301373的博客
04-08 397
某系统的数字密码（大于0），采用加密方式进行传输。
排序算法总结——Java实现
qq_41544550的博客
07-11 646
1、冒泡排序 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直到排序完成。 public class BubbleSort { public static void main(String[] args) { ...
数组
m0_56644341的博客
04-09 408
一维数组 静态初始化 数据类型[] 数组名 = {元素1,元素2,元素3…}; int[] arr = {1,2,3,4,5}; int[] arr = new int[]{1,2,3,4,5}; 动态初始化 int[] arr = new int[5]; int[] arr; arr = new int[5]; 一维数组的遍历 public static void main(String[] args) { int[] arr = new int[]{1,2,3,4,5}; //打印数组
09、数组操作练习题
a11_11_11的博客
10-28 784
数组操作练习题
Java基础-数组循环综合练习1
qq_52699757的博客
05-15 115
Java基础-数组循环综合练习1
leetcode中国-Array:用Java练习数组
06-29
Java List MaxMin 最小值，最大值 SecondMax 第二大值 MaxSubArraySum 求最大子数组和以及位置区间 FindMostFrequentInArray 找数组中重复元素最多的数 FindSum 有序数中找两两相加和为20的组合 ShiftK 向右循环移K...
mi-aprende-java-con-ejercicios:Java练习解决方案
05-13
@IESCampanillas中以DAW（Web应用程序开发）的CFGS中的编程为主题的《用练习学习Java》一书的练习的解决方案。 :laptop: 程序的编制和执行 要编译该程序，请键入以下内容（您需要拥有JDK）： javac *...
Java程序设计基础笔记 • 【第10章 数组】
12-22
10.1.2 Java中的数组 10.1.3 数组的分类 10.2 一维数组 10.2.1 数组的定义和使用 10.2.2 数组的使用案例 10.2.3 实践练习 10.3 数组的应用（一） 10.3.1 遍历数组元素 10.3.2 增强型for循环与数组的遍历 10.3.2 ...
java数组
xx的博客
10-19 848
java数组
数组的常用操作及方法
weixin_48961004的博客
11-28 934
数组的常用操作
算法：八大排序
weixin_47796247的博客
04-15 530
目录 一、冒泡排序 二、简单选择排序 三、堆排序 四、直接插入排序 五、归并排序 六、快速排序 七、希尔排序 八、基数排序 一、冒泡排序 （平均时间复杂度为O(n²)） 从左到右依次俩俩比较，并进行交换，知道最右边最大为止（也可以从大到小） 代码实现： public class array { public static void main(String[] args){ int[] a=n...
JAVA初学者关于for循环的十道练习题
最新发布
m0_62756941的博客
08-01 1806
1、循环输入周一到周五的成绩，要求成绩不能是负数，如果为负数，重新输入，结果显示，平均分，最高分，最低分。7.公鸡2元，母鸡1元，小鸡半元，每种至少一只，100文买100只鸡有多少可能性。8.鸡兔同笼：总共100个脚，各多少只？6.输入A和B两个值，计算出他俩的最小公倍数和最大公因数。4.列出1-1000以内所有的奇数和偶数。2.输出所有5位数中的回文数。5.列出1000以内所有的质数。3.计算1-100之和。
Java基础练习题之数组(一)
weixin_44786702的博客
01-25 978
Java基础练习题之数组(一)
JAVA 基础知识学习7
吴杨的博客
03-28 483
目录 目录 01奇数求和练习 02水仙花练习功能实现 03ASCII编码表 04char类型的存储 05输出所有英文字母 0699乘法表的分析 0799乘法表的功能实现 day07_08基础语法实现数组的遍历avi1418 day07_09基础语法数组逆序原理avi1755 day07_10基础语法数组逆序功能实现avi945 day07_11基础语法选择排序原理avi1401 day07_12基础
Java循环经典练习题
weixin_50518344的博客
07-12 789
验证码生成器 杨辉三角 猜数字游戏 杨辉三角
Java基础练习题——数组和循环练习题
ls_Procedure的博客
08-13 3926
Java基础练习题——数组和循环练习题 1.       编写一个九九乘法法 importjava.util.*; publicclass A {          public static void main(String[] args)          {                         for(int i=1;i<10;i++){//双重循环打印   
java数组循环试题_Java学习关于循环和数组练习题整理
weixin_33344572的博客
02-13 428
循环例子：while循环和do…while循环whlie(条件语句) {循环体}//先进行条件语句的判断，再进行循环体do {循环体}whlie (条件语句)//先执行一次循环后再进行条件语句的判断break语句break语句：结束全部循环,具体应用如下：//1+2+3+...+n<1000,求n//此题可以利用break语句在和大于1000时结束循环，输出n的值public static ...
练习-java数组之二维数值数组之矩阵加
03-16
在Java中，可以使用二维数值数组来表示矩阵，然后使用循环遍历数组中的元素进行加法运算，最后得到一个新的矩阵。 具体实现步骤如下： 1. 定义两个二维数值数组matrix1和matrix2，分别表示两个矩阵。 2. 定义一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值