第三章：数组[4Arrays]-白红宇

第三章：数组[4Arrays]

阅读量：4922 次

发布时间：2019-06-11

本文共 9074 字，大约阅读时间需要 30 分钟。

①API

 
java.util 
类 Arrays
java.lang.Object
 继承者 java.util.Arrays
 
public class Arraysextends Object

②方法

                        方法摘要            
             static
                                <T> <T>                
                           (T... a)
          返回一个受指定数组支持的固定大小的列表。            
             static int             (byte[] a, byte key)
          使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。            
             static int             (byte[] a, int fromIndex, int toIndex, byte key)
          使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。            
             static int             (char[] a, char key)
          使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。            
             static int             (char[] a, int fromIndex, int toIndex, char key)
          使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。            
             static int             (double[] a, double key)
          使用二分搜索法来搜索指定的 double 型数组，以获得指定的值。            
             static int             (double[] a, int fromIndex, int toIndex, double key)
          使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。            
             static int             (float[] a, float key)
          使用二分搜索法来搜索指定的 float 型数组，以获得指定的值。            
             static int             (float[] a, int fromIndex, int toIndex, float key)
          使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。            
             static int             (int[] a, int key)
          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。            
             static int             (int[] a, int fromIndex, int toIndex, int key)
          使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。            
             static int             (long[] a, int fromIndex, int toIndex, long key)
          使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。            
             static int             (long[] a, long key)
          使用二分搜索法来搜索指定的 long 型数组，以获得指定的值。            
             static int             ([] a, int fromIndex, int toIndex,  key)
          使用二分搜索法来搜索指定数组的范围，以获得指定对象。            
             static int             ([] a,  key)
          使用二分搜索法来搜索指定数组，以获得指定对象。            
             static int             (short[] a, int fromIndex, int toIndex, short key)
          使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。            
             static int             (short[] a, short key)
          使用二分搜索法来搜索指定的 short 型数组，以获得指定的值。            
             static
                                <T> int                
                           (T[] a, int fromIndex, int toIndex, T key, <? super T> c)
          使用二分搜索法来搜索指定数组的范围，以获得指定对象。            
             static
                                <T> int                
                           (T[] a, T key, <? super T> c)
          使用二分搜索法来搜索指定数组，以获得指定对象。            
             static boolean[]             (boolean[] original, int newLength)
          复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。            
             static byte[]             (byte[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static char[]             (char[] original, int newLength)
          复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。            
             static double[]             (double[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static float[]             (float[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static int[]             (int[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static long[]             (long[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static short[]             (short[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。            
             static
                                <T> T[]                
                           (T[] original, int newLength)
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。            
             static
                                <T,U> T[]                
                           (U[] original, int newLength, <? extends T[]> newType)
          复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。            
             static boolean[]             (boolean[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static byte[]             (byte[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static char[]             (char[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static double[]             (double[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static float[]             (float[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static int[]             (int[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static long[]             (long[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static short[]             (short[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static
                                <T> T[]                
                           (T[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。            
             static
                                <T,U> T[]                
                           (U[] original, int from, int to, <? extends T[]> newType)
          将指定数组的指定范围复制到一个新数组。            
             static boolean             ([] a1, [] a2)
          如果两个指定数组彼此是深层相等 的，则返回 true。            
             static int             ([] a)
          基于指定数组的“深层内容”返回哈希码。            
             static              ([] a)
          返回指定数组“深层内容”的字符串表示形式。            
             static boolean             (boolean[] a, boolean[] a2)
          如果两个指定的 boolean 型数组彼此相等，则返回 true。            
             static boolean             (byte[] a, byte[] a2)
          如果两个指定的 byte 型数组彼此相等，则返回 true。            
             static boolean             (char[] a, char[] a2)
          如果两个指定的 char 型数组彼此相等，则返回 true。            
             static boolean             (double[] a, double[] a2)
          如果两个指定的 double 型数组彼此相等，则返回 true。            
             static boolean             (float[] a, float[] a2)
          如果两个指定的 float 型数组彼此相等，则返回 true。            
             static boolean             (int[] a, int[] a2)
          如果两个指定的 int 型数组彼此相等，则返回 true。            
             static boolean             (long[] a, long[] a2)
          如果两个指定的 long 型数组彼此相等，则返回 true。            
             static boolean             ([] a, [] a2)
          如果两个指定的 Objects 数组彼此相等，则返回 true。            
             static boolean             (short[] a, short[] a2)
          如果两个指定的 short 型数组彼此相等，则返回 true。            
             static void             (boolean[] a, boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组的每个元素。            
             static void             (boolean[] a, int fromIndex, int toIndex, boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。            
             static void             (byte[] a, byte val)
          将指定的 byte 值分配给指定 byte 节型数组的每个元素。            
             static void             (byte[] a, int fromIndex, int toIndex, byte val)
          将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。            
             static void             (char[] a, char val)
          将指定的 char 值分配给指定 char 型数组的每个元素。            
             static void             (char[] a, int fromIndex, int toIndex, char val)
          将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。            
             static void             (double[] a, double val)
          将指定的 double 值分配给指定 double 型数组的每个元素。            
             static void             (double[] a, int fromIndex, int toIndex, double val)
          将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。            
             static void             (float[] a, float val)
          将指定的 float 值分配给指定 float 型数组的每个元素。            
             static void             (float[] a, int fromIndex, int toIndex, float val)
          将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。            
             static void             (int[] a, int val)
          将指定的 int 值分配给指定 int 型数组的每个元素。            
             static void             (int[] a, int fromIndex, int toIndex, int val)
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。            
             static void             (long[] a, int fromIndex, int toIndex, long val)
          将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。            
             static void             (long[] a, long val)
          将指定的 long 值分配给指定 long 型数组的每个元素。            
             static void             ([] a, int fromIndex, int toIndex,  val)
          将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。            
             static void             ([] a,  val)
          将指定的 Object 引用分配给指定 Object 数组的每个元素。            
             static void             (short[] a, int fromIndex, int toIndex, short val)
          将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。            
             static void             (short[] a, short val)
          将指定的 short 值分配给指定 short 型数组的每个元素。            
             static int             (boolean[] a)
          基于指定数组的内容返回哈希码。            
             static int             (byte[] a)
          基于指定数组的内容返回哈希码。            
             static int             (char[] a)
          基于指定数组的内容返回哈希码。            
             static int             (double[] a)
          基于指定数组的内容返回哈希码。            
             static int             (float[] a)
          基于指定数组的内容返回哈希码。            
             static int             (int[] a)
          基于指定数组的内容返回哈希码。            
             static int             (long[] a)
          基于指定数组的内容返回哈希码。            
             static int             ([] a)
          基于指定数组的内容返回哈希码。            
             static int             (short[] a)
          基于指定数组的内容返回哈希码。            
             static void             (byte[] a)
          对指定的 byte 型数组按数字升序进行排序。            
             static void             (byte[] a, int fromIndex, int toIndex)
          对指定 byte 型数组的指定范围按数字升序进行排序。            
             static void             (char[] a)
          对指定的 char 型数组按数字升序进行排序。            
             static void             (char[] a, int fromIndex, int toIndex)
          对指定 char 型数组的指定范围按数字升序进行排序。            
             static void             (double[] a)
          对指定的 double 型数组按数字升序进行排序。            
             static void             (double[] a, int fromIndex, int toIndex)
          对指定 double 型数组的指定范围按数字升序进行排序。            
             static void             (float[] a)
          对指定的 float 型数组按数字升序进行排序。            
             static void             (float[] a, int fromIndex, int toIndex)
          对指定 float 型数组的指定范围按数字升序进行排序。            
             static void             (int[] a)
          对指定的 int 型数组按数字升序进行排序。            
             static void             (int[] a, int fromIndex, int toIndex)
          对指定 int 型数组的指定范围按数字升序进行排序。            
             static void             (long[] a)
          对指定的 long 型数组按数字升序进行排序。            
             static void             (long[] a, int fromIndex, int toIndex)
          对指定 long 型数组的指定范围按数字升序进行排序。            
             static void             ([] a)
          根据元素的对指定对象数组按升序进行排序。            
             static void             ([] a, int fromIndex, int toIndex)
          根据元素的对指定对象数组的指定范围按升序进行排序。            
             static void             (short[] a)
          对指定的 short 型数组按数字升序进行排序。            
             static void             (short[] a, int fromIndex, int toIndex)
          对指定 short 型数组的指定范围按数字升序进行排序。            
             static
                                <T> void                
                           (T[] a, <? super T> c)
          根据指定比较器产生的顺序对指定对象数组进行排序。            
             static
                                <T> void                
                           (T[] a, int fromIndex, int toIndex, <? super T> c)
          根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。            
             static              (boolean[] a)
          返回指定数组内容的字符串表示形式。            
             static              (byte[] a)
          返回指定数组内容的字符串表示形式。            
             static              (char[] a)
          返回指定数组内容的字符串表示形式。            
             static              (double[] a)
          返回指定数组内容的字符串表示形式。            
             static              (float[] a)
          返回指定数组内容的字符串表示形式。            
             static              (int[] a)
          返回指定数组内容的字符串表示形式。            
             static              (long[] a)
          返回指定数组内容的字符串表示形式。            
             static              ([] a)
          返回指定数组内容的字符串表示形式。            
             static              (short[] a)
          返回指定数组内容的字符串表示形式。            
          
                        从类 java.lang. 继承的方法            
             , , , , , , , , , ,              
          

从类 java.lang. 继承的方法
`, , , , , , , , , ,`

③

import java.util.Arrays;
/*
 * Arrays:针对数组进行操作的工具类。比如说排序和查找。
 * 1:public static String toString(int[] a) 把数组转成字符串
 * 2:public static void sort(int[] a) 对数组进行排序
 * 3:public static int binarySearch(int[] a,int key) 二分查找[排好序的数组]
 * 4:public static <T> List<T>  asList(T... a)返回一个受指定数组支持的固定大小的列表。
 */
public class ArraysDemo { 
    public static void main(String[] args) { 
        // 定义一个数组
        int[] arr = { 24, 69, 80, 57, 13 };
        // public static String toString(int[] a) 把数组转成字符串
        System.out.println("排序前：" + Arrays.toString(arr));
        
       // public static void sort(int[] a) 对数组进行排序
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));// [13, 24, 57, 69, 80]
 
        // public static int binarySearch(int[] a,int key) 二分查找[排好序的数组]
        System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));
        System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
        
       // public static <T> List<T>  asList(T... a)返回一个受指定数组支持的固定大小的列表。
        String[] stringArray = { "a", "b", "c", "d", "e" };
        ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
        System.out.println(arrayList);// [a, b, c, d, e]
        
       //Array.equals(数组名A，数组名B),比较两个数组A、B是否相等
        String[] A = {"1","2","3"};
        String[] B = {"一","二","三"};
        String[] C = {"1","2","3"};
        System.out.println(Arrays.equals(A, B));//false
        System.out.println(Arrays.equals(A, C));//true
        
       //Array.Fill(数组名，值)此方法用于填充数组。
        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
        }
 
       //检查一个数组是否包含某值List的contains()
 
       String[] arr= { "a", "b", "c", "d", "e" };  
       boolean b = Arrays.asList(arr).contains("a");  
       System.out.println(b);  // true 
 
    }
}

④

⑤

⑥

⑦

⑧

⑨

⑩

⑪

⑫

⑬

⑭

⑮

⑯

⑰

⑱

⑲

⑳

转载于:https://www.cnblogs.com/Lucky-stars/p/11009942.html

你可能感兴趣的文章