Java中数组常用方法的总结

一、Java标准类库提供static方法System.arraycopy(),用它复制数组比用for循环复制要快得多，     System.arraycopy()针对所有的类型做了重载，需要5个参数。 

    第一个参数：源数组。 

    第二个参数：偏移量,即从哪个位置开始复制的索引。 

    第三个参数：目标数组。 

    第四个参数：偏移量。 

    第五个参数：要从源数组中复制到目标数组元素的个数,一般情况下为目标数组的长度。 

例： 

    从A数组中复制元素到B数组？ 

    public class Practice { 

        public static void main(String[] args){ 

            String[] A = {"H

            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

               String[] B = {"一二三"}; 

                 String[] C = {"1

                 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

                     System.out.println(Arrays.asList(A)); 

               } 

       } 

       运行结果为： 

                  [H, e, l, l, o]; 

五、数组中的排序 

    使用内置的排序方法，就可以对任意的基本类型数组排序，也可以对任意的对象数组进行排序，只要该对象实现了Comparable接口或具有相关联的Comparator接口 

    例： 

      已经数组String[] A = {"A现对数组A进行排序，要求忽略大小写排序？ 

      分析：String默认的排序方法，第一步是将大写字母开头的词均放在小写字母头的词的前面，然后才进行排序。 

            如：String[] A = {"A

                 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

                               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

                      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

                 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

                       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

                    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

                       Arrays.sort(a,Collections.reverseOrder()); 

                       System.out.println(Arrays.asList(a));    

                } 

        } 

      运行结果为：[c, b, a];