java数组练习题

最新推荐文章于 2022-11-17 22:00:00 发布
最新推荐文章于 2022-11-17 22:00:00 发布
阅读量1.4k 收藏 14
点赞数 2
分类专栏： java基础 简单的Java题目 数组 文章标签： 数组相关的练习题 小算法题目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45345128/article/details/103355598
版权

数 组

主要讲解宋老师里面课后题(无答案的)，以便后期复习使用。（可以私信我要文档资料）

代码题

  1. 创建一个char类型的26个元素的数组，分别 放置’A’-‘Z’。
    使用for循环访问所有元素并打印出来。
public class Exer1 {
    public static void main(String[] args) {
        char[] a = new char[26];
        for (int i = 0; i < 26 ; i++) {
            a[i] = (char)('A'+i);
        }
        for (int i = 0; i < 26; i++) {
            System.out.print(a[i]+" ");
        }
    }

}
  1. 创建一个char类型的36个元素的数组，前26个元素放置’A’-‘Z’, 后10个元素放置’0’-‘9’。
    使用for循环访问所有元素并打印出来。
    提示：char类型数据运算 ‘A’+1 -> ‘B’，‘0’+1 -> ‘1’
public class Exer2 {
    public static void main(String[] args) {
        char[] a = new char[36];
        int j ;
        for (int i = 0; i < 26 ; i++) {
            a[i] = (char)('A'+i);
        }
        for (int i = 26; i <36; i++) {
            a[i] = (char) ('0'+i-26);
        }
        for (int i = 0; i < 36; i++) {
            System.out.print(a[i]+" ");
        }
    }

}
  1. 用数组求出斐波那契数列的前20项值
public class Exer3 {   //递归算法，复杂度有点高.
    public static int exer(int n){
        if (n == 0){
            return 0;
        }
        if (n == 1){
            return 1;
        }
        return exer(n-1) + exer(n-2);
    }

    public static void main(String[] args) {
        int [] arr = new int[20];
        for (int i = 1; i < arr.length+1 ; i++) {
            arr[i-1] = exer(i);
        }
        String s = Arrays.toString(arr);
        System.out.println(s);
    }

}
  1. 对10个整数进行按照从小到大的顺序排序
public class Exer4 {   //用最简单的方法。可以用冒泡，快速等
    public static void main(String[] args) {
        int [] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*100+1);//1-100的随机数
        }
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}
  1. 求一个3*3矩阵对角线元素之和
    <提示>
    程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
public class Exer5 {
    public static void main(String[] args) { //这里随机赋值
        int [][] arr = new int[3][3];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = (int)(Math.random()*100+1);  //1-100
            }
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
                if(i == j)
                    sum += arr[i][i];
            }
            System.out.println();

        }
        System.out.println("对角线和为"+sum);
    }
}
  1. 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
    <提示>
    程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。
public class Exer6 {
    public static void main(String[] args) {
        int [] arr = new int[]{1,2,3,4,5,7,8,9}; //
        System.out.println("请输入一个数");
        Scanner scanner = new Scanner(System.in);
        int [] arr1 = new int[arr.length+1];
        int n = scanner.nextInt();
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < n)
            {
                index = arr.length;
            }
            else {
                arr1[i] = n;
                index = i;
                System.out.println(index);
                break;
            }

        }
        for (int i = 0; i < index; i++) {
            arr1[i] = arr[i];
        }
                    arr1[index] = n;
        for (int i = index+1; i <arr1.length ; i++) {
                    arr1[i] = arr[i-1];
        }
        System.out.println(Arrays.toString(arr1));

    }

}
  1. 利用随机数生成一个整数数组，数组中有10个元素，每个元素的值都在1-30之间，且要求各个数值不能相同。打印该数组。
public class Exer7 {
    public static void main(String[] args) {
        int [] arr  = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*30+1);
            for (int j = 0; j < i; j++) {
                if(arr[i] == arr[j])
                    i--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
  1. 将一个数组逆序输出。
    <提示>程序分析：用第一个与最后一个交换。
public class Exer8 {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        for (int i = 0; i < arr.length / 2; i++) {
            int temp;
            temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }


}
  1. 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。 `
public class Exer9 {
    public static void main(String[] args) {
        int[] arr = new int[10]; //假设输入10个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入10个数字");
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println("输入的数组为" + Arrays.toString(arr));
        int maxNumber = arr[0];
        int minNumber = arr[0];
        int maxIndex = 0;
        int minIndex = 0;
        for (int i = 0; i < arr.length; i++) {
            if (maxNumber < arr[i]) {
                maxNumber = arr[i];
                maxIndex = i;
            }
        }

        for (int i = 0; i < arr.length; i++) {
            if (minNumber > arr[i]) {
                minNumber = arr[i];
                minIndex = i;
            }
        }

        if (minIndex != arr.length - 1) {
            int temp;
            temp = arr[arr.length - 1];
            arr[arr.length - 1] = arr[minIndex];
            arr[minIndex] = temp;
        }
        if (maxIndex != 0) {
            int temp;
            temp = arr[0];
            arr[0] = arr[maxIndex];
            arr[maxIndex] = temp;
        }

        System.out.println("输出为" + Arrays.toString(arr));
    }


}
  1. 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
public class Exer10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入有多少个整数n");
        int n = scanner.nextInt();
        System.out.println("请输入后移的位置m");
        int m = scanner.nextInt();
        int [] arr = new int[n];
        int [] arr1 = new int[n];
        System.out.println("请输入n个整数");
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.println("输入的整数数组为");
        System.out.println(Arrays.toString(arr));

        for (int i = 0; i < n-m; i++) {
            arr1[m+i] = arr[i];
        }
        for (int i = arr.length -m; i < arr.length; i++) {
            arr1[i-arr.length+m] = arr[i];
        }
        System.out.println("输出的数组为");
        System.out.println(Arrays.toString(arr1));
    }

}
  1. 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换
public class Exer11 {
    public static void main(String[] args) {
        int[][] arr = new int[4][4];
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入数组每4个一行");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        System.out.println("输入的数组为");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        for (int i = 0; i < arr.length/2; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                int  temp ;
                temp = arr[i][j];
               arr[i][j] = arr[arr.length-1-i][j];
               arr[arr.length-1-i][j] = temp;
            }
        }
        System.out.println("输出的数组为");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }

    }
}
  1. 定义一个3行4列的二维数组，逐个从键盘输入值，编写程序将四周的数据清0
public class Exer12 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int [][] arr = new int[3][4];
        System.out.println("请输入");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        System.out.println("输入的数组是");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        System.out.println("输出的结果为");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(i == 0 || i == arr.length-1 || j == 0 || j == arr[i].length-1)
                        arr[i][j] = 0;
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }


}
  1. 定义一个3行4列的二维数组，逐个从键盘输入值，将左下三角的值清0
public class Exer13 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int [][] arr = new int[3][4];
        System.out.println("请输入");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        System.out.println("输入的数组是");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        System.out.println("输出的结果为");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(i>=j)
                        arr[i][j] = 0;
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }


}
  1. 定义一个4行4列的二维数组，逐个从键盘输入值，将对角线的值清0
public class Exer14 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] arr = new int[4][4];
        System.out.println("请输入");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        System.out.println("输入的数组是");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        System.out.println("输出的结果为");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (i + j == arr.length - 1 || i == j)
                    arr[i][j] = 0;
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}
  1. 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出
public class Exer15 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数和列数的值N");
        int n = scanner.nextInt();
        int[][] arr = new int[n][n];
        System.out.println("请输入");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        System.out.println("输入的数组是");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("输出的结果为");
        int[] arr1 = new int[n];
        for (int i = 0; i < arr.length; i++) {
            int maxNumber = arr[i][0];
            for (int j = 0; j < arr[i].length; j++) {
                if (maxNumber < arr[i][j]) {
                    maxNumber = arr[i][j];
                }
            }
            arr1[i] = maxNumber;
        }
        System.out.println(Arrays.toString(arr1));

    }
}
goodmentality
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数组练习Demo
weixin_45505597的博客
10-05 590
回形数格式方阵的实现 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 public static void main(String[] args) { int n = 7; int[]
java二维数组自定义输入输出并求每行最大值_羊豆豆_新浪博客
ABoLuoTaMei的专栏
03-28 233
public class test { static int a[][]=new int[2][2]; public static void main(String[] args) { Scanner input=new Scanner(System.in); //自定义输入接收输入 for(int i=0;i<2;i++) { for(int j=0;j<...
Java 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换
zhangeer的博客
11-11 1586
【代码】Java 定义一个4行4列的二维数组，逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换。
java数组基础算法题-回形数格式方阵的实现、
毛虫-strive-blogs
04-26 354
文章目录题目第一题代码实现第二题代码实现： 题目 创建长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。 回形数格式方阵的实现 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 1
回形数格式方阵的实现(Java)
俺才是守夜冠军
09-26 1625
回形数格式方阵的实现(Java) 问题描述： 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 15 6 10 9
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。...以上是对Java数组练习题中的主要知识点的详细解析，通过这些题目，可以更好地理解和掌握Java中数组的操作、特性以及异常处理。
Java数组练习题.pdf
11-26
在这个Java数组练习题中，涉及了许多关于数组的重要知识点。 1. **数组的访问与长度**：数组的元素通过下标来访问，下标从0开始，数组Array的长度可以通过`length`属性获取，例如`Array.length`。 2. **数组复制与...
Java数组练习题.docx
11-26
在这个Java数组练习题中，涉及到了数组的访问、复制、存储位置、排序、初始化、异常处理以及相关语法等多个知识点。 1. **数组的访问**：数组的元素通过下标来访问，下标是从0开始的整数，例如`array[0]`表示访问...
Java数组练习题带答案.doc
10-07
Java 数组练习题带答案 Java 数组是一种基本的数据结构，用于存储固定大小的同类型元素的集合。本文通过多种练习题和答案，帮助读者更好地理解 Java 数组的概念和应用。 1. 数组元素的访问 数组的元素可以通过...
Java题目-回形数格式方阵的实现
h1062679091的博客
04-05 969
从键盘输入一个整数(1~20) 则以该数字为矩阵的大小,把1,2,3…n*n的数字按照顺时针螺旋的形式填入其中. 例如: 输入数字2,则程序输出: 1 2 4 3 输入数字3,则程序输出: 1 2 3 8 9 4 7 6 5 输入数字4,则程序输出: 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 刚开..
【Java语言】练习系列----回形数格式方阵的实现
一只小白的奋斗历程的博客
04-11 539
从键盘输入一个整数， 则以该数字为矩阵的大小， 把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。 例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 具体代码实现如下： public class RectangleTest { public static void ma
Java实现（1~20）回形数方阵
Fish_Vast的博客
07-21 670
从键盘输入一个任意正整数 （不要太大，不然控制台也装不下，哈哈），则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5    接触算法不算太久，拿这种题目练手，刚开始真的有点烧脑袋啊，看了许久别人的代码，最后还是自己悟出了这里面的（个人思想），自己用手画了一张图，还有通过自己的想法码出了一小段代码，还发现了一个小问题，就是遇到奇数的时候，数字是要多计算一个的，
Java练习题-回形数格式方阵的实现方法②
心也台声的博客
01-15 149
方法1：Java练习题-回形数格式方阵的实现方法① 方法2： Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数（1~20）："); int n = scanner.nextInt(); int[][] arr = new int[n][n]; int count = 0; // 要显示的数据 int maxX = n - 1; // x轴的最大下标 int maxY = n - 1; // Y轴的最大下标 int m
mysql_fetch_array与mysql_fetch_row有什么区别?
purpen
09-17 148
两种查询函数array / row区别 格式：mysql_fetch_row(result); 说明：mysql_fetch_row用来查询结果的一行保存至数组，该数组下标从0开始，每一个数组元素对应 一个域。通过循环，可以将查询结果全部获得。 格式：mysql_fetch_array(result); 说明：mysql_fetch_array和mysql_fetch_row功能基本...
定义一个包含 10 个元素的整型数组，通过随机产生 10 以内的随机数，给数组中的每个元素赋值，并输出结果。
CNSA183_20的博客
04-30 7360
任务： 功能：定义一个包含 10 个元素的整型数组，通过随机产生 10 以内的随机数，给数组中的每个元素赋值，并输出结果。 运行结果：0332632709 注：由于数组元素值为随机产生，所以运行结果不固定，此运行结果仅作为示例 请在下图中的第6、11、17行中将代码填写完整。 package world; public class Sui { public static void main(String[] args) { ...
Java学习笔记 --- 数组
乌云的博客
09-17 269
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。（数组就是一组数据）
java基础笔记4之理解并学会使用数组
song_6666的博客
06-22 1686
目录一、数组基础知识数组使用注意事项和细节：二、数组练习1.创建一个char类型的26个元素的数组，分别放置'A' - 'Z'. 使用for循环访问所有元素并打印出来。提示：char类型数据运算 'A' + 1 -> 'B'2.请求出一个数组int[]的最大值{4，-1，9，10，23}，并得到对应得下标。3.请求出一个数组的和和平均值。三、数组赋值机制四、数组练习（加强版）1.添加元素，可以不断地添加元素，也可以添加完一个后退出2.删除元素，不断地删除元素，直到最后一个才不让删。3.冒泡排序的实现过程4.
Flink实战之Flink SQL中的Map、Array、Row
m0_67390963的博客
03-20 8024
Flink sql支持Map、Array、Row类型，这几种类型在DDL中如何定义、如何获取、如何构造，本文做个总结。 以如下数据作为样例： { "id":1238123899121, "name":"asdlkjasjkdla998y1122", "date":"1990-10-14", "obj":{ "time1":"12:12:43Z", "str":"sfasfafs", "lg":2324342345 },
Java 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出。
zhangeer的博客
11-17 1468
【代码】Java 定义一个N*N二维数组，从键盘上输入值，找出每行中最大值组成一个一维数组并输出。
java 数组练习题
最新发布
05-09
Java 数组练习题可以有很多，下面是一些常见的例子： 1. 给定一个整数数组，找出其中两个数的和等于目标值，返回这两个数的索引。例如，给定 nums = [2, 7, 11, 15], target = 9，因为 nums + nums = 2 + 7 = 9，所以返回 [0, 1]。 2. 给定一个整数数组，找出其中最长的连续递增序列的长度。例如，给定 nums = [1,3,5,4,7]，最长连续递增序列是 [1,3,5]，所以返回它的长度 3。 3. 给定一个二维数组 matrix，按照顺时针螺旋顺序返回它的所有元素。例如，给定以下矩阵 matrix： [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 应该返回 [1,2,3,6,9,8,7,4,5]。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值