数组：认识数组、使用数组以及数组练习题

最新推荐文章于 2024-10-18 10:41:41 发布

JPlaTao

最新推荐文章于 2024-10-18 10:41:41 发布

阅读量225

点赞数

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_46312726/article/details/132155125

版权

本文介绍了Java中的数组，包括数组的定义、静态和动态初始化、元素访问以及数组遍历。此外，还提供了多个数组操作的练习题，如找数组最小值、计算元素和、筛选特定条件的元素等，旨在加深对数组操作的理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组

认识数组

数组是具有相同数据类型且按一定次序排列的一组变量的集合体。即用一个变量名表示一批数据。Java为数组在内存中分配一段连续的空间，这段空间中存储数据的个数是固定的，数组就是一个容器，用来存一批同种类型的数据。

显而易见，我们在需要同时定义多个同类型的变量时使用数组。

数组的定义和访问

定义数组

Java中定义数组有两种语法格式： 数据类型数组名[ ]; 或数据类型[ ] 数组名;

数组是什么数据类型，数组的元素就是什么数据类型
数组的特征是[ ]
数组是引用类型

数组的静态初始化

即将定义数组、为数组元素分配内存、数组元素初始化三步一起写，也就是在定义数组时直接给数组中的数据赋值这种方式称为静态初始化。标准格式是

数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3};
简化为：
数据类型[] 变量名 = {元素1,元素2,元素3};
//例如：
String[] names = {"张三", "李四", "王五"...};
System.out.println(names[1]);

数组的动态初始化

动态初始化不需要我们写出具体的元素，而是指定元素类型和长度就行。格式如下

数据类型[] 数组名; 数组名 = new 数据类型[数组长度];

例如： names = new String[5];

定义数组和为数组元素分配内存，这两步可以合并在一起写，例如：

String[] names = new String[5];

数组元素的访问

数组中存储的数据叫做元素；而且数组中的每一个元素都有一个编号与之对应，这个编号叫做索引，这个索引是从0依次递增的整数。

要想访问数组中的元素，格式如下

// 数组名可以找到数组对象的地址，再通过索引就可以定位到具体的元素了
数组名[索引] // 索引 0 --> 长度 - 1

数组的遍历

所谓遍历意思就是将数组中的元素一个一个的取出来。

int[] ages = {12, 24, 36};
for (int i = 0; i < ages.length; i++) {
	// i的取值 = 0, 1, 2
	System.out.println(ages[i]);
}

数组练习题及答案

1.定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值

public class ArrayMin {
    public static void main(String[] args) {
        int[] arr = {43,13,23,65,32};
        int min = arr[0];
        for (int num :arr
             ) {
            if(num < min){
                min = num;
            }
        }
        System.out.println("最小值为："+min);
    }
}

2.创建一个长度为6的整数数组。请编写代码，随机生成六个0（包含）~100（不包含）之间的整数存放到数组中，然后计算出数组中所有元素的和并打印。

public class RandomSum {
    public static void main(String[] args) {
        int[] randomNums= new int[6];
        Random random = new Random();
        int sum= 0;
        for (int i:randomNums
             ) {
            i =random.nextInt(100);
            System.out.println(i);
            sum += i;
        }
        System.out.println(sum);
    }
}

3.求出数组中索引与索引对应的元素都是奇数的元素

public class BothOdd {
    public static void main(String[] args) {
        int[] randomNums = new int[50];
        Random random = new Random();
        for (int i = 0; i < randomNums.length; i++) {
            randomNums[i] = random.nextInt(100);
        }
        for (int i = 0; i < randomNums.length; i++) {
            if (i % 2 != 0 && randomNums[i] % 2 != 0) {
                System.out.println(randomNums[i] + ", "+ i);
            }
        }
    }
}

4.完成如下功能：

a.定义一个长度为5的int型数组arr，提示用户输入5个1-60之间的数字作为数组元素

b. 生成2-10（范围包含2和10）之间的随机数num

c. 遍历数组arr,筛选出数组中不是num倍数的元素并输出

PS：输入的数组元素范围包括1和60，不需要代码判断

public class Multiple {
    public static void main(String[] args) {
        int[] arr = new int[5];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.print("请输入第" + i + "/5个1-60之间的数：");
            arr[i] = scanner.nextInt();
        }
        Random random = new Random();
        int num = random.nextInt(8)+2;
        System.out.println("随机数为："+num);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%num != 0){
                System.out.println(arr[i]+"不是随机数的倍数");
            }
        }
    }
}

5.有一个数组int[] arr = {9,1,3,4,54,56,23,22,20,43,45,78};,要求打印数组中能被6整除的元素。

public class MultiplesOf6 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 3, 4, 54, 56, 23, 22, 20, 43, 45, 78};

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 6 == 0) {
                System.out.println(arr[i]);
            }
        }
    }
}

6…定义一个长度为20的数组，元素为20-40的随机数，要求判断指定元素在数组中出现的次数，指定元素为键盘录入范围为20-40之间。

public class CountNum {
    public static void main(String[] args) {
        Random random = new Random();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个20~40之间的数");
        int num;
        while (true){
            num = scanner.nextInt();
            if (num<20 || num >40){
                System.out.println("输入错误，请重新输入");
            }else break;
        }
        int[] rdmNum = new int[20];
        int count = 0;
        for (int i = 0; i < rdmNum.length; i++) {
            rdmNum[i] = random.nextInt(20)+20;
            System.out.println(rdmNum[i]);
            if (num == rdmNum[i]){
                count++;
            }
        }
        System.out.println(count);
    }
}

7.现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。

public class ArrToInt {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入此数组长度：");
        int N = scanner.nextInt();
        int[] arr = new int[N];
        Random random = new Random();
        for (int i = 0; i < N; i++) {
            arr[i] = random.nextInt(9);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int num = 0;
        for (int j : arr) {
            num *= 10;
            num += j;
        }
        System.out.println(num);
    }
}

8… 定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）

import java.util.Random;

public class OddLeftEvenRight {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
        int[] newArr = new int[arr.length];
        int oddCount = 0;
        int evenCount = 1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0){
                newArr[oddCount] = arr[i];
                oddCount++;
            }
            else {
                newArr[arr.length-evenCount] = arr[i];
                evenCount++;
            }
        }
        for (int i:newArr
             ) {
            System.out.print(i+" ");
        }
    }
}

9.在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

import java.util.Scanner;

public class Judge {
    public static void main(String[] args) {
        int[] judge = new int[6];
        Scanner scanner = new Scanner(System.in);
        double sum = 0;
        for (int i = 0; i < judge.length; i++) {
            System.out.println("第" + (i+1) + "位评委打分为：");
            judge[i] = scanner.nextInt();
            System.out.println(judge[i]);
            sum += judge[i];
        }
        int max = 0;
        for (int j : judge) {
            if (j > max) max = j;
        }
        System.out.println(max);
        int min = judge[0];
        for (int j : judge) {
            if (j<min) min = j;
        }
        System.out.println(min);
        sum = sum - max - min;
        System.out.println("最终得分为：" + sum/ (judge.length-2));
    }
}

10.现有一个int 数组，数组中有十个元素。将数组反转后输出。

import java.util.Random;

public class Revers {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(20);
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        for (int i = 0; i < arr.length / 2; i++) {
            arr[i] = arr[i] ^ arr[arr.length - 1 -i];
            arr[arr.length - 1 - i] = arr[i] ^ arr[arr.length - 1 -i];
            arr[i] = arr[i] ^ arr[arr.length - 1 - i];
        }
        for (int i: arr
             ) {
            System.out.print(i + " ");
        }
    }
}