数据结构--数组(二)

一、数组简介

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java语言中提供的数组是用来存储固定大小的同类型元素。

二、数组定义：

 int[] scores={76,83,92,87};
数组
int[] scores={76,83,92,87,50};
// 读取下标为1的数组元素
System.out.println(scores[1]);

遍历数组：

    @Test
    public void test() {
        int[] scores = {76, 83, 92, 87, 50};
        System.out.println(scores[1]);
        for (int i : scores) {
            System.out.println(i);
        }
    }
结果

三、Arrays 类操作 Java 中的数组

Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。

常用方法：
Arrays.asList(T… data)
注意：该方法返回的是 Arrays 内部静态类 ArrayList，而不是我们平常使用的 ArrayList,，该静态类 ArrayList 没有覆盖父类的 add(), remove() 等方法，所以如果直接调用，会报 UnsupportedOperationException 异常。

List<Integer> list = Arrays.asList(1, 2, 3);
list.forEach(System.out::println);

Arrays.fill(Object[] array, Object obj)
用指定元素填充整个数组 (会替换掉数组中原来的元素)

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)
用指定元素填充数组，从起始位置到结束位置，取头不取尾 (会替换掉数组中原来的元素)

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 0, 2, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

Arrays.sort(Object[] array)
对数组元素进行排序 (串行排序)

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
Arrays.sort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

Arrays.sort(T[] array, Comparator<? super T> comparator)
使用自定义比较器，对数组元素进行排序 (串行排序)

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 实现降序排序，返回-1放左边，1放右边，0保持不变
Arrays.sort(data, (str1, str2) -> {
    if (str1.compareTo(str2) > 0) {
        return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]

Arrays.sort(Object[] array, int fromIndex, int toIndex)
对指定范围内的数组元素进行排序 (串行排序)

Arrays.sort(T[] array, int fromIndex, int toIndex, Comparator<? super T> c)
使用自定义比较器，对指定范围内的数组元素进行排序 (串行排序)

Arrays.parallelSort(T[] array)
对数组元素进行排序 (并行排序)，当数据规模较大时，会有更好的性能

String[] data = {"1", "4", "3", "2"};
Arrays.parallelSort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

Arrays.binarySearch(Object[] array, Object key)
注意：在调用该方法之前，必须先调用 Arrays.sort() 方法进行排序，如果数组没有排序，那么结果是不确定的，此外如果数组中包含多个指定元素，则无法保证将找到哪个元素
使用二分法查找数组内指定元素的索引值

当搜索元素是数组元素时，返回该元素的索引值
当搜索元素不是数组元素时，返回 - (索引值 + 1)

搜索元素是数组元素，返回该元素索引值:

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
System.out.println(Arrays.binarySearch(data, 1)); // 0

搜索元素不是数组元素，且小于数组中的最小值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {0, 1, 3, 5, 7}，此时0的索引值为0，则搜索0时返回 -(0 + 1) = -1
System.out.println(Arrays.binarySearch(data, 0)); // -1

搜索元素不是数组元素，且大于数组中的最大值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {1, 3, 5, 7， 9}，此时9的索引值为4，则搜索8时返回 -(4 + 1) = -5
System.out.println(Arrays.binarySearch(data, 9)); // -5

搜索元素不是数组元素，但在数组范围内

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// 此时程序会把数组看作 {1, 2, 3, 5, 7}，此时2的索引值为1，则搜索2时返回 -(1 + 1) = -2
System.out.println(Arrays.binarySearch(data, 2)); // -2

Arrays.binarySearch(Object[] array, int fromIndex, int toIndex, Object obj)
使用二分法查找数组内指定范围内的指定元素的索引值

Integer[] data = {1, 3, 5, 7};
Arrays.sort(data);
// {1, 3}，3的索引值为1
System.out.println(Arrays.binarySearch(data, 0, 2, 3)); // 1

Arrays.copyOf(T[] original, int newLength)
拷贝数组，其内部调用了 System.arraycopy() 方法，从下标 0 开始，如果超过原数组长度，则会用 null 进行填充

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data3 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data3)); // [1, 2, 3, 4, null]

Arrays.copyOfRange(T[] original, int from, int to)
拷贝数组，指定起始位置和结束位置，如果超过原数组长度，则会用 null 进行填充

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOfRange(data1, 0, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOfRange(data1, 0, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

Arrays.equals(Object[] array1, Object[] array2)
判断两个数组是否相等
数组元素为基本数据类型时，依次比较值
数组元素为引用数据类型时，依次调用元素的 equals() 方法进行比较
即如果两个数组被认为是相等的，则两个数组中应包含相同顺序的相同元素

Integer[] data1 = {1, 2, 3};
Integer[] data2 = {1, 2, 3};
System.out.println(Arrays.equals(data1, data2)); // true

Arrays.deepEquals(Object[] array1, Object[] array2)
判断两个多维数组是否相等
数组元素为基本数据类型时，依次比较值
数组元素为引用数据类型时，依次调用元素的 equals() 方法进行比较
即如果两个多维数组被认为是相等的，则两个多维数组中应包含相同顺序的相同元素

Integer[][] data1 = {{1,2,3}, {1,2,3}};
Integer[][] data2 = {{1,2,3}, {1,2,3}};
System.out.println(Arrays.deepEquals(data1, data2)); // true

Arrays.setAll(T[] array, IntFunction<? extends T> generator)
让数组中的所有元素，串行地使用方法提供的生成器函数来计算每个元素 (一元操作)

Integer[] data = {1, 2, 3, 4};
// i为索引值
Arrays.setAll(data, i -> data[i] * 2);
System.out.println(Arrays.toString(data)); // [2, 4, 6, 8]

Arrays.parallelSetAll(T[] array, IntFunction<? extends T> generator)
让数组中的所有元素，并行地使用方法提供的生成器函数来计算每个元素 (一元操作)，当数据规模较大时，会有更好的性能

Integer[] data = {1, 2, 3, 4};
// i为索引值
Arrays.parallelSetAll(data, i -> data[i] * 2);
System.out.println(Arrays.toString(data)); // [2, 4, 6, 8]

Arrays.parallelPrefix(T[] array, BinaryOperator op)
让数组中的所有元素，并行地使用方法提供的生成器函数来计算每个元素 (二元操作)，当数据规模较大时，会有更好的性能

Integer[] data = {2, 3, 4, 5};
// 第一个元素2不变，将其与第二个元素3一起作为参数x, y传入，得到乘积6，作为数组新的第二个元素
// 再将6和第三个元素4一起作为参数x, y传入，得到乘积24，作为数组新的第三个元素，以此类推
Arrays.parallelPrefix(data, (x, y) -> x * y);
System.out.println(Arrays.toString(data)); // [2, 6, 24, 120]

Arrays.spliterator(T[] array)
返回数组的分片迭代器，用于并行地遍历数组

public class Students {

    private String name;

    private Integer age;

    public Students(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    // 省略get、set方法
}

public static void main(String[] args) {
    Students[] data = new Students[5];
    IntStream.range(0,5).forEach(i -> data[i] = new Students("小明"+i+"号", i));
    // 返回分片迭代器
    Spliterator<Students> spliterator = Arrays.spliterator(data);
    spliterator.forEachRemaining(stu -> {
        System.out.println("学生姓名: " + stu.getName() + "  " + "学生年龄: " + stu.getAge());
        // 学生姓名: 小明0号  学生年龄: 0
        // 学生姓名: 小明1号  学生年龄: 1
        // 学生姓名: 小明2号  学生年龄: 2
        // 学生姓名: 小明3号  学生年龄: 3
        // 学生姓名: 小明4号  学生年龄: 4
    });
}

Arrays.stream(T[] array)
返回数组的流 (Stream)，然后我们就可以使用 Stream 相关的许多方法了

Integer[] data = {1, 2, 3, 4};
List<Integer> list = Arrays.stream(data).collect(toList());
System.out.println(list); // [1, 2, 3, 4]

四、构建动态数组
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 常见基础知识
    一、基础知识：1、JVM、JRE和JDK的区别：JVM(Java Virtual Machine):java虚拟机...
    杀小贼阅读 2,433评论 0赞 4
  • java基础04集合框架
    四、集合框架 1：String类：字符串(重点) (1)多个字符组成的一个序列，叫字符串。生活中很多数据的描述都采...
    佘大将军阅读 786评论 0赞 2
  • ArrayList的源码分析
    ArrayList是最常用的数组，这里我们分析一下源码： ArrayList继承了AbstractList<E> ...
    说dian什么好呢阅读 777评论 0赞 0
  • 2018-01-24
    1.单行注释：“//”2.多行注释：“/ /” if条件语句 1. if(bloolean 表达式){pass;...
    再也不喊饿阅读 591评论 0赞 0
  • 月光
    月光从亮子 逃进来 黑暗的房间 长了一双明亮的眼睛
    河岛阅读 291评论 0赞 1