深入了解Java数组操作及常用算法题

柔情只为你懂 2023-10-13 17:48 27阅读 0赞

在Java编程中，数组是一种重要的数据结构，可以存储多个相同类型的元素。本文将介绍如何使用Java数组进行常见操作，并探索其中的一些常用算法。我们将通过一个具体的代码示例来详细说明每个操作的实现和作用。

在Java中，数组操作是一项基本技能。我们从提供的代码开始，逐步分析每个题目，并给出相应的解决方案。

## 题目1：返回数组中的所有偶数 ##

首先，我们定义一个计数器count，用于统计数组中偶数的个数。通过遍历数组，对每个元素进行取模操作，判断是否为偶数。如果是偶数，则将其添加到新数组arr\_new中，并同时增加计数器count的值。最后，我们得到了一个新数组arr\_new，其中包含原始数组中的所有偶数。

// ...之前的代码
    
    //题目 1：
    //编写一个 Java 程序，定义一个整数数组 ，并返回该数组中的所有偶数。
    int count = 0;//定义一个计数器
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] % 2 == 0){ //判断新数组的长度
            count++;//满足条件则自增
        }
    }
    //定义一个新数组
    int[] arr_new = new int[count];
    //定义一个计数器，记录新数组下标
    int f = 0;
    //循环遍历
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] % 2 == 0){//判断是否为偶数
            arr_new[f] = arr[i];//满足条件则赋值到新数组
            f++;//新数组下标自增
        }
    }
    //打印输出
    System.out.println("数组中的所有偶数:" + Arrays.toString(arr_new));
    
    // ...之后的代码

## 题目2：返回数组中的所有奇数 ##

与题目1类似，我们使用一个计数器count2来统计数组中奇数的个数。通过遍历数组并进行取模操作，判断是否为奇数。如果是奇数，则将其添加到新数组arr\_new2中，并同时增加计数器count2的值。最终，我们得到了一个新数组arr\_new2，其中包含原始数组中的所有奇数。

// ...之前的代码
    
    //题目 2：
    //编写一个 Java 程序，定义一个整数数组 ，并返回该数组中的所有奇数。
    int count2 = 0;//定义一个计数器
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] % 2 != 0){ //判断新数组的长度
            count2++;//满足条件则自增
        }
    }
    //定义一个新数组
    int[] arr_new2 = new int[count2];
    //定义一个计数器，记录新数组下标
    int f2 = 0;
    //循环遍历
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] % 2 != 0){//判断是否为奇数
            arr_new2[f2] = arr[i];//满足条件则赋值到新数组
            f2++;//新数组下标自增
        }
    }
    //打印输出
    System.out.println("数组中的所有奇数:" + Arrays.toString(arr_new2));
    
    // ...之后的代码

## 题目3：返回数组中每个元素的平方值 ##

为了解决这个问题，我们定义一个新数组arr\_new3，用于存储原始数组中每个元素的平方值。通过遍历原始数组，将每个元素的平方值赋值给arr\_new3中对应的位置。最终，我们得到了一个新数组arr\_new3，其中包含了原始数组中每个元素的平方值。

// ...之前的代码
    
    //题目 3：
    //编写一个 Java 程序，定义一个整数数组 ，并返回一个新的数组，其中的元素是原始数组中每个元素的平方值。
    //定义一个新数组
    int[] arr_new3 = new int[arr.length];
    //循环遍历
    for (int i = 0; i < arr.length; i++) {
        arr_new3[i] = arr[i] * arr[i];
    }
    //打印输出
    System.out.println("数组元素的平方是：" + Arrays.toString(arr_new3));
    
    // ...之后的代码

## 题目4：返回数组中的第二大元素 ##

在给定的代码中，题目4的解决方案尚未实现。我们需要使用一种合适的算法来找到数组中的第二大元素。常见的方法是使用两个变量，分别记录最大值和次大值，并进行比较和更新。您可以尝试使用类似的算法来实现该功能。

// ...之前的代码
    
    //题目 4：
    //编写一个 Java 程序，定义一个整数数组 ，并返回该数组中的第二大的元素。
    int max = Integer.MIN_VALUE; // 定义最大值
    int secondMax = Integer.MIN_VALUE; // 定义第二大值
    
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > max) {
            secondMax = max;
            max = arr[i];
        } else if (arr[i] > secondMax && arr[i] < max) {
            secondMax = arr[i];
        }
    }
    
    System.out.println("数组中的第二大元素是：" + secondMax);
    
    // ...之后的代码

## 题目5：返回两个数组对应位置的元素之和 ##

首先，我们生成第二个随机数组arr5，长度与第一个数组arr相同。然后，定义一个新数组arr\_new5，用于存储两个数组对应位置的元素之和。通过两个嵌套的循环遍历，我们可以将两个数组相同位置的元素相加，并将结果赋值给arr\_new5中对应的位置。最终，我们得到了一个新数组arr\_new5，其中包含了两个数组对应位置元素的和。

// ...之前的代码
    
    //题目 5：
    //编写一个 Java 程序，定义两个整数数组 ，并返回一个新的数组，其中的元素是两个数组中对应位置的元素之和。
    int[] arr5 = new int[num];//定义一个数组(长度默认与随机的第一个数组相同)
    
    //生成随机数组
    for (int i = 0; i < num; i++) {
        arr5[i] = random.nextInt(89) + 10;//生成10 - 99 之间的随机数
    }
    
    //打印出生成的随机数组
    System.out.println("第一个随机数组是：" + Arrays.toString(arr));
    System.out.println("第二个随机数组是：" + Arrays.toString(arr5));
    
    //定义一个新数组
    int[] arr_new5 = new int[arr5.length];
    //循环遍历，两个数组
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr5.length; j++) {
            if (i == j){//判断，两个数组下标是否相同
                arr_new5[i] = arr[i] + arr5[j]; //相同则相加并赋值给新数组
            }
        }
    }
    //打印输出
    System.out.println("两个随机数组和是：" + Arrays.toString(arr_new5));
    
    // ...之后的代码

## 题目6：将数组中等于指定值的元素替换为0 ##

用户通过键盘输入一个数值number。我们定义一个新数组arr\_new6，用于存储替换后的数组。通过遍历原始数组，判断每个元素是否与输入值相同。如果相同，则将该位置的元素替换为0；否则，将原始数组中的元素赋值给arr\_new6。最终，我们得到了一个新数组arr\_new6，其中包含了替换操作后的数组。

// ...之前的代码
    
    //题目 6：
    //编写一个 Java 程序，定义一个整数数组和一个整数值 ，将数组中所有等于该值的元素替换为0。、
    //键盘录入一个数值
    System.out.println("请输入一个10-99之间的数值：（提示：65）");//输入65 随机数组中默认设定了两个固定值为 65
    int number = scanner.nextInt();
    //定义一个新数组
    int[] arr_new6 = new int[arr.length];
    //循环遍历
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == number){//判断每个数值与输入值是否相同
            arr_new6[i] = 0;//相同则赋值为0
        }else {
            arr_new6[i] = arr[i];//不相同则赋值原数组的值
        }
    }
    //打印输出
    System.out.println("修改之前的数组是：" + Arrays.toString(arr));
    System.out.println("修改之后的数组是：" + Arrays.toString(arr_new6));
    
    // ...之后的代码

## 题目7：返回数组中的最小值和最大值 ##

我们定义一个新数组arr\_new7，长度为2，用于存储最小值和最大值。首先，我们通过遍历原始数组找到最小值，并将其赋值给arr\_new7的第一个位置。然后，再次遍历数组，找到最大值，并将其赋值给arr\_new7的第二个位置。最终，我们得到了一个新数组arr\_new7，其中包含了原始数组中的最小值和最大值。

// ...之前的代码
    
    //题目 7：
    //编写一个 Java 程序，定义一个整数数组 ，并返回一个新的数组，其中的元素是原始数组中的最小值和最大值。
    //定义一个新数组
    int[] arr_new7 = new int[2];//只存储最小值和最大值
    //获取最小值
    int min = arr[0];//定义一个最小值，初值为原数组的0号位值
    //循环遍历
    for (int i = 0; i < arr.length; i++) {
        if (min > arr[i]){//判断比较最小值
            min = arr[i];//将较小值赋值给定义的最小值min
        }
    }
    arr_new7[0] = min;//将得到的最小值赋值给定义的新数组
    //获取最大值
    int max = arr[0];//定义一个最大值，初值为原数组的0号位值
    for (int i = 0; i < arr.length; i++) {
        if (max < arr[i]){//判断比较最最值
            max = arr[i];//将较小值赋值给定义的最大值max
        }
    }
    arr_new7[1] = max;//将得到的最大值赋值给定义的新数组
    //打印输出
    System.out.println("最小值和最大值是：" + Arrays.toString(arr_new7));
    
    // ...之后的代码

## 题目8：返回字符串数组中每个字符串的长度 ##

在给定的代码中，我们已经定义了一个字符串数组str，其中包含了一些字符串。我们定义一个新数组arr\_new8，用于存储字符串数组中每个字符串的长度。通过遍历字符串数组，使用length()方法获取每个字符串的长度，并将其赋值给arr\_new8中对应的位置。最终，我们得到了一个新数组arr\_new8，其中包含了字符串数组中每个字符串的长度。

// ...之前的代码
    
    //题目 8：
    //编写一个 Java 程序，定义一个字符串数组 ，并返回一个新的数组，其中的元素是原始数组中的每个字符串的长度。
    String[] str = {"a1as2b","k55dfa6n","sad","v!!!!","c    c","l<36>45dsf","fa6fa52af15a8faf","l0l","y1234t","pao68ag"};
    //打印定义好的字符串
    System.out.println("自定义的字符串是：" + Arrays.toString(str));
    //定义一个新数组
    int[] arr_new8 = new int[str.length];
    //循环遍历
    for (int i = 0; i < str.length; i++) {
        arr_new8[i] = str[i].length();//获取每个字符串的长度，并赋值给新数组
    }
    //打印输出
    System.out.println("每个字符串长度是：" + Arrays.toString(arr_new8));
    
    // ...之后的代码

## 题目9：返回字符串数组中每个字符串的首字母大写 ##

我们定义一个新的字符串数组arr\_new9，用于存储字符串数组中每个字符串首字母大写后的结果。通过遍历字符串数组，使用Character.toUpperCase()方法将每个字符串的首字母转为大写，并将结果赋值给arr\_new9中对应的位置。最终，我们得到了一个新数组arr\_new9，其中包含了字符串数组中每个字符串首字母大写的结果。

// ...之前的代码
    
    //题目 9：
    //编写一个 Java 程序，定义一个字符串数组 ，并返回一个新的数组，其中的元素是原始数组中的每个字符串的首字母大写。
    //定义一个新的字符串数组
    String[] arr_new9 = new String[str.length];
    //循环遍历
    for (int i = 0; i < str.length; i++) {
        char firstChar = Character.toUpperCase(str[i].charAt(0)); // 将首字母转为大写
        arr_new9[i] ="" + firstChar; // 构造新的字符串，将首字母大写后的字符串赋值给新数组
    }
    //打印输出
    System.out.println("改为首字母大写是：" + Arrays.toString(arr_new9));
    
    // ...之后的代码

## 题目10：返回数组的倒序排列 ##

首先，我们定义一个新数组arr\_new10，用于存储原始数组的倒序排列结果。通过使用冒泡排序算法或其他排序算法，可以实现数组的倒序排列。在给定的代码中，使用了冒泡排序算法来完成这个任务。最终，我们得到了一个新数组arr\_new10，其中包含了原始数组倒序排列后的结果。

// ...之前的代码
    
    //题目 10：
    //编写一个 Java 程序，定义一个整数数组 ，并返回一个新的数组，其中的元素是原始数组中的倒序排列。
    //定义一个新数组
    int[] arr_new10 = new int[str.length];
    //生成随机数组
    for (int i = 0; i < num; i++) {
        arr_new10[i] = random.nextInt(89) + 10;//生成10 - 99 之间的随机数
    }
    //打印出生成的随机数组
    System.out.println("生成一个新数组是：" + Arrays.toString(arr_new10));
    //使用循环遍历完成降序排序
    //循环遍历 外层 0 - length-1
    for (int i = 0; i < arr_new10.length - 1; i++) {
        //循环遍历 内层 0 - length-1-i
        for (int j = 0; j < arr_new10.length - 1 - i; j++) {
            //定义一个变量储存当前值
            int now = arr_new10[j];
            //定义一个变量储存下一个值
            int next = arr_new10[j + 1];
            //定义一个容器
            int num10 = 0;
            //判断 借助容器实现位置的交换
            if (now < next){
                num10 = now;//将较小值放入容器
                arr_new10[j] = next;//将获取到的下一个值赋值给当前值
                arr_new10[j + 1] = num10;//将容器中的值赋值给原来的下一个值
            }
        }
    }
    System.out.println("倒序排列后数组是：" + Arrays.toString(arr_new10));
    
    // ...之后的代码

总结： 本文介绍了如何使用Java数组进行常见操作，并深入了解了一些常用的算法。通过对题目代码的分析和解决方案的说明，我们了解了每个操作的实现方法和作用。掌握这些数组操作和算法对于编写高效的Java程序非常重要，它们可以帮助我们处理不同类型的数据和问题。

希望本文能帮助您更好地理解和运用Java中的数组操作和常用算法。如果您有任何关于本文或其他Java编程相关的问题，欢迎在评论区留言交流！