【参考答案】java基础练习：数组（一维、二维、传值传地址）

最新推荐文章于 2023-03-31 19:19:28 发布

全栈测试笔记

最新推荐文章于 2023-03-31 19:19:28 发布

阅读量245

点赞数

文章标签： java 算法数据结构开发语言排序算法

本文链接：https://blog.csdn.net/weixin_44896406/article/details/128681840

版权

这篇博客探讨了Java中的一维和二维数组的使用，包括动态赋值、数组反转、增强for循环以及传值和传地址的概念。还讨论了冒泡排序在二维数组的应用，以及如何处理不定长参数。同时，提供了处理数组中超过一半数量的数字的笔试题解。

摘要由CSDN通过智能技术生成

一维数组

定义一个int类型数组，动态赋值，然后将数组中元素反转，最后输出，要求：动态赋值定义方法；反转定义方法

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int[] nums = new int[3];
        setValue(nums);
        System.out.println("动态赋值后：" + Arrays.toString(nums));
        reverseArray(nums);
        System.out.println("数组反转后：" + Arrays.toString(nums));
    }

    public static void setValue(int[] nums){
        Scanner sc = new Scanner(System.in);
        for (int i=0;i<nums.length;i++){
            System.out.print("请输入数组第" + (i+1) +"个元素：");
            nums[i] = sc.nextInt();
        }
    }

    public static void reverseArray(int[] nums){
        int len = nums.length;
        for (int i=0;i<len/2;i++){
            int temp = nums[len-1-i];
            nums[len-1-i] = nums[i];
            nums[i] = temp;
        }
    }
}

有一个数组[1, 3, 66, 16, 28, 666, 168]，循环输出数组中的元素并计算所有数的总和，并将最大值放到最前面，最小值放到最后面，然后输出数组

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int[] nums = {1, 3, 66, 16, 28, 666, 168};

        int sum = 0;
        for (int num : nums) {
            System.out.print(num + " ");
            sum += num;
        }
        System.out.println("\n总和：" + sum);

        int maxIndex = 0, minIndex = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > nums[maxIndex]) {
                maxIndex = i;
            }
            if (nums[i] < nums[minIndex]) {
                minIndex = i;
            }
        }

        System.out.println("最大值的索引：" + maxIndex);
        System.out.println("最小值的索引：" + minIndex);

        if (maxIndex==nums.length && minIndex==0){
            int temp=nums[0];
            nums[0]=nums[maxIndex];
            nums[maxIndex]=temp;
            System.out.println(Arrays.toString(nums));
        } else if (maxIndex==nums.length){
            int temp=nums[0];
            nums[0]=nums[maxIndex];
            nums[maxIndex]=temp;

            temp=nums[nums.length-1];
            nums[nums.length-1]=nums[minIndex];
            nums[minIndex]=temp;
        } else if (minIndex==0){
            int temp=nums[nums.length-1];
            nums[nums.length-1]=nums[minIndex];
            nums[minIndex]=temp;


            temp=nums[0];
            nums[0]=nums[maxIndex];
            nums[maxIndex]=temp;

            int temp=nums[0];
            nums[0]=nums[maxIndex];
            nums[maxIndex]=temp;

            temp=nums[nums.length-1];
            nums[nums.length-1]=nums[minIndex];
            nums[minIndex]=temp;
        }
        System.out.println("交换后：" + Arrays.toString(nums));
    }
}

增强for

输出数组的值[1, 3, 66, 16, 28, 666, 168]

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int[] nums = {1, 3, 66, 16, 28, 666, 168};
        // 普通的for循环
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        System.out.println();
        // 增强for循环
        for (int n : nums) {
            System.out.println(n);
        }
        System.out.println(Arrays.toString(nums)); 
    }
}

传值、传地址

下面输出结果是？

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int a = 5;
        int b = a; 
        b = 8;
        System.out.println(a);
        System.out.println(b);


        int[] c = { 1,2,3 };
        int[] d = c;
        d[0] = 666;
        System.out.println(Arrays.toString(c));
        System.out.println(Arrays.toString(d));

        change(a,c);
        System.out.println(a);
        System.out.println(Arrays.toString(c));

    }

    public static void change(int i, int[] array) {
        i = 666;
        array[array.length - 1] = 999;
        System.out.println(i);
        System.out.println(Arrays.toString(array));
    }
}

基本数据类型是传值

数组是传地址

二维数组(含冒泡)

输出二维数组的每个元素，int[][] d = { { 1, 2, 9 }, { 5 }, { 1, 3 }, { 9, 7, 0 } };

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int[][] d = { { 1, 2, 9 }, { 5 }, { 1, 3 }, { 9, 7, 0 } };
        for (int i = 0; i < d.length; i++) {
            for (int j = 0; j < d[i].length; j++) {
                System.out.print(d[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

有2个班，每个班有3名学生，提示用户分别输入学生的成绩，将数据保存到二维数组中，并计算每个班的平均分、全校的最高分、最低分，最后输出平均分最高的班以及对应的平均分

package com.qzcsbj;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int[][] scores = new int[2][3];
        double maxavg = 0;
        int maxavgClass = 0;
        int i = 0;
        for (; i < scores.length; i++) {
            System.out.println("-------请输入第" + (i + 1) + "个班级的学生成绩-------");
            double sum = 0, avg = 0;
            for (int j = 0; j < scores[i].length; j++) {
                System.out.print("请输入第" + (j + 1) + "名学生的成绩：");
                scores[i][j] = input.nextInt();
                sum += scores[i][j];
            }
            avg = sum / 3;
            if (avg>maxavg){
                maxavg=avg;
                maxavgClass= i+1;
            }
            System.out.println("第" + (i + 1) + "个班级的平均分为：" + avg);
        }

        int max = scores[0][0], min = scores[0][0];
        for (int i2 = 0; i2 < scores.length; i2++) {
            for (int j = 0; j < scores[i2].length; j++) {
                if (scores[i2][j] > max) {
                    max = scores[i2][j];
                }
                if (scores[i2][j] < min) {
                    min = scores[i2][j];
                }
            }
        }
        System.out.println("最高分：" + max);
        System.out.println("最低分：" + min);
        System.out.println("最高平均分班级为：" + maxavgClass +"班，平均分为：" + maxavg);

    }
}

冒泡实现排序，[9,6,4,5,3]，输出：[3, 4, 5, 6, 9]，要求打印每一轮每一次冒泡后的结果

package com.qzcsbj;

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

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class Test {
    public static void main(String[] args) {
        int[] nums = {9,6,4,5,3};

        // 外层循环控制比较的轮数
        for (int i = 0; i < nums.length - 1; i++) {
            // 内层循环控制每一轮比较的次数
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                    System.out.println("第" + (i + 1) + "轮，第" + (j+1) + "次：" + Arrays.toString(nums));
                }
            }
            System.out.println("==第" + (i + 1) + "轮结果：" + Arrays.toString(nums));
        }

        System.out.println(">>排序后的数组：" + Arrays.toString(nums));
    }
}

不定长参数

不定长参数的本质是数组

笔试题

数组中有一个数字出现的次数超过数组长度的一半

两种方法

public static void main(String[] args) {
       int[] nums = {1,2,3,2,2,2,5,4,2};
       System.out.println(getFromSort(nums));
       System.out.println(getFromMap(nums));
   }
 
   public static int getFromSort(int[] array){
       Arrays.sort(array);
       System.out.println(Arrays.toString(array));
       int mid = array.length/2;
       int midvalue = array[mid];
       int times = 0;
       for(int i=0;i<array.length;i++){
           if (array[i] == midvalue){
               times ++;
               if (times>mid){
                   return array[i];
               }
           }
       }
       return -1;
   }
 
   public static int getFromMap(int[] array){
       int mid = array.length/2;
       Map<String, Integer> map = new HashMap<>();
       for(int i=0;i<array.length;i++){
           String key = array[i] + "";
           if(map.get(key)==null){
               map.put(key,1);
           }else{
               map.put(key,map.get(key)+1);
           }
 
           if (map.get(key)>mid){
               return Integer.parseInt(key);
           }
       }
       return -1;
   }