数组最常用方法

- 日理万妓 2024-03-29 15:07 83阅读 0赞

#### 目录 ####

*  初始化数组
 *  复制数组
 *  合并数组
 *  截取子串
 *  数组遍历
 *  基本方法
 *  检查数组是否包含某个值
 *  查找元素下标
 *  查找并返回两个同类型数组之间第一个不匹配的索引
 *  插入元素
 *  移除数组中的元素
 *  逆向一个数组
 *  移动数组的顺序
 *  交换数组两元素位置
 *  二次编辑每个元素
 *  Java8流式用法
 *  数据equals
 *  数组 to string
 *  数组 to List
 *  List to 数组
 *  数组 to Set
 *  数组 to Map
 *  打印二维数组
 *  将整数转换为字节数组
 *  参考

## 初始化数组 ##

String[] arr = new String[] {
        "zyy", "zxx", "zww"};
    String[] arr = {
        "wyy", "wzz", "wxx", "wxx"};
    String[] arr = ArrayUtils.toArray("a", "b", "c", "d", "e");
    
    String[] arr = new String[4];
    Arrays.fill(arr , "wyy");
    
    String[] arr = arr .clone();
    String[] arr = ArrayUtils.clone(s3);

## 复制数组 ##

Integer[] array1 = {
        1, 1, 1, 2, 7, 11, 22, 37};
    Integer[] integers = Arrays.copyOf(array1, 4);  // [1, 1, 1, 2]
    
    String[] s1 = {
        "wyy", "wzz", "wxx", "wxx"};
    String[] strArr = Arrays.copyOf(s1, 4); // [wyy, wzz, wxx, wxx]
    
    String[] strings1 = Arrays.copyOfRange(s1, 0, 1); //[wyy]
    String[] strings2 = Arrays.copyOfRange(s1, 0, s1.length); //[wyy, wzz, wxx, wxx]
    String[] strings3 = Arrays.copyOfRange(s1, 0, s1.length - 1); //[wyy, wzz, wxx]

## 合并数组 ##

int[] intArray = {
        1, 2, 88, 3, 4, 5};
    int[] intArray2 = {
         6, 7, 8, 9, 10 };
    
    int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2); //create a new array
    //[1, 2, 88, 3, 4, 5, 6, 7, 8, 9, 10]

## 截取子串 ##

String[] stringArray1 = {
        "a", "b", "c", "d", "e"};
    String[] subarray = ArrayUtils.subarray(stringArray1, 1, 3); // [b, c]

--------------------

## 数组遍历 ##

int[] s5 = new int[] {
        7, 3, 2, 8, 9};
    
    for (Integer s : s5) {
        
        System.out.print(s + " ");
    }
    
    for (int i = 0; i < s5.length; i++) {
        
        System.out.print(s5[i] + " ");
    }

--------------------

## 基本方法 ##

boolean a = ArrayUtils.isEmpty(stringArray);
    boolean b = ArrayUtils.isNotEmpty(stringArray);
    boolean b = ArrayUtils.isSameLength(stringArray);   判断两个数组的长度是否相同，要同类型；
    boolean b = ArrayUtils.isSameType(stringArray);     判断两个数组的类型是否相同
    boolean b = ArrayUtils.isSorted(stringArray);       判断数组是否以自然顺序排序
    boolean b = ArrayUtils.nullToEmpty(stringArray);

## 检查数组是否包含某个值 ##

String[] stringArray = {
        "a", "b", "c", "d", "e"};
    boolean b = Arrays.asList(stringArray).contains("a");
    boolean a = ArrayUtils.contains(stringArray, "a");

--------------------

## 查找元素下标 ##

# 查找元素下标
    Integer[] array1 = {
        1, 1, 1, 2, 7, 11, 22, 37};
    int i = Arrays.binarySearch(array1, 2);
    System.out.println(i); // 3
    
    # 查找元素第一次出现的下标
    int a = ArrayUtils.indexOf(stringArray, "a");
    
    # 查找所有元素下标
    String[] stringArray = {
        "a", "b", "c", "d", "a"};
    BitSet a = ArrayUtils.indexesOf(stringArray, "a");   // {0, 4}
    BitSet a = ArrayUtils.indexesOf(arr, "a", 2);       从下标为2开始查找3D这个值得所有下标
    
    # 查找元素最后一次出现的下标
    int a = ArrayUtils.lastIndexOf(stringArray, "a");
    
    # 查找下标是否有效
    ArrayUtils.isArrayIndexValid(null, 0)       // false
    ArrayUtils.isArrayIndexValid([], 0)         // false
    ArrayUtils.isArrayIndexValid(["a"], 0)      // true

## 查找并返回两个同类型数组之间第一个不匹配的索引 ##

int[] array1 = {
        2, 7, 11, 22, 37};
    int[] array2 = {
        2, 7, 11, 22, 37};
    int[] array3 = {
        2, 7, 19, 31, 39, 56};
    
    int index1 = Arrays.mismatch(array1, array2); //-1
    int index2 = Arrays.mismatch(array1, array3); // 2

--------------------

## 插入元素 ##

# 从数组后添加元素
    String[] stringArray = {
        "a", "b", "c", "d", "e"};
    String[] fs = ArrayUtils.add(stringArray, "f"); // [a, b, c, d, e, f]
    
    # 往数组里添加数组
    String[] stringArray = {
        "a", "b", "c", "d", "e"};
    String[] stringArray2 = {
        "a", "b", "c", "d", "e"};
    String[] fs = ArrayUtils.addAll(stringArray, stringArray2); // [a, b, c, d, e, a, b, c, d, e]
    
    # 从数组前添加元素
    String[] stringArray = {
        "a", "b", "c", "d", "e"};
    String[] fs = ArrayUtils.addFirst(stringArray, "t"); // [t, a, b, c, d, e]
    
    # 插入元素到指定位置
     String[] stringArray = {
        "a", "a", "b", "c", "d", "a"};
     String[] zs = ArrayUtils.insert(1, stringArray, "z"); // [a, z, a, b, c, d, a]

## 移除数组中的元素 ##

# 删除指定位置元素 create a new array
    ArrayUtils.remove(["a"], 0)           = []
    ArrayUtils.remove(["a", "b"], 0)      = ["b"]
    ArrayUtils.remove(["a", "b"], 1)      = ["a"]
    ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]
    
    # 删除指定位置多个元素
    ArrayUtils.removeAll([1], 0)             = []
    ArrayUtils.removeAll([2, 6], 0)          = [6]
    ArrayUtils.removeAll([2, 6], 0, 1)       = []
    ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
    ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
    ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
    
    # 删除所有指定元素
    ArrayUtils.removeElement(null, true)                = null
    ArrayUtils.removeElement([], true)                  = []
    ArrayUtils.removeElement([true], false)             = [true]
    ArrayUtils.removeElement([true, false], false)      = [true]
    ArrayUtils.removeElement([true, false, true], true) = [false, true]

--------------------

## 逆向一个数组 ##

int[] intArray = {
         1, 2, 3, 4, 5 };
    ArrayUtils.reverse(intArray);  // [5, 4, 3, 2, 1]

## 移动数组的顺序 ##

# Shifts the order of the given int array
    String[] stringArray1 = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray1,1); // [e, a, b, c, d]
    
    String[] stringArray = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray,2); // [d, e, a, b, c]
    
    String[] stringArray2 = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray2,3); // [c, d, e, a, b]
    
    String[] stringArray3 = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray3,4); // [b, c, d, e, a]
    
    String[] stringArray4 = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray4,5); //  [a, b, c, d, e]
    
    String[] stringArray5 = {
        "a", "b", "c", "d", "e"};
    ArrayUtils.shift(stringArray5,6);// 6%5 ->1 取模 [e, a, b, c, d]

## 交换数组两元素位置 ##

ArrayUtils.swap(["1", "2", "3"], 0, 2) -> ["3", "2", "1"]
    ArrayUtils.swap(["1", "2", "3"], 0, 0) -> ["1", "2", "3"]
    ArrayUtils.swap(["1", "2", "3"], 1, 0) -> ["2", "1", "3"]
    ArrayUtils.swap(["1", "2", "3"], 0, 5) -> ["1", "2", "3"]
    ArrayUtils.swap(["1", "2", "3"], -1, 1) -> ["2", "1", "3"]

--------------------

## 二次编辑每个元素 ##

double[] a = {
        1.0, 2.0, 3.0, 4.4};
    Arrays.setAll(a, x -> a[x] * a[x]);
    System.out.println("数组中整数的平方：" + Arrays.toString(a));
    数组中整数的平方：[1.0, 4.0, 9.0, 19.360000000000003]

## Java8流式用法 ##

Double[] stringArray = {
        1D, 2D, 3D, 11D, 22D, 33D, 111D, 222D, 333D};
    Arrays.stream(stringArray).filter(a -> a > 2D).forEach(aDouble -> System.out.print(aDouble + " 、")); 
    // 3.0 、11.0 、22.0 、33.0 、111.0 、222.0 、333.0 、
    
    Arrays.stream(stringArray, 0, 4).filter(a -> a > 2D).forEach(aDouble -> System.out.print(aDouble + " 、"));
    // 3.0 、11.0 、

--------------------

## 数据equals ##

Integer[] array1 = {
        1, 1, 1, 2, 7, 11, 22, 37};
    Integer[] array2 = {
        1, 1, 1, 2, 7, 11, 22, 37};
    
    boolean equals = Arrays.equals(array1, array2); // true
    
    boolean equals1 = Arrays.equals(array1, 2, 4, array2, 2, 4); // true
    
    boolean equals3 = Arrays.equals(array1, array2, new Comparator<Integer>() {
        
        @Override
        public int compare(Integer o1, Integer o2) {
        
            return (o1 < o2  ? -1 : (o1.equals(o2) ? 0 : 1));
        }
    });  // true
    
    boolean equals4 = Arrays.equals(array1, array2, (o1, o2) -> (o1 < o2 ? -1 : (o1.equals(o2) ? 0 : 1)));
    System.out.println(equals);  // true

## 数组 to string ##

String[] s1 = {
        "wyy", "wzz", "wxx", "wxx"};
    
    # String提供实现
    String str4 = String.join(",", s1); // wyy,wzz,wxx,wxx
    String str3 = StringUtils.join(s1, ","); // wyy,wzz,wxx,wxx
    
    # 数组提供实现
    String str1 = Arrays.toString(s1); // [wyy, wzz, wxx, wxx]
    String str2 = ArrayUtils.toString(s1); // {wyy,wzz,wxx,wxx}
    
    # 自定义实现
    String str5 = Arrays.stream(s1).collect(Collectors.joining(",")); // wyy,wzz,wxx,wxx

--------------------

## 数组 to List ##

String[] s2 = {
        "wyy", "wzz", "wxx", "wxx"};
    
    List<String> list = Arrays.asList(s2);
    List<String> list = List.of(s2);
    List<String> list = new ArrayList<>(List.of(s2));
    ist<String> list = new ArrayList<>(Arrays.asList(s2));

## List to 数组 ##

Integer[] list = integers2.toArray(Integer[]::new);
    Integer[] list = integers2.toArray(new Integer[0]);
    Integer[] list = integers2.toArray(new Integer[integers2.size()]);

**[字符串,数组,集合之间相互转换总结][Link 1]**

## 数组 to Set ##

Set<String> set = new HashSet<>(Arrays.asList(s2));

## 数组 to Map ##

Map colorMap = ArrayUtils.toMap(new String[][] {
        
        {
        "RED", "#FF0000"},
        {
        "GREEN", "#00FF00"},
        {
        "BLUE", "#0000FF"}
    });

--------------------

## 打印二维数组 ##

//  打印二维数组
    int[][] ints = new int[][]{
        {
        1, 2, 3}, {
        4, 5, 6}};
    
    Arrays.stream(ints).forEach(a -> System.out.println(Arrays.toString(a)));
    
    [1, 2, 3]
    [4, 5, 6]

## 将整数转换为字节数组 ##

byte[] bytes = ByteBuffer
        // 从堆空间中分配缓冲区4个字节
        .allocate(4)
        //向ByteBuffer写数据
        .putInt(100).array();
    
    // Stream.of(bytes).forEach(a -> System.out.format("0x%x ", a)); 报错
    for (byte t : bytes) {
        
        System.out.format("0x%x ", t);
    }
    
    0x0 0x0 0x0 0x64

--------------------

## 参考 ##

**[stackoverflow中票数最多的数组操作方法][stackoverflow]**  
**[斩草除根学ArrayUtils][ArrayUtils]**  
**[斩草除根学Arrays][Arrays]**

[Link 1]: https://blog.csdn.net/weixin_37646636/article/details/128600562
[stackoverflow]: https://www.jianshu.com/p/cb4813967e33
[ArrayUtils]: https://www.jianshu.com/p/aa28a1e39327
[Arrays]: https://www.jianshu.com/p/abaefbe09f12