第三章：数组[4Arrays]

最新推荐文章于 2023-12-18 16:22:47 发布

王爷的大房子

最新推荐文章于 2023-12-18 16:22:47 发布

阅读量121

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/Lucky-stars/p/11009942.html

版权

①API

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

②方法

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

从类 java.lang.Object 继承的方法
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

③

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 
 
    }
}