Java提高篇之数组（2）

﹏ヽ暗。殇╰゛Y 2022-12-21 09:23 148阅读 0赞

上篇文章定义了数组，简单介绍了数组及一维数组和二维数组，我们知道，数组是用来存储数据的，那么涉及到数据，必然有对于数据的操作，即增删改查，尤其涉及到数组时，设计到数据结构和算法相关，算法相关的内容在数据结构和算法系列博客中会详细介绍，本篇博客介基于数组Array类的相关方法，即统计数组的最大值、最小值、平均值、总和，复制数组，数组比较，数组元素比较数组排序，查找，等的实现。

（一）数组Array类简介

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比 如排序和搜索）的各种方法。其有一套用于数组的static方法，

*  该类包含用于操作数组的各种方法（如排序和搜索）。 该类还包含一个静态工厂，可以将数组视为列表。
 *  如果指定的数组引用为空，则该类中的方法都抛出一个`NullPointerException` ，除非另有说明。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70][]

（二）统计数组的最大值、最小值、平均值、总和

package arrays;//: arrays/ArrayOptions.java
    // Initialization & re-assignment of arrays.
    class ArrayOption {
      public static void main(String args[]) {
        int data[] = new int[] {1, 2, 3, 4, 66, 5, 6, 7, 8, 9};
        double result[] = stat(data);
        double max =result[0];
        double min=result[1];
        double sum=result[2];
        double arr=result[3];
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
        System.out.println("数据总和：" + sum);
        System.out.println("平均值：" + arr);
      }
    
      //此时需要返回的数据一共有四个，那么一个方法只能够返回一种数据类型，所以应该使用数组返回
      //数组[0]为最大值、数组[1]为最小值、数组[2]为数据总和、数组[3]为平均值
      public static double[] stat(int data[]) {
        double reData[] = new double[4];
        reData[0] = data[0];
        reData[1] = data[0];
        reData[2] = data[0];
        for(int x = 1; x < data.length; x++) {
          reData[2] += data[x];
          if(data[x] > reData[0])
            reData[0] = data[x];
          if(data[x] < reData[1])
            reData[1] = data[x];
        }
        reData[3] = reData[2] / data.length;
        return reData;
      }
    }

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1][]

（三）复制数组

数组的复制要用到System.arraycopy(),arraycopy()方法需要的参数有：原数组，表示从原数组什么位置开始复制的偏移量，表示从目标数组什么位置开始复制的偏移量，以及需要复制元素的个数。当然，对于数组的越界操作均会导致异常。

package arrays;//: arrays/CopyingArrays.java
    // Using System.arraycopy()
    import java.util.*;
    
    public class CopyingArrays {
      public static void main(String[] args) {
        int[] i = new int[7];
        int[] j = new int[10];
        Arrays.fill(i, 47);
        Arrays.fill(j, 99);
        System.out.println("i = " + Arrays.toString(i));
        System.out.println("j = " + Arrays.toString(j));
        System.arraycopy(i, 0, j, 0, i.length);
        System.out.println("j = " + Arrays.toString(j));
        int[] k = new int[5];
        Arrays.fill(k, 103);
        System.arraycopy(i, 0, k, 0, k.length);
        System.out.println("k = " + Arrays.toString(k));
        Arrays.fill(k, 103);
        System.arraycopy(k, 0, i, 0, k.length);
        System.out.println("i = " + Arrays.toString(i));
        // Objects:
        Integer[] u = new Integer[10];
        Integer[] v = new Integer[5];
        Arrays.fill(u, new Integer(47));
        Arrays.fill(v, new Integer(99));
        System.out.println("u = " + Arrays.toString(u));
        System.out.println("v = " + Arrays.toString(v));
        System.arraycopy(v, 0, u, u.length/2, v.length);
        System.out.println("u = " + Arrays.toString(u));
      }
    } /* Output:
    i = [47, 47, 47, 47, 47, 47, 47]
    j = [99, 99, 99, 99, 99, 99, 99, 99, 99, 99]
    j = [47, 47, 47, 47, 47, 47, 47, 99, 99, 99]
    k = [47, 47, 47, 47, 47]
    i = [103, 103, 103, 103, 103, 47, 47]
    u = [47, 47, 47, 47, 47, 47, 47, 47, 47, 47]
    v = [99, 99, 99, 99, 99]
    u = [47, 47, 47, 47, 47, 99, 99, 99, 99, 99]
    *///:~

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2][]

（四）数组比较

数组相等的条件为元素个数必须相等，且对应位置的元素也相等。

package arrays;//: arrays/ComparingArrays.java
    // Using Arrays.equals()
    import java.util.*;
    
    
    public class ComparingArrays {
      public static void main(String[] args) {
        int[] a1 = new int[10];
        int[] a2 = new int[10];
        Arrays.fill(a1, 47);
        Arrays.fill(a2, 47);
        System.out.println(Arrays.equals(a1, a2));
        a2[3] = 11;
        System.out.println(Arrays.equals(a1, a2));
        String[] s1 = new String[4];
        Arrays.fill(s1, "Hi");
        String[] s2 = { new String("Hi"), new String("Hi"),
          new String("Hi"), new String("Hi") };
        System.out.println(Arrays.equals(s1, s2));
      }
    } /* Output:
    true
    false
    true
    *///:~

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3][]

（五）数组元素比较

package arrays;//: arrays/CompType.java
    // Implementing Comparable in a class.
    
    
    import java.util.Arrays;
    
    public class CompType  {
    
      public static void main(String[] args) {
    
        int []a=new int[]{11,22,55,99,452,65,1,5,486,22 };
        System.out.println("before sorting:");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("after sorting:");
        System.out.println(Arrays.toString(a));
      }
    }

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4][]

（六）数组排序

package arrays;//: arrays/StringSorting.java
    
    import java.util.Arrays;
    import java.util.Collections;
    
    public class StringSorting {
      public static void main(String[] args) {
    
        String [] sa=new String[]{"YNzbr", "nyGcF", "OWZnT", "cQrGs", "eGZMm", "JMRoE", "suEcU", "OneOE"
                , "dLsmw", "HLGEa", "hKcxr", "EqUCB", "bkIna", "Mesbt", "WHkjU", "rUkZP", "gwsqP", "zDyCy", "RFJQA", "HxxHv"};
        System.out.println("Before sort: " + Arrays.toString(sa));
        Arrays.sort(sa);
        System.out.println("After sort: " + Arrays.toString(sa));
        Arrays.sort(sa, Collections.reverseOrder());
        System.out.println("Reverse sort: " + Arrays.toString(sa));
        Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER);
        System.out.println("Case-insensitive sort: " + Arrays.toString(sa));
      }
    } /* Output:
    Before sort: [YNzbr, nyGcF, OWZnT, cQrGs, eGZMm, JMRoE, suEcU, OneOE, dLsmw, HLGEa, hKcxr, EqUCB, bkIna, Mesbt, WHkjU, rUkZP, gwsqP, zDyCy, RFJQA, HxxHv]
    After sort: [EqUCB, HLGEa, HxxHv, JMRoE, Mesbt, OWZnT, OneOE, RFJQA, WHkjU, YNzbr, bkIna, cQrGs, dLsmw, eGZMm, gwsqP, hKcxr, nyGcF, rUkZP, suEcU, zDyCy]
    Reverse sort: [zDyCy, suEcU, rUkZP, nyGcF, hKcxr, gwsqP, eGZMm, dLsmw, cQrGs, bkIna, YNzbr, WHkjU, RFJQA, OneOE, OWZnT, Mesbt, JMRoE, HxxHv, HLGEa, EqUCB]
    Case-insensitive sort: [bkIna, cQrGs, dLsmw, eGZMm, EqUCB, gwsqP, hKcxr, HLGEa, HxxHv, JMRoE, Mesbt, nyGcF, OneOE, OWZnT, RFJQA, rUkZP, suEcU, WHkjU, YNzbr, zDyCy]
    *///:~

运行结果为：

Before sort: [YNzbr, nyGcF, OWZnT, cQrGs, eGZMm, JMRoE, suEcU, OneOE, dLsmw, HLGEa, hKcxr, EqUCB, bkIna, Mesbt, WHkjU, rUkZP, gwsqP, zDyCy, RFJQA, HxxHv]
    After sort: [EqUCB, HLGEa, HxxHv, JMRoE, Mesbt, OWZnT, OneOE, RFJQA, WHkjU, YNzbr, bkIna, cQrGs, dLsmw, eGZMm, gwsqP, hKcxr, nyGcF, rUkZP, suEcU, zDyCy]
    Reverse sort: [zDyCy, suEcU, rUkZP, nyGcF, hKcxr, gwsqP, eGZMm, dLsmw, cQrGs, bkIna, YNzbr, WHkjU, RFJQA, OneOE, OWZnT, Mesbt, JMRoE, HxxHv, HLGEa, EqUCB]
    Case-insensitive sort: [bkIna, cQrGs, dLsmw, eGZMm, EqUCB, gwsqP, hKcxr, HLGEa, HxxHv, JMRoE, Mesbt, nyGcF, OneOE, OWZnT, RFJQA, rUkZP, suEcU, WHkjU, YNzbr, zDyCy]
    
    Process finished with exit code 0

（七）查找

package arrays;//: arrays/ArraySearching.java
    // Using Arrays.binarySearch().
    import java.util.*;
    public class ArraySearching {
      public static void main(String[] args) {
        int []a=new int[]{11,22,55,99,452,65,1,5,486,22 };
        System.out.println("Sorted before: " + Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("Sorted array: " + Arrays.toString(a));
        System.out.println("数组中22 出现的位置:"+Arrays.binarySearch(a, 22));
      }
    }

运行结果为：

![20201115222058913.png][]

（八）返回一个数组

package arrays;//: arrays/IceCream.java
    // Returning arrays from methods.
    import java.util.*;
    
    public class IceCream {
      private static Random rand = new Random(47);
      static final String[] FLAVORS = {
        "Chocolate", "Strawberry", "Vanilla Fudge Swirl",
        "Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
        "Praline Cream", "Mud Pie"
      };
      public static String[] flavorSet(int n) {
        if(n > FLAVORS.length)
          throw new IllegalArgumentException("Set too big");
        String[] results = new String[n];
        boolean[] picked = new boolean[FLAVORS.length];
        for(int i = 0; i < n; i++) {
          int t;
          do
            t = rand.nextInt(FLAVORS.length);
          while(picked[t]);
          results[i] = FLAVORS[t];
          picked[t] = true;
        }
        return results;
      }
      public static void main(String[] args) {
        for(int i = 0; i < 7; i++)
          System.out.println(Arrays.toString(flavorSet(3)));
      }
    } /* Output:
    [Rum Raisin, Mint Chip, Mocha Almond Fudge]
    [Chocolate, Strawberry, Mocha Almond Fudge]
    [Strawberry, Mint Chip, Mocha Almond Fudge]
    [Rum Raisin, Vanilla Fudge Swirl, Mud Pie]
    [Vanilla Fudge Swirl, Chocolate, Mocha Almond Fudge]
    [Praline Cream, Strawberry, Mocha Almond Fudge]
    [Mocha Almond Fudge, Strawberry, Mint Chip]
    *///:~

运行结果为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5][]

以上代码均出自Java编程思想。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20221120/7c7cadf9e1d04ce4979ac627e93f7fef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 1]: /images/20221120/b9ba7d967f4b4725a6fe0d616bf3840e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 2]: /images/20221120/208a71b5f83b42c8afecab48d17e3fba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 3]: /images/20221120/c769799d96704ed58d1231aedf82646f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 4]: /images/20221120/9e33ca5602224452905db5c4477468a0.png
[20201115222058913.png]: /images/20221120/0c8151d6ccf54301925d5c2a50e942e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201115223134512.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg==,size_16,color_FFFFFF,t_70