Arrays的用法（附10道练习题）

  • 开发
  • 23

Java中的Arrays类是Java标准库中的一个工具类，它提供了一系列静态方法来操作数组，这些方法可以实现对数组的搜索、排序、比较和填充等操作。

目录

一、Arrays.toString()

二、Arrays.sort()

三、Arrays.equals()

四、Arrays.asList()

五、Arrays.copyOf()

六、Arrays.fill()

七、Arrays.binarySearch()

八、Arrays.stream()

九、Arrays练习

1. 给定一个整型数组，使用Arrays类的方法将其所有元素填充为指定的值。

2. 给定两个整型数组，使用Arrays类的方法比较它们是否相等。

3. 给定一个整型数组，使用Arrays类的方法将其复制到一个新的数组中。

4. 给定一个整型二维数组，使用Arrays类的方法对其进行排序，按照每行第一个元素升序排序。

5. 给定一个已排序的整型数组，查找特定元素的位置。如果元素存在，则返回其索引；如果不存在，则返回一个负数。

6. 给定一个整型数组，将数组的前三个元素填充为3。

7. 给定一个整型数组，使用Arrays.copyOf方法创建一个新的数组，新数组是原数组的一个副本，但是长度是原数组长度的两倍。

8. 给定一个整型数组，将该数组的所有元素乘以2，赋值给一个新数组。

9. 合并两个int[]类型的数组，得到一个int[]类型的数组，再转换成List类型

10. 给定一个整型数组，去除数组中的重复元素，并返回一个没有重复元素的新数组，并求出最大值和最小值。

一、Arrays.toString()

  • 对于多维数组，直接调用 Arrays.toString() 只会打印子数组的引用，而不是内容。因此，需要遍历多维数组，并对每个子数组分别调用 Arrays.toString()。
import java.util.Arrays;

// 定义一个成绩类，包含学生ID、语文成绩、数学成绩以及总分
class Score {
    public int id;        // 学生ID
    public int Chinese;   // 语文成绩
    public int Math;      // 数学成绩
    public int sum;       // 总分

    // 构造方法，初始化学生ID、语文成绩、数学成绩，并计算总分
    Score(int id, int Chinese, int Math) {
        this.id = id;
        this.Chinese = Chinese;
        this.Math = Math;
        this.sum = Chinese + Math; // 计算总分
    }

    // 重写toString方法，方便输出成绩信息
    @Override
    public String toString() {
        return "Score{" +
                "id=" + id +
                ", Chinese=" + Chinese +
                ", Math=" + Math +
                ", sum=" + sum +
                "}";
    }
}

public class Main {
    public static void main(String[] args) {
        // 定义一个基本类型数组并初始化
        int[] intArray = {1, 2, 3, 4, 5};
        // 使用Arrays.toString()打印数组内容
        System.out.println(Arrays.toString(intArray)); // 输出: [1, 2, 3, 4, 5]

        // 定义一个二维数组并初始化
        int[][] multiArray = {{1, 2}, {3, 4}};
        // 打印二维数组的引用，不是内容
        System.out.println(Arrays.toString(multiArray)); // 输出: [[I@49e4cb85, [I@2133c8f8]

        // 遍历二维数组并打印每个一维数组的内容
        for (int[] arr : multiArray) {
            System.out.println(Arrays.toString(arr));
            // 输出每个一维数组的内容
            // [1, 2]
            // [3, 4]
        }

        // 定义一个成绩对象数组并初始化
        Score[] scoreArray = {
                new Score(1, 90, 80),
                new Score(2, 95, 86)
        };
        // 使用Arrays.toString()打印成绩对象数组的内容
        System.out.println(Arrays.toString(scoreArray)); // 输出: [Score{id=1, Chinese=90, Math=80, sum=170}, Score{id=2, Chinese=95, Math=86, sum=181}]
    }
}

二、Arrays.sort()

  • sort(Object[] a): 对整个数组进行排序。
  • sort(T[] a, int fromIndex, int toIndex): 对数组的指定范围进行排序。
import java.util.Arrays;
import java.util.Collections;

// 定义一个成绩类，包含学生ID、语文成绩、数学成绩以及总分
class Score {
    public int id;        // 学生ID
    public int Chinese;   // 语文成绩
    public int Math;      // 数学成绩
    public int sum;       // 总分

    // 构造方法，初始化学生ID、语文成绩、数学成绩，并计算总分
    Score(int id, int Chinese, int Math) {
        this.id = id;
        this.Chinese = Chinese;
        this.Math = Math;
        this.sum = Chinese + Math; // 计算总分
    }

    // 重写toString方法，方便输出成绩信息
    @Override
    public String toString() {
        return "Score{" +
                "id=" + id +
                ", Chinese=" + Chinese +
                ", Math=" + Math +
                ", sum=" + sum +
                "}";
    }
}

public class Main {
    public static void main(String[] args) {
        // 对基本类型的数组进行排序
        int[] intArr = {1, 3, 5, 7, 6, 4, 2};
        Arrays.sort(intArr); // 使用Arrays.sort进行升序排序
        System.out.println(Arrays.toString(intArr)); // 输出排序后的数组，结果为[1, 2, 3, 4, 5, 6, 7]

        // 对包装类型的数组进行降序排序
        Integer[] integerArr = {1, 3, 5, 7, 6, 4, 2};
        Arrays.sort(integerArr, Collections.reverseOrder()); // 使用Collections.reverseOrder进行降序排序
        System.out.println(Arrays.toString(integerArr)); // 输出排序后的数组，结果为[7, 6, 5, 4, 3, 2, 1]

        // 对成绩对象数组进行排序
        Score[] scoreArr = {
                new Score(1, 90, 80),
                new Score(2, 95, 86),
                new Score(3, 95, 100),
                new Score(4, 80, 90)
        };

        // 按照总分降序排序，如果总分一样，按照语文成绩降序排序
        Arrays.sort(scoreArr,
                (s1, s2) -> s2.sum - s1.sum == 0 ? s2.Chinese - s1.Chinese : s2.sum - s1.sum
        );
        // 遍历并输出排序后的成绩数组
        for (var i : scoreArr) {
            System.out.println(i);
        }
        // 输出结果：
        // Score{id=3, Chinese=95, Math=100, sum=195}
        // Score{id=2, Chinese=95, Math=86, sum=181}
        // Score{id=1, Chinese=90, Math=80, sum=170}
        // Score{id=4, Chinese=80, Math=90, sum=170}
    }
}

三、Arrays.equals()

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建两个整型数组
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {5, 4, 3, 2, 1};

        // 使用 Arrays.equals 比较两个数组
        boolean equals = Arrays.equals(array1, array2);
        System.out.println("array1 和 array2 是否相等: " + equals); // true

        equals = Arrays.equals(array1, array3);
        System.out.println("array1 和 array3 是否相等: " + equals); // false
    }
}

四、Arrays.asList()

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 使用 Arrays.asList 将数组转换为 List
        Integer[] array = {1, 2, 3, 4, 5};
        List<Integer> list1 = Arrays.asList(array); //可改元素，不能增加和删除

        // 输出转换后的 List
        System.out.println(list1); // 输出 [1, 2, 3, 4, 5]

        // 尝试修改 List 中的一个元素
        list1.set(0, 10); // 这是允许的，因为它修改了原始数组中的元素
        System.out.println(list1); // 输出 [10, 2, 3, 4, 5]

        // 尝试添加或删除元素将抛出异常
        // list1.add(6); // 抛出 UnsupportedOperationException
        // list1.remove(1); // 抛出 UnsupportedOperationException

        // 比较Arrays.asList 和 List.of
        List<Integer> list2 = List.of(array);
        // 输出创建的 List
        System.out.println(list2); // 输出 [1, 2, 3, 4, 5]

        // 尝试修改 List 中的一个元素将抛出异常
        // list2.set(0, 10); // 抛出 UnsupportedOperationException

        // 尝试添加或删除元素也将抛出异常
        // list2.add(6); // 抛出 UnsupportedOperationException
        // list2.remove(1); // 抛出 UnsupportedOperationException

    }
}

五、Arrays.copyOf()

  • int[] copyOf(int[] original, int newLength)：从original数组中截取长度为newLength的新数组
  •  int[] copyOfRange(int[] original, int from, int to)：从original数组中截取[from,to)新数组
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 示例1：复制基本数据类型数组
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] newArray = Arrays.copyOf(originalArray, 10);                   // 新数组长度为10
        System.out.println("新数组（基本数据类型）: " + Arrays.toString(newArray));        //[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

        // 示例2：复制对象数组
        String[] originalStringArray = {"Apple", "Banana", "Cherry"};
        String[] newStringArray = Arrays.copyOf(originalStringArray, 5);     // 新数组长度为5
        System.out.println("新数组（对象数组）: " + Arrays.toString(newStringArray));     //[Apple, Banana, Cherry, null, null]

        // 示例3：新数组长度小于原始数组
        int[] originalArray2 = {1, 2, 3, 4, 5};
        int[] newArray2 = Arrays.copyOf(originalArray2, 3);                  // 新数组长度为3
        System.out.println("新数组（部分复制）: " + Arrays.toString(newArray2));          //[1, 2, 3]

        // 示例4：使用Arrays.copyOfRange复制数组的一部分
        int[] newArray3 = Arrays.copyOfRange(originalArray2, 1, 4);
        System.out.println("新数组（copyOfRange）: " + Arrays.toString(newArray3));     //[2, 3, 4]

    }
}

六、Arrays.fill()

  • void fill(Object[] a, Object val)：填充数组
  • void fill(Object[] a, int fromIndex, int toIndex, Object val)：填充数组[fromIndex,toIndex)
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建一个整型数组
        int[] array = new int[10];

        // 使用 fill 方法将整个数组填充为 5
        Arrays.fill(array, 5);
        System.out.println("填充整个数组: " + Arrays.toString(array)); // [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]

        // 使用 fill 方法将数组的索引 3 到索引 7 的元素填充为 8
        Arrays.fill(array, 3, 8, 8);
        System.out.println("填充部分数组: " + Arrays.toString(array)); // [5, 5, 5, 8, 8, 8, 8, 8, 5, 5]
    }
}

七、Arrays.binarySearch()

（1）int binarySearch(Object[] a, Object key)：

  • 在数组a中查找key。
  • 如果找到key，则返回其在数组中的索引。
  • 如果未找到key，则返回-(insertion point) - 1，其中insertion point是key应该插入的位置。

（2）int binarySearch(int[] a, int fromIndex, int toIndex, int key)：

  • 在数组a的子数组[fromIndex, toIndex)中查找key。
  • 如果找到key，则返回其在子数组中的索引。
  • 如果未找到key，则返回-(insertion point) - 1，其中insertion point是key应该插入的位置。
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建并初始化一个已排序的整型数组
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15};

        // 查找元素7
        int index1 = Arrays.binarySearch(array, 7);
        System.out.println(index1); // 3

        // 在子数组[2, 6)中[5, 7, 9, 11]查找元素5
        int index2 = Arrays.binarySearch(array, 2, 6, 5);
        System.out.println(index2); // 2

        // 查找一个不存在的元素，比如4
        int index3 = Arrays.binarySearch(array, 4);
        System.out.println(index3); // 应输出一个负数，表示插入点
    }
}

八、Arrays.stream()

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.OptionalDouble;
import java.util.OptionalInt;

public class Main {

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        // 案例1: 计算数组元素的总和
        int sum = Arrays.stream(numbers).sum();
        System.out.println("Sum: " + sum); // 预期输出: Sum: 55

        // 案例2: 计算数组元素的平均值
        OptionalDouble average = Arrays.stream(numbers).average();
        System.out.println("Average: " + average.getAsDouble()); // 预期输出: Average: 5.5

        // 案例3: 找出数组中的最大值
        OptionalInt max = Arrays.stream(numbers).max();
        System.out.println("Max: " + max.getAsInt()); // 预期输出: Max: 10

        // 案例4: 找出数组中的最小值
        OptionalInt min = Arrays.stream(numbers).min();
        System.out.println("Min: " + min.getAsInt()); // 预期输出: Min: 1

        // 案例5: 计算数组中偶数的个数
        long evenCount = Arrays.stream(numbers).filter(n -> n % 2 == 0).count();
        System.out.println("Even count: " + evenCount); // 预期输出: Even count: 5

        // 案例6: 将数组中的每个元素乘以2
        int[] multiplied = Arrays.stream(numbers).map(n -> n * 2).toArray();
        System.out.println("Multiplied: " + Arrays.toString(multiplied)); // 预期输出: Multiplied: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

        // 案例7: 将数组中的偶数平方
        int[] squaredEvens = Arrays.stream(numbers).filter(n -> n % 2 == 0).map(n -> n * n).toArray();
        System.out.println("Squared evens: " + Arrays.toString(squaredEvens)); // 预期输出: Squared evens: [4, 16, 36, 64, 100]

        // 案例8: 检查数组中是否所有元素都大于0
        boolean allPositive = Arrays.stream(numbers).allMatch(n -> n > 0);
        System.out.println("All positive: " + allPositive); // 预期输出: All positive: true

        // 案例9: 检查数组中是否至少有一个元素大于5
        boolean anyGreaterThanFive = Arrays.stream(numbers).anyMatch(n -> n > 5);
        System.out.println("Any greater than 5: " + anyGreaterThanFive); // 预期输出: Any greater than 5: true

        // 案例10: 获取数组元素的统计信息
        IntSummaryStatistics stats = Arrays.stream(numbers).summaryStatistics();
        System.out.println("Statistics: " + stats); // 预期输出: Statistics: IntSummaryStatistics{count=10, sum=55, min=1, average=5.500000, max=10}
    }
}

九、Arrays练习

1. 给定一个整型数组，使用Arrays类的方法将其所有元素填充为指定的值。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 4, 5, 7, 9, 3};
        Arrays.fill(arr, 1);
        System.out.println(Arrays.toString(arr));
    }
}

2. 给定两个整型数组，使用Arrays类的方法比较它们是否相等。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1, 4, 5, 7, 9, 3};
        int[] arr2 = {1, 4, 5, 7, 9, 3};
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals); //true
    }
}

3. 给定一个整型数组，使用Arrays类的方法将其复制到一个新的数组中。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1, 4, 5, 7, 9, 3};
        int[] arr2 = Arrays.copyOf(arr1, arr1.length);
        System.out.println(Arrays.toString(arr2)); //[1, 4, 5, 7, 9, 3]
    }
}

4. 给定一个整型二维数组，使用Arrays类的方法对其进行排序，按照每行第一个元素升序排序。

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        int[][] arr = {{3, 5}, {1, 2}, {4, 6}};
        Arrays.sort(arr, Comparator.comparingInt(a -> a[0]));
        for (int[] a : arr) {
            System.out.println(Arrays.toString(a));
        }
        //[1, 2]
        //[3, 5]
        //[4, 6]

    }
}

5. 给定一个已排序的整型数组，查找特定元素的位置。如果元素存在，则返回其索引；如果不存在，则返回一个负数。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 6, 7, 8, 9};
        int i1 = Arrays.binarySearch(arr, 3);
        int i2 = Arrays.binarySearch(arr, 4);
        System.out.println(i1); // 1
        System.out.println(i2); // -3
    }
}

6. 给定一个整型数组，将数组的前三个元素填充为3。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 6, 7, 8, 9};
        Arrays.fill(arr,0,3,3);
        System.out.println(Arrays.toString(arr)); //[3, 3, 3, 6, 7, 8, 9]
    }
}

7. 给定一个整型数组，使用Arrays.copyOf方法创建一个新的数组，新数组是原数组的一个副本，但是长度是原数组长度的两倍。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 6, 7, 8, 9};
        int[] arr2 = Arrays.copyOf(arr1, arr1.length * 2);
        System.out.println(Arrays.toString(arr2)); //[1, 3, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0]
    }
}

8. 给定一个整型数组，将该数组的所有元素乘以2，赋值给一个新数组。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 6, 7, 8, 9};
        int[] arr2 = Arrays.stream(arr1)
                .map(i -> i * 2)
                .toArray();
        System.out.println(Arrays.toString(arr2)); //[2, 6, 10, 12, 14, 16, 18]
    }
}

9. 合并两个int[]类型的数组，得到一个int[]类型的数组，再转换成List<Integer>类型

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 7, 9};
        int[] arr2 = {2, 4, 6, 8, 10, 12};
        int[] arr3 = Arrays.copyOf(arr1, arr1.length + arr2.length);

        System.out.println(Arrays.toString(arr3)); //[1, 3, 5, 7, 9, 0, 0, 0, 0, 0, 0]

        //从arr2的0号元素开始，复制到arr3，从arr3的arr1.length号元素开始，复制arr2.length个元素
        System.arraycopy(arr2, 0, arr3, arr1.length, arr2.length);
        System.out.println(Arrays.toString(arr3)); //[1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 12]

        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3)); //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]

        List<Integer> list = Arrays.stream(arr3)
                .boxed()
                .collect(Collectors.toList());
        System.out.println(list);                  //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12]

    }
}

10. 给定一个整型数组，去除数组中的重复元素，并返回一个没有重复元素的新数组，并求出最大值和最小值。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 3, 3, 3, 5, 5, 6, 8, 9};
        int[] arr2 = Arrays.stream(arr1)
                .distinct()
                .toArray();
        System.out.println(Arrays.toString(arr2)); //[1, 3, 5, 6, 8, 9]

        int max = Arrays.stream(arr2).max().getAsInt();
        int min = Arrays.stream(arr2).min().getAsInt();
        System.out.println(max); // 9
        System.out.println(min); // 1
    }
}

阅读全部

相关推荐

  1. Arrays的用法（附10道练习题）

    2024-07-17 13:50:02       24 阅读

  5. 1.7.2 python练习题15道

    2024-07-17 13:50:02       29 阅读

  6. MySQL SQL100道基础练习题

    2024-07-17 13:50:02       17 阅读

  7. 100道ajax面试题、练习题

    2024-07-17 13:50:02       21 阅读

  10. arrays.sort用法详解

    2024-07-17 13:50:02       50 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-17 13:50:02       67 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-17 13:50:02       71 阅读

  9. 在Django里面运行非项目文件

    2024-07-17 13:50:02       58 阅读

  19. Python语言-面向对象

    2024-07-17 13:50:02       69 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-17 13:50:02       64 阅读

热门阅读

  3. Hadoop之/etc目录下各配置文件的作用详解

    2024-07-17 13:50:02       18 阅读

  5. 前端学习常用技术栈

    2024-07-17 13:50:02       23 阅读

  8. Perl语言入门学习

    2024-07-17 13:50:02       20 阅读

  9. 【闲聊】-Perl的基础语法

    2024-07-17 13:50:02       24 阅读

  15. LVS的NAT方式

    2024-07-17 13:50:02       18 阅读

  16. SAP中MIR4使用的BAPI是什么，如何使用？

    2024-07-17 13:50:02       21 阅读

  17. cuda--docker

    2024-07-17 13:50:02       25 阅读

  19. WHAT - 介绍一个不太一样的 UI 组件库 shadcn/ui

    2024-07-17 13:50:02       19 阅读

  20. C# 实体更新记录：如何捕获和记录字段变化到日志

    2024-07-17 13:50:02       19 阅读

  23. 从零开始！Jupyter Notebook的安装教程

    2024-07-17 13:50:02       22 阅读

  24. 数仓工具—Hive语法之替换函数和示例

    2024-07-17 13:50:02       19 阅读

  27. 油管吃播鼻祖被流量吞噬的半生

    2024-07-17 13:50:02       23 阅读

  30. ActiViz实战：ActiViz中的自己实现鼠标双击事件

    2024-07-17 13:50:02       28 阅读