关于java:Arrays点燃你的数组操作技巧的隐秘武器

48次阅读

共计 6372 个字符，预计需要花费 16 分钟才能阅读完成。

前言

  数组在 Java 中是一种罕用的数据结构，用于存储和操作大量数据。然而在解决数组中的数据，可能会变得复杂和繁琐。Arrays 是咱们在解决数组时的一把利器。它提供了丰盛的办法和性能，使得数组操作变得更加简略、高效和牢靠。无论是排序、搜寻、比拟还是复制，Arrays 都可能满足咱们的需要，来帮忙咱们充分发挥数组的后劲。接下来咱们一起看看 Arrays 的各种性能和用法，以帮忙咱们更好地利用这个弱小的工具。

  1. asList() – 转换为固定大小列表：将指定的元素转换为一个固定大小的列表。
  2. binarySearch() – 二分查找：在指定数组中应用二分查找算法查找指定元素。
  3. copyOf() – 复制数组：将指定数组的正本复制到一个新数组中。
  4. copyOfRange() – 范畴复制数组：将指定数组的指定范畴内的元素复制到一个新数组中。
  5. fill() – 填充数组：将指定的值填充到数组的每个元素中。
  6. equals() – 比拟数组相等性：比拟两个数组是否相等。
  7. setAll() – 设置所有元素：应用指定的生成器函数设置数组的元素值。
  8. sort() – 排序数组：对指定数组进行升序排序。
  9. stream() – 转换为流：将数组转换为流。
  10. spliterator() – 宰割迭代器：创立一个用于遍历数组元素的宰割迭代器。
  11. parallelPrefix() – 并行前缀：对数组中的元素进行累积操作，将后果存储在数组中。
  12. parallelSetAll() – 并行设置所有元素：应用指定的生成器函数并行地设置数组的元素值。
  13. parallelSort() – 并行排序：对指定数组进行并行排序。
  14. hashCode() – 哈希码值：返回数组的哈希码值。
  15. deepHashCode() – 多维数组的哈希码值：返回多维数组的哈希码值。
  16. deepToString() – 多维数组的字符串示意模式：返回多维数组的字符串示意模式。
  17. toString() – 数组的字符串示意模式：返回数组的字符串示意模式。

代码示例

1. asList() – 转换为固定大小列表：

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

public class AsListExample {public static void main(String[] args) {String[] array = {"A", "B", "C"};
        System.out.println("原始数组:" + Arrays.toString(array));
        List<String> list = Arrays.asList(array);
        System.out.println("转换后的列表:" + list);
    }
}

输入后果：

 原始数组: [A, B, C]
转换后的列表: [A, B, C]

2. binarySearch() – 二分查找：

import java.util.Arrays;

public class BinarySearchExample {public static void main(String[] args) {int[] numbers = {2, 4, 6, 8, 10};
        int key = 6;
        System.out.println("数组:" + Arrays.toString(numbers));
        int index = Arrays.binarySearch(numbers, key);
        System.out.println("要查找的元素:" + key);
        System.out.println("元素的索引地位:" + index);
    }
}

输入后果：

 数组: [2, 4, 6, 8, 10]
要查找的元素: 6
元素的索引地位: 2

3. copyOf() – 复制数组：

import java.util.Arrays;

public class CopyOfExample {public static void main(String[] args) {int[] sourceArray = {1, 2, 3};
        System.out.println("源数组:" + Arrays.toString(sourceArray));
        int[] copyArray = Arrays.copyOf(sourceArray, sourceArray.length);
        System.out.println("复制后的数组:" + Arrays.toString(copyArray));
    }
}

输入后果：

 源数组: [1, 2, 3]
复制后的数组: [1, 2, 3]

4. copyOfRange() – 范畴复制数组：

import java.util.Arrays;

public class CopyOfRangeExample {public static void main(String[] args) {int[] sourceArray = {1, 2, 3, 4, 5};
        System.out.println("源数组:" + Arrays.toString(sourceArray));
        int[] copyArray = Arrays.copyOfRange(sourceArray, 1, 4);
        System.out.println("复制后的数组:" + Arrays.toString(copyArray));
    }
}

输入后果：

 源数组: [1, 2, 3, 4, 5]
复制后的数组: [2, 3, 4]

5. fill() – 填充数组：

import java.util.Arrays;

public class FillExample {public static void main(String[] args) {int[] arrayToFill = new int[5];
        System.out.println("原始数组:" + Arrays.toString(arrayToFill));
        int valueToFill = 10;
        Arrays.fill(arrayToFill, valueToFill);
        System.out.println("填充后的数组:" + Arrays.toString(arrayToFill));
    }
}

输入后果：

 原始数组: [0, 0, 0, 0, 0]
填充后的数组: [10, 10, 10, 10, 10]

6. equals() – 比拟数组相等性：

import java.util.Arrays;

public class EqualsExample {public static void main(String[] args) {int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};
        System.out.println("数组 1:" + Arrays.toString(array1));
        System.out.println("数组 2:" + Arrays.toString(array2));
        boolean areEqual = Arrays.equals(array1, array2);
        System.out.println("数组 1 和数组 2 是否相等:" + areEqual);
    }
}

输入后果：

 数组 1: [1, 2, 3]
数组 2: [1, 2, 3]
数组 1 和数组 2 是否相等: true

7. setAll() – 设置所有元素：

import java.util.Arrays;

public class SetAllExample {public static void main(String[] args) {int[] arrayToSet = new int[5];
        System.out.println("原始数组:" + Arrays.toString(arrayToSet));
        Arrays.setAll(arrayToSet, i -> i * 2);
        System.out.println("设置后的数组:" + Arrays.toString(arrayToSet));
    }
}

输入后果：

 原始数组: [0, 0, 0, 0, 0]
设置后的数组: [0, 2, 4, 6, 8]

8. sort() – 排序数组：

import java.util.Arrays;

public class SortExample {public static void main(String[] args) {int[] arrayToSort = {5, 2, 8, 1, 6};
        System.out.println("原始数组:" + Arrays.toString(arrayToSort));
        Arrays.sort(arrayToSort);
        System.out.println("排序后的数组:" + Arrays.toString(arrayToSort));
    }
}

输入后果：

 原始数组: [5, 2, 8, 1, 6]
排序后的数组: [1, 2, 5, 6, 8]

9. stream() – 转换为流：

import java.util.Arrays;

public class StreamExample {public static void main(String[] args) {int[] arrayToStream = {1, 2, 3, 4, 5};
        System.out.println("数组:" + Arrays.toString(arrayToStream));
        Arrays.stream(arrayToStream).forEach(System.out::println);
    }
}

输入后果：

 数组: [1, 2, 3, 4, 5]
1
2
3
4
5

10. spliterator() – 宰割迭代器：

import java.util.Arrays;

public class SpliteratorExample {public static void main(String[] args) {int[] arrayToSplit = {1, 2, 3, 4, 5};
        System.out.println("数组:" + Arrays.toString(arrayToSplit));
        Arrays.spliterator(arrayToSplit).forEachRemaining((Consumer<Integer>) System.out::println);
    }
}

输入后果：

 数组: [1, 2, 3, 4, 5]
1
2
3
4
5

11. parallelPrefix() – 并行前缀：

import java.util.Arrays;

public class ParallelPrefixExample {public static void main(String[] args) {int[] arrayToPrefix = {1, 2, 3, 4, 5};
        System.out.println("原始数组:" + Arrays.toString(arrayToPrefix));
        Arrays.parallelPrefix(arrayToPrefix, (a, b) -> a * b);
        System.out.println("并行前缀数组:" + Arrays.toString(arrayToPrefix));
    }
}

输入后果：

 原始数组: [1, 2, 3, 4, 5]
并行前缀数组: [1, 2, 6, 24, 120]

12. parallelSetAll() – 并行设置所有元素：

import java.util.Arrays;

public class ParallelSetAllExample {public static void main(String[] args) {int[] arrayToSetAll = new int[5];
        System.out.println("原始数组:" + Arrays.toString(arrayToSetAll));
        Arrays.parallelSetAll(arrayToSetAll, i -> i * 3);
        System.out.println("设置后的数组:" + Arrays.toString(arrayToSetAll));
    }
}

输入后果：

 原始数组: [0, 0, 0, 0, 0]
设置后的数组: [0, 3, 6, 9, 12]

13. parallelSort() – 并行排序：

import java.util.Arrays;

public class ParallelSortExample {public static void main(String[] args) {int[] arrayToParallelSort = {5, 2, 8, 1, 6};
        System.out.println("原始数组:" + Arrays.toString(arrayToParallelSort));
        Arrays.parallelSort(arrayToParallelSort);
        System.out.println("排序后的数组:" + Arrays.toString(arrayToParallelSort));
    }
}

输入后果：

 原始数组: [5, 2, 8, 1, 6]
排序后的数组: [1, 2, 5, 6, 8]

14. hashCode() – 哈希码值：

import java.util.Arrays;

public class HashCodeExample {public static void main(String[] args) {int[] arrayToHash = {1, 2, 3};
        System.out.println("数组:" + Arrays.toString(arrayToHash));
        int hashCode = Arrays.hashCode(arrayToHash);
        System.out.println("数组的哈希码值:" + hashCode);
    }
}

输入后果：

 数组: [1, 2, 3]
数组的哈希码值: 30817

15. deepHashCode() – 多维数组的哈希码值：

import java.util.Arrays;

public class DeepHashCodeExample {public static void main(String[] args) {int[][] multiDimensionalArray = {{1, 2}, {3, 4}};
        System.out.println("多维数组:" + Arrays.deepToString(multiDimensionalArray));
        int deepHashCode = Arrays.deepHashCode(multiDimensionalArray);
        System.out.println("多维数组的哈希码值:" + deepHashCode);
    }
}

输入后果：

 多维数组: [[1, 2], [3, 4]]
多维数组的哈希码值: 32833

16. deepToString() – 多维数组的字符串示意模式：

import java.util.Arrays;

public class DeepToStringExample {public static void main(String[] args) {int[][] multiDimensionalArray = {{1, 2}, {3, 4}};
        System.out.println("多维数组:" + Arrays.deepToString(multiDimensionalArray));
    }
}

输入后果：

 多维数组: [[1, 2], [3, 4]]

17. toString() – 数组的字符串示意模式：

import java.util.Arrays;

public class ToStringExample {public static void main(String[] args) {int[] arrayToString = {1, 2, 3};
        System.out.println("数组:" + Arrays.toString(arrayToString));
    }
}

输入后果：

 数组: [1, 2, 3]

结尾

  如果感觉对你有帮忙，能够多多评论，多多点赞哦，也能够到我的主页看看，说不定有你喜爱的文章，也能够顺手点个关注哦，谢谢。

  我是不一样的科技宅，每天提高一点点，体验不一样的生存。咱们下期见！

正文完
java
发表至： java
2023-05-07
 0
关于spring:SpringMVC-九大组件之-HandlerAdapter-深入分析
关于java:JAVA-设计模式系列工厂模式
关于java:公司开发遇到的框架问题
关于java:发布jar包到maven中央仓库