91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Java核心類庫Arrays的常用方法介紹

發布時間:2021-07-30 09:09:13 來源:億速云 閱讀:139 作者:chen 欄目:開發技術

本篇內容主要講解“Java核心類庫Arrays的常用方法介紹”,感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷,實用性強。下面就讓小編來帶大家學習“Java核心類庫Arrays的常用方法介紹”吧!

目錄
  • Java常用類庫Arrays

  • 一、常用方法

    • 1.1 toString

    • 1.2 Sort

      • 1.2.1 sort(T[] a, int fromIndex, int toIndex)

      • 1.2.2 Sort(T[] a)

      • 1.2.3 其它

    • 1.3 copyOf

      • 1.4 mismatch

        • 1.5 binarySearch

          • 1.5.1 binarySearch(T[] a, int fromIndex, int toIndex, T key)

          • 1.5.2 binarySearch(T[] a, T key)

          • 1.5.3 其它

        • 1.6 equals

          • 1.6.1 equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)

          • 1.6.2 equals(T[] a, T[] a2)

          • 1.6.3 其它

        • 1.7 fills

          • 1.7.1 fill(T[] a, int fromIndex, int toIndex, T val)

          • 1.7.2 fill(T[] a, T val)

      • 二、其他方法

        Java常用類庫Arrays

        類Arrays包含用于操作數組的各種方法(例如排序和搜索)

        • 如果指定的數組引用為null,則此類中的方法都拋出NullPointerException ,除非另有說明

        一、常用方法

        1.1 toString

        返回指定數組內容的字符串形式

        舉例

           int[] a1 = {1,2,3,4,5};
               System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]

        源碼

        	public static String toString(int[] a) {
                if (a == null)
                    return "null";
                int iMax = a.length - 1;
                if (iMax == -1)
                    return "[]";
                StringBuilder b = new StringBuilder();
                b.append('[');
                for (int i = 0; ; i++) {
                    b.append(a[i]);
                    if (i == iMax)
                        return b.append(']').toString();
                    b.append(", ");
                }
            }

        其它

        Modifier and TypeFieldDescription
        static StringdeepToString(Object[] a)返回指定數組的“深層內容”的字符串表示形式

        1.2 Sort

        排序(默認升序)

        1.2.1 sort(T[] a, int fromIndex, int toIndex)

        指定區間進行排序

        舉例

           int[] a1 = {9,1,3,7,2,5};
               System.out.println(Arrays.toString(a1));//[9, 1, 3, 7, 2, 5]
               Arrays.sort(a1,0,3);//[0,3),對9,1,3進行排序
               System.out.println(Arrays.toString(a1));//[0[1, 3, 9, 7, 2, 5]

        源碼

        public static void sort(int[] a, int fromIndex, int toIndex) {
                rangeCheck(a.length, fromIndex, toIndex);
                DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
            }
        1.2.2 Sort(T[] a)

        對整個數組進行排序

        舉例

           int[] a1 = {0,7,8,2,4,1};
               System.out.println(Arrays.toString(a1));//[0, 7, 8, 2, 4, 1]
               Arrays.sort(a1);
               System.out.println(Arrays.toString(a1));//[0, 1, 2, 4, 7, 8]

        源碼

        public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
            }
        1.2.3 其它
        Modifier and TypeFieldDescription
        static voidsort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。
        static voidsort(T[] a, Comparator<? super T> c)根據指定比較器引發的順序對指定的對象數組進行排序。






        static voidparallelSort(T[] a)將指定的數組按升序排序。
        static voidparallelSort(T[] a, int fromIndex, int toIndex)將指定的數組范圍按數字升序排序。
        static <T extends Comparable<? super T>>voidparallelSort(T[] a)根據元素的natural ordering對指定的對象數組按升序排序。
        static <T extends Comparable<? super T>>voidparallelSort(T[] a, int fromIndex, int toIndex)根據元素的natural ordering ,將指定對象數組的指定范圍按升序排序。
        static voidparallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。
        static voidparallelSort(T[] a, Comparator<? super T> cmp)根據指定比較器引發的順序對指定的對象數組進行排序。

        1.3 copyOf

        復制(常用于數組擴容)

        舉例

           int[] a = {1,2,3};
               System.out.println(a.length);//output:3
               a = Arrays.copyOf(a,15);
               System.out.println(a.length);//output:15

        源碼

          public static int[] copyOf(int[] original, int newLength) {
                int[] copy = new int[newLength];
                System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
                return copy;
            }

        其它

        Modifier and TypeFieldDescription
        static T[]copyOf(T[] original, int newLength)使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度
        static <T,U>T[]copyOf(U[] original, int newLength, 類<? extends T[]> newType)使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度

        1.4 mismatch

        舉例

           int[] a1 = {0,1,2,3,4,5};
               int[] a2 = {0,1,2,3,4,5};//與a1相同
               int[] a3 = {0,1,2,3,0,5};//從索引4開始與a1不同
               System.out.println(Arrays.mismatch(a1,a2));//output:-1
               System.out.println(Arrays.mismatch(a1,a3));//output:4

        源碼

         public static int mismatch(int[] a, int[] b) {
                int length = Math.min(a.length, b.length); // Check null array refs
                if (a == b)
                    return -1;
                int i = ArraysSupport.mismatch(a, b, length);
                return (i < 0 && a.length != b.length) ? length : i;
            }

        其它

        Modifier and TypeFieldDescription
        static intmismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)查找并返回指定范圍內兩個 Object數組之間第一個不匹配的相對索引,否則如果未找到不匹配則返回-1。
        static intmismatch(T[] a, T[] b, Comparator<? super T> cmp)查找并返回兩個 Object數組之間第一個不匹配的索引,否則如果未找到不匹配則返回-1。

        1.5 binarySearch

        二分查找,搜索,返回下標

        1.5.1 binarySearch(T[] a, int fromIndex, int toIndex, T key)

        限定了搜索的范圍[fromIndex, toIndex)

        舉例

          int[] a = {1,2,3,4,5};
               int x1 = Arrays.binarySearch(a,2,3,4);//在a數組下標[2,3)中查找值為4的下標
               System.out.println(x1);//output:<0的隨機數

        源碼

        	public static int binarySearch(int[] a, int fromIndex, int toIndex,int key) {
                rangeCheck(a.length, fromIndex, toIndex);
                return binarySearch0(a, fromIndex, toIndex, key);
            }
            private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
                int low = fromIndex;
                int high = toIndex - 1;
                while (low <= high) {
                    int mid = (low + high) >>> 1;
                    int midVal = a[mid];
                    if (midVal < key)
                        low = mid + 1;
                    else if (midVal > key)
                        high = mid - 1;
                    else
                        return mid; // key found
                }
                return -(low + 1);  // key not found.
            }
        1.5.2 binarySearch(T[] a, T key)

        與上述相同,只是沒有限定范圍,fromIndex=0, toIndex=length

        舉例

           int[] a = {1,2,3,4,5};
               int x1 = Arrays.binarySearch(a,3);//在a數組中查找值為3的下標
               int x2 = Arrays.binarySearch(a,-6);//在a數組中查找值為6的下標
               System.out.println(x1);//output:2
               System.out.println(x2);//output:<0的隨機數

        源碼

        public static int binarySearch(int[] a, int key) {
                return binarySearch0(a, 0, a.length, key);
            }
        	private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
                int low = fromIndex;
                int high = toIndex - 1;
                while (low <= high) {
                    int mid = (low + high) >>> 1;
                    int midVal = a[mid];
                    if (midVal < key)
                        low = mid + 1;
                    else if (midVal > key)
                        high = mid - 1;
                    else
                        return mid; // key found
                }
                return -(low + 1);  // key not found.
            }
        1.5.3 其它
        Modifier and TypeFieldDescription
        static intbinarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)使用二進制搜索算法搜索指定對象的指定數組范圍
        static intbinarySearch(T[] a, T key, Comparator<? super T> c)使用二進制搜索算法在指定的數組中搜索指定的對象

        1.6 equals

        1.6.1 equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)

        如果兩個指定數組在指定范圍內相等 ,則返回true

        舉例

           int[] a1 = {1,2,3,4,5};
               int[] a2 = {1,2,0,0,4,5};
               System.out.println(Arrays.equals(a1,0,2,a2,0,2));//true
               System.out.println(Arrays.equals(a1,3,5,a2,4,6));//true

        源碼

        public static boolean equals(int[] a, int aFromIndex, int aToIndex,int[] b, int bFromIndex, int bToIndex) {
                rangeCheck(a.length, aFromIndex, aToIndex);
                rangeCheck(b.length, bFromIndex, bToIndex);
                int aLength = aToIndex - aFromIndex;
                int bLength = bToIndex - bFromIndex;
                if (aLength != bLength)
                    return false;
                return ArraysSupport.mismatch(a, aFromIndex, b, bFromIndex,aLength) < 0;
            }
        1.6.2 equals(T[] a, T[] a2)

        如果兩個指定數組相等,則返回 true

        舉例

           int[] a1 = {1,2,3,4,5};
               int[] a2 = {1,2,3,4,5};
               int[] a3 = {1,2,0,4,5};
               System.out.println(Arrays.equals(a1,a2));//true
               System.out.println(Arrays.equals(a1,a3));//false

        源碼

         public static boolean equals(int[] a, int[] a2) {
                if (a==a2)
                    return true;
                if (a==null || a2==null)
                    return false;
                int length = a.length;
                if (a2.length != length)
                    return false;
                return ArraysSupport.mismatch(a, a2, length) < 0;
            }
        1.6.3 其它
        Modifier and TypeFieldDescription
        static booleandeepEquals(Object[] a1, Object[] a2)如果兩個指定的數組彼此 深度相等 ,則返回 true
        static booleanequals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)如果在指定范圍內指定的兩個Object數組彼此 相等 ,則返回true
        static booleanequals(T[] a, T[] a2, Comparator<? super T> cmp)如果兩個指定的Objects數組彼此 相等 ,則返回 true

        1.7 fills

        1.7.1 fill(T[] a, int fromIndex, int toIndex, T val)

        將指定的T值分配給指定的T類型數組的指定范圍的每個元素

        舉例

           int[] a1 = new int[10];
               Arrays.fill(a1,1,4,8);
               char[] a2 = new char[10];
               Arrays.fill(a2,0,3,'s');
               System.out.println(Arrays.toString(a1));//[0, 8, 8, 8, 0, 0, 0, 0, 0, 0]
               System.out.println(Arrays.toString(a2));//[s, s, s,  ,  ,  ,  ,  ,  ,  ]

        源碼

        public static void fill(char[] a, int fromIndex, int toIndex, char val) {
                rangeCheck(a.length, fromIndex, toIndex);
                for (int i = fromIndex; i < toIndex; i++)
                    a[i] = val;
            }
        1.7.2 fill(T[] a, T val)

        將指定的T值分配給指定的T類型數組的每個元素

        舉例

           int[] a1 = new int[10];
               Arrays.fill(a1,8);
               char[] a2 = new char[10];
               Arrays.fill(a2,'s');
               System.out.println(Arrays.toString(a1));//[8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
               System.out.println(Arrays.toString(a2));//[s, s, s, s, s, s, s, s, s, s]

        源碼

        	public static void fill(int[] a, int val) {
                for (int i = 0, len = a.length; i < len; i++)
                    a[i] = val;
            }

        二、其他方法

        Modifier and TypeFieldDescription
        static ListasList(T… a)返回由指定數組支持的固定大小的列表。






        static intcompare(T[] a, T[] b)字典順序比較兩個T陣列
        static intcompare(T[] a, int aFromIndex, int aToIndex,T[] b, int bFromIndex, int bToIndex)在指定范圍內按字典順序比較兩個T陣列
        static <T extends Comparable<? super T>>intcompare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)在指定范圍內按字典順序比較兩個 Object陣列。
        static intcompare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)在指定范圍內按字典順序比較兩個 Object陣列。
        static <T extends Comparable<? super T>>intcompare(T[] a, T[] b)按 Object順序比較兩個 Object陣列,在可比元素中。
        static intcompare(T[] a, T[] b, Comparator<? super T> cmp)使用指定的比較器按字典順序比較兩個 Object陣列






        static intcompareUnsigned(T[] a, T[] b)byte字典順序比較兩個T陣列,數字處理元素為無符號
        static intcompareUnsigned(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)在指定范圍內按字典順序比較兩個 T陣列,將元素數字處理為無符號






        static T[]copyOfRange(T[] original, int from, int to)將指定數組的指定范圍復制到新數組中
        static T[]copyOfRange(T[] original, int from, int to)將指定數組的指定范圍復制到新數組中
        static <T,U>T[]copyOfRange(U[] original, int from, int to, 類<? extends T[]> newType)將指定數組的指定范圍復制到新數組中






        static inthashCode(T[] a)根據指定數組的內容返回哈希碼
        static intdeepHashCode(Object[] a)返回基于指定數組的“深層內容”的哈希碼






        static voidparallelPrefix(T[] array, int fromIndex, int toIndex,TBinaryOperator op)對于給定的數組子范圍執行parallelPrefix(T[],TBinaryOperator)
        static voidparallelPrefix(dT[] array,TBinaryOperator op)使用提供的函數并行地累積給定數組的每個元素
        static voidparallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator op)對于給定的數組子范圍執行 parallelPrefix(Object[], BinaryOperator)
        static voidparallelPrefix(T[] array, BinaryOperator op)使用提供的函數并行地累積給定數組的每個元素






        static voidparallelSetAll(double[] array, IntToDoubleFunction generator)使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素
        static voidparallelSetAll(int[] array, IntUnaryOperator generator)使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素
        static voidparallelSetAll(long[] array, IntToLongFunction generator)使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素
        static voidparallelSetAll(T[] array, IntFunction<? extends T> generator)使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素






        static voidsetAll(double[] array, IntToDoubleFunction generator)使用提供的生成器函數設置指定數組的所有元素以計算每個元素
        static voidsetAll(int[] array, IntUnaryOperator generator)使用提供的生成器函數設置指定數組的所有元素以計算每個元素
        static voidsetAll(long[] array, IntToLongFunction generator)使用提供的生成器函數設置指定數組的所有元素以計算每個元素
        static voidsetAll(T[] array, IntFunction<? extends T> generator)使用提供的生成器函數設置指定數組的所有元素以計算每個元素






        staticSpliterator.OfDouble spliterator(double[] array)返回覆蓋所有指定數組的Spliterator.OfDouble
        staticSpliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive)返回覆蓋指定數組的指定范圍的Spliterator.OfDouble
        staticSpliterator.OfInt spliterator(int[] array)返回覆蓋所有指定數組的Spliterator.OfInt
        staticSpliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive)返回覆蓋指定數組的指定范圍的Spliterator.OfInt
        staticSpliterator.OfLong spliterator(long[] array)返回覆蓋所有指定數組的Spliterator.OfLong
        staticSpliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive)返回覆蓋指定數組的指定范圍的Spliterator.OfLong
        static Spliteratorspliterator(T[] array)返回覆蓋所有指定數組的Spliterator
        static Spliteratorspliterator(T[] array, int startInclusive, int endExclusive)返回覆蓋指定數組的指定范圍的Spliterator
        static DoubleStreamstream(double[] array)返回以指定數組作為源的順序DoubleStream
        static DoubleStreamstream(double[] array, int startInclusive, int endExclusive)返回指定數組的指定范圍作為其源的順序DoubleStream
        static IntStreamstream(int[] array)返回以指定數組作為源的順序IntStream
        static IntStreamstream(int[] array, int startInclusive, int endExclusive)返回指定數組的指定范圍作為其源的順序IntStream
        static LongStreamstream(long[] array)返回以指定數組作為源的順序LongStream
        static LongStreamstream(long[] array, int startInclusive, int endExclusive)返回指定數組的指定范圍作為其源的順序LongStream
        static Streamstream(T[] array)返回以指定數組作為源的順序Stream
        static Streamstream(T[] array, int startInclusive, int endExclusive)返回指定數組的指定范圍作為其源的順序Stream

        到此,相信大家對“Java核心類庫Arrays的常用方法介紹”有了更深的了解,不妨來實際操作一番吧!這里是億速云網站,更多相關內容可以進入相關頻道進行查詢,關注我們,繼續學習!

        向AI問一下細節

        免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

        AI

        宁夏| 乐平市| 渑池县| 琼海市| 修水县| 安新县| 志丹县| 光山县| 武威市| 永春县| 正安县| 侯马市| 阳信县| 思茅市| 青龙| 昔阳县| 桂阳县| 波密县| 大冶市| 保山市| 玉田县| 巴林左旗| 伊春市| 都昌县| 苏尼特右旗| 南开区| 兰坪| 子洲县| 东安县| 葫芦岛市| 仙居县| 永年县| 大埔县| 古交市| 忻城县| 洪洞县| 沁阳市| 伊通| 高安市| 梁河县| 东港市|