Java中数组常用方法的总结

一、Java标准类库提供static方法System.arraycopy(),用它复制数组比用for循环复制要快得多，     System.arraycopy()针对所有的类型做了重载，需要5个参数。
    第一个参数：源数组。
    第二个参数：偏移量,即从哪个位置开始复制的索引。
    第三个参数：目标数组。
    第四个参数：偏移量。
    第五个参数：要从源数组中复制到目标数组元素的个数,一般情况下为目标数组的长度。
例：
    从A数组中复制元素到B数组？
    public class Practice {
        public static void main(String[] args){
            String[] A = {"H","e","l","l","o"};
            String[] B = new String[3];
            System.arraycopy(A, 0, B, 1, B.length - 1);
          for(int i = 0; i < B.length; i ++){
                 System.out.print(B[i] + " ");
            }
      }
    }
    运行结果为：null H e;
二、Array.Fill(数组名，值)此方法用于填充数组。
    例：
       现向已知数组A中填充值？
       public class Practice {
             public static void main(String[] args){
                   String[] A = new String[5];
                   Arrays.fill(A, "Hello");
                   for(int i = 0; i < A.length; i ++){
                 System.out.print(A[i] + " ");
              }
         }
       }
       运行结果为：
                  Hello Hello Hello Hello Hello
三、Array.equals(数组名A，数组名B),比较两个数组A、B是否相等，此方法针对所有基本类型与object都作了重载，例如比较两个数是否相等用Integer.equals()方法……，通过object.equals()方法比较数组是否相等，是基于内容的。
    例：
       三个已知数组的比较？
       public class Practice {
       public static void main(String[] args){
                 String[] A = {"1","2","3"};
               String[] B = {"一","二","三"};
                 String[] C = {"1","2","3"};
                 System.out.println(Arrays.equals(A, B));
                 System.out.println(Arrays.equals(A, C));
           }
       }
       运行结果为：false
                            true
四、Array.asList()此方法用于输出数组中的所有数.
    例：
       输出已知数组A中的所有数？
       public class Practice {
               public static void main(String[] args){
                       String[] A = {"H","e","l","l","o"};
                     System.out.println(Arrays.asList(A));
               }
       }
       运行结果为：
                  [H, e, l, l, o];
五、数组中的排序
    使用内置的排序方法，就可以对任意的基本类型数组排序，也可以对任意的对象数组进行排序，只要该对象实现了Comparable接口或具有相关联的Comparator接口
    例：
      已经数组String[] A = {"A","B","c","D","e","f","G","H"};现对数组A进行排序，要求忽略大小写排序？
      分析：String默认的排序方法，第一步是将大写字母开头的词均放在小写字母头的词的前面，然后才进行排序。
            如：String[] A = {"A","B","c","D","e","f","G","H"};
                 Arrays.sort(A);
                   System.out.println(Arrays.asList(A));
            运行结果为：[A, B, D, G, H, c, e, f];
      如果想忽略大小写，可以通过自定义排序方式来实现：
            如：
                public class Practice1 implements Comparator{  
                        public static void main(String[] args){
                               String[] A = {"A","B","c","D","e","f","G","H"};
                               Arrays.sort(A,new Practice1());
                               System.out.println(Arrays.asList(A));
                        }

                        public int compare(Object o1, Object o2) {
                               String s1 = (String)o1;
                               String s2 = (String)o2;
                               return s1.toLowerCase().compareTo(s2.toLowerCase());
                        }
                }
            运行结果为：[A, B, c, D, e, f, G, H];
六、使用Arrays.binarySearch()执行快速查找。
    例：快速查找数组A中的元素？
        public class Practice{  
                public static void main(String[] args){
                        String[] a = {"a","d","e","w","f"};
                      Arrays.sort(a);
                      System.out.println(Arrays.asList(a));
                        int index1 = Arrays.binarySearch(a, "f");
                        System.out.println("要查找的值存在的时候：" + index1);
                        int index2 = Arrays.binarySearch(a, "n");
                        index2 = -index2 - 1;
                        System.out.print("当不存在的时候输出该值最可能存在的位置：" + index2);
               }
        }  
    注意：不要对未排序的数组使用binarySearch();
七、Arrays.copyOf()用法,这个方法是将原数组快速复制成一个新数组。如果新数组的长度小于旧数组的长度，将截取一部分旧数组中的元素，复制给新数组，
    反之，如果大于旧数组的长度，则将以0，null，或false给予补充。
    例：快速复制数组？
     public class Practice{  
       public static void main(String[] args){
                 String[] a = {"a","d","e","w","f"};
                 String[] b = new String[4];
                 String[] c = new String[5];
                 String[] d = new String[6];
                 b = Arrays.copyOf(a, b.length);
                 c = Arrays.copyOf(a, c.length);
                 d = Arrays.copyOf(a, d.length);
             System.out.println("b数组的元素：" + Arrays.asList(b));
                 System.out.println("c数组的元素：" + Arrays.asList(c));
             System.out.println("d数组的元素：" + Arrays.asList(d));
      }
     }
     运行结果为：
                b数组的元素：[a, d, e, w]
               c数组的元素：[a, d, e, w, f]
                d数组的元素：[a, d, e, w, f, null]
八、Arrays.copyOfRange()用法，这个方法与前面介绍的Arrays.copyOf()的用法相似，下面来通过具体实例讲解。
    例：如何将原数组指定复制一个新数组？
     public class Practice{  
              public static void main(String[] args){
                       String[] a = {"a","d","e","w","f"};
                       String[] b = new String[4];
                       b = Arrays.copyOfRange(a, 2, 4);
                     System.out.println("b数组的元素：" + Arrays.asList(b));
            }
     }
    运行结果为：
               b数组的元素：[e, w];
    相信读者已知道其中用法了吧，type[] N = Arrays.copyofRange("原数组",i,j)就是复制原数组赋值给新的数组N,指定从索引i到j;

九、Arrays.deepToString()用法，这个方法的用法同Arrays.asList()的用法相似,此方法是为了将多维数组转换为字符串而设计的；
    下面通过例子来看一下它们的相同点。
    例：输出已知数组a中的元素。
   public class Practice{  
         public static void main(String[] args){
                String[] a = {"a","d","e","w","f"};
                    System.out.println("用Arrays.asList()方法输出：" + Arrays.asList(a));
                    System.out.println("用Arrays.deepToString()方法输出：" + Arrays.deepToString(a));;
            }
   }
    运行结果为：
              用Arrays.asList()方法输出：[a, d, e, w, f]。
            用Arrays.deepToString()方法输出：[a, d, e, w, f]。
十、Arrays.deepEquals()的用法。
    说明：此方法与 Arrays.equals(Object[],Object[]) 方法不同，此方法适用于任意深度的嵌套数组。
          如果两个数组引用均为 null，或者它们引用了包含相同元素数量的数组，并且两个数组中的所
          有相应元素对都是深层相等的，则认为这两个数组引用是深层相等的。
    例：已知三个三维数组间的比较。
        public class Practice{  
      public static void main(String[] args){
                 String[][][] d = new String[2][2][2];
                 d[1][1][1] = "a";
                 String[][][] e = new String[3][3][3];
                   e[1][1][1] = "a";
                    String[][][] f = new String[2][2][2];
                  f[1][1][1] = "a";
                    String[][][] g = new String[2][2][2];
                g[1][1][1] = "ab";
   
                  System.out.println("--------------------------");
                  System.out.println("输出equals()方法与deepEquals()方法的区别；");
                    System.out.println("数组d与数组f进行比较： " + d.equals(f));
                  System.out.println("数组d与数组f进行比较： " + Arrays.deepEquals(d, f));
                    System.out.println("--------------------------");
   
                 //下面输出比较结果
              System.out.println("=================================");
                System.out.println("数组d与数组e进行比较： " + Arrays.deepEquals(d, e));
                System.out.println("数组d与数组g进行比较： " + Arrays.deepEquals(d, g)); 
                  System.out.println("=================================");
         }
}
   运行结果为：
             --------------------------
   输出equals()方法与deepEquals()方法的区别；
   数组d与数组f进行比较： false
   数组d与数组f进行比较： true
   --------------------------
   =================================
  数组d与数组e进行比较： false
   数组d与数组g进行比较： false
   =================================
十一、Collections.reverseOrder()用法(反转自然的顺序)；
      例：用除了循环外的另一方式逆向输出已知数组a？
         public class Practice{  
              public static void main(String[] args){
                       String[] a = {"a","b","c"};
                       Arrays.sort(a,Collections.reverseOrder());
                       System.out.println(Arrays.asList(a));   
                }
        }
      运行结果为：[c, b, a];