深入学习java源码之Arrays.binarySearch()与Arrays.copyOf()

最新推荐文章于 2024-08-11 19:50:52 发布
最新推荐文章于 2024-08-11 19:50:52 发布
阅读量465 收藏 1
点赞数
分类专栏： Java源码 文章标签： 深入学习java源码之Arrays.binarySearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35029061/article/details/85956518
版权

深入学习java源码之Arrays.binarySearch()与Arrays.copyOf()

java中有三种移位运算符

<<      :     左移运算符，num << 1,相当于num乘以2

>>      :     右移运算符，num >> 1,相当于num除以2

>>>    :     无符号右移，忽略符号位，空位都以0补齐

算术左移和算术右移主要用来进行有符号数的倍增、减半 
逻辑左移和逻辑右移主要用来进行无符号数的倍增、减半 

比如一个有符号位的8位二进制数10101010，[]是添加的数字

逻辑左移一位：0101010[0] 
逻辑左移两位：101010[00]

算术左移一位：0101010[0] 
算术左移两位：101010[00]

逻辑右移一位：[0]1010101 
逻辑右移两位：[00]101010

算术右移一位：[1]1010101 
算术右移两位：[11]101010
 

    // 20
    System.out.println(10 << 1);
    // -20
    System.out.println(-10 << 1);
    // 5
    System.out.println(10 >> 1);
    // -5
    System.out.println(-10 >> 1);
    // 5
    System.out.println(10 >>> 1);
    // 2147483643
    System.out.println(-10 >>> 1);

论java中System.arrayCopy()与Arrays.copyOf()的区别

如果我们想拷贝一个数组，我们可能会使用System.arraycopy()或者Arrays.copyof()两种方式。

System.arraycopy()

int[] arr = {1,2,3,4,5};  
int[] copied=new int[10];
System.arraycopy(arr,0,copied,1,5);//这里的arr是原数组，0是原数组拷贝的其实地址。而copied是目标数组，1是目标数组开始存放的位置，5则是数组存放的长度。

System.out.println(Array.toString(copied));
运行结果如下:
[0,1,2,3,4,5,0,0,0,0];

arrays.copyof()

int[] arr = {1,2,3,4,5};  
int copied=arrays.copyof(arr,10);
System.out.println(Arrays.toString(copied));
copied=arrays.copyof(arr,3);
System.out.println(Arrays.toString(copied));

运行结果如下:
[1,2,3,4,5,0,0,0,0,0]
[1,2,3]

这里我们来谈谈他们的区别，这也是之前我一直没弄懂的地方:

两者的区别在于，Arrays.copyOf()不仅仅只是拷贝数组中的元素，在拷贝元素时，会创建一个新的数组对象。而System.arrayCopy只拷贝已经存在数组元素。

如果我们看过Arrays.copyOf()的源码就会知道，该方法的底层还是调用了System.arrayCopyOf()方法。

而且System.arrayCopy如果改变目标数组的值原数组的值也会随之改变。

 

Modifier and TypeMethod and Description
static intbinarySearch(byte[] a, byte key)

使用二进制搜索算法搜索指定值的指定字节数组。

static intbinarySearch(byte[] a, int fromIndex, int toIndex, byte key)

使用二进制搜索算法搜索指定值的指定字节数组的范围。

static intbinarySearch(char[] a, char key)

使用二进制搜索算法搜索指定数组的指定值。

static intbinarySearch(char[] a, int fromIndex, int toIndex, char key)

使用二分搜索算法搜索指定值的指定数组的范围。

static intbinarySearch(double[] a, double key)

使用二进制搜索算法搜索指定值的指定数组的双精度值。

static intbinarySearch(double[] a, int fromIndex, int toIndex, double key)

使用二分搜索算法搜索指定值的指定数组的双精度范围。

static intbinarySearch(float[] a, float key)

使用二叉搜索算法搜索指定数组的浮点数。

static intbinarySearch(float[] a, int fromIndex, int toIndex, float key)

使用二分搜索算法搜索指定数组的浮点数范围。

static intbinarySearch(int[] a, int key)

使用二叉搜索算法搜索指定的int数组的指定值。

static intbinarySearch(int[] a, int fromIndex, int toIndex, int key)

使用二叉搜索算法搜索指定值的指定数组的范围。

static intbinarySearch(long[] a, int fromIndex, int toIndex, long key)

使用二分搜索算法搜索指定值的指定数组的范围。

static intbinarySearch(long[] a, long key)

使用二进制搜索算法搜索指定数组的指定数组。

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)

使用二进制搜索算法搜索指定值的指定数组的短整型范围。

static intbinarySearch(short[] a, short key)

使用二进制搜索算法搜索指定值的指定数组的指定值。

static <T> intbinarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)

使用二进制搜索算法搜索指定对象的指定数组的范围。

static <T> intbinarySearch(T[] a, T key, Comparator<? super T> c)

使用二叉搜索算法搜索指定对象的指定数组。

static boolean[]copyOf(boolean[] original, int newLength)

使用 false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。

static byte[]copyOf(byte[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static char[]copyOf(char[] original, int newLength)

复制指定的数组，截断或填充空字符（如有必要），以便复制具有指定的长度。

static double[]copyOf(double[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static float[]copyOf(float[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static int[]copyOf(int[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static long[]copyOf(long[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static short[]copyOf(short[] original, int newLength)

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

static <T> T[]copyOf(T[] original, int newLength)

复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。

static <T,U> T[]copyOf(U[] original, int newLength, 类<? extends T[]> newType)

复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。

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, 类<? extends T[]> newType)

将指定数组的指定范围复制到新数组中。

static booleandeepEquals(Object[] a1, Object[] a2)

如果两个指定的数组彼此 深度相等 ，则返回 true 。

static intdeepHashCode(Object[] a)

根据指定数组的“深度内容”返回哈希码。

static StringdeepToString(Object[] a)

返回指定数组的“深度内容”的字符串表示形式。

static booleanequals(boolean[] a, boolean[] a2)

如果两个指定的布尔数组彼此 相等 ，则返回 true 。

static booleanequals(byte[] a, byte[] a2)

如果两个指定的字节数组彼此 相等 ，则返回 true 。

static booleanequals(char[] a, char[] a2)

如果两个指定的字符数组彼此 相等 ，则返回 true 。

static booleanequals(double[] a, double[] a2)

如果两个指定的双精度数组彼此 相等 ，则返回 true 。

static booleanequals(float[] a, float[] a2)

如果两个指定的浮动数组彼此 相等 ，则返回 true 。

static booleanequals(int[] a, int[] a2)

如果两个指定的int数组彼此 相等 ，则返回 true 。

static booleanequals(long[] a, long[] a2)

如果两个指定的longs数组彼此 相等 ，则返回 true 。

static booleanequals(Object[] a, Object[] a2)

如果两个指定的对象数组彼此 相等 ，则返回 true 。

static booleanequals(short[] a, short[] a2)

如果两个指定的短裤阵列彼此 相等 ，则返回 true 。

static voidfill(boolean[] a, boolean val)

将指定的布尔值分配给指定的布尔数组的每个元素。

static voidfill(boolean[] a, int fromIndex, int toIndex, boolean val)

将指定的布尔值分配给指定数组布尔值的指定范围的每个元素。

static voidfill(byte[] a, byte val)

将指定的字节值分配给指定字节数组的每个元素。

static voidfill(byte[] a, int fromIndex, int toIndex, byte val)

将指定的字节值分配给指定字节数组的指定范围的每个元素。

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值分配给指定的双精度数组的每个元素。

static voidfill(double[] a, int fromIndex, int toIndex, double val)

将指定的double值分配给指定的双精度数组范围的每个元素。

static voidfill(float[] a, float val)

将指定的float值分配给指定的浮点数组的每个元素。

static voidfill(float[] a, int fromIndex, int toIndex, float val)

将指定的浮点值分配给指定的浮点数组的指定范围的每个元素。

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值分配给指定的longs数组的指定范围的每个元素。

static voidfill(long[] a, long val)

将指定的long值分配给指定的longs数组的每个元素。

static voidfill(Object[] a, int fromIndex, int toIndex, Object val)

将指定的对象引用分配给指定的对象数组的指定范围的每个元素。

static voidfill(Object[] a, Object val)

将指定的对象引用分配给指定的对象数组的每个元素。

static voidfill(short[] a, int fromIndex, int toIndex, short val)

将指定的短值分配给指定的短裤数组的指定范围的每个元素。

static voidfill(short[] a, short val)

将指定的短值分配给指定的短裤数组的每个元素。

java源码

package java.util;

import java.lang.reflect.Array;
import java.util.concurrent.ForkJoinPool;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntFunction;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.UnaryOperator;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class Arrays {

    private static final int MIN_ARRAY_SORT_GRAN = 1 << 13;

    // Suppresses default constructor, ensuring non-instantiability.
    private Arrays() {}

    static final class NaturalOrder implements Comparator<Object> {
        @SuppressWarnings("unchecked")
        public int compare(Object first, Object second) {
            return ((Comparable<Object>)first).compareTo(second);
        }
        static final NaturalOrder INSTANCE = new NaturalOrder();
    }

    private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
        }
        if (fromIndex < 0) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }
    }

    public static int binarySearch(long[] a, long key) {
        return binarySearch0(a, 0, a.length, key);
    }
	
    public static int binarySearch(long[] a, int fromIndex, int toIndex,
                                   long key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }	

    // Like public version, but without range checks.
    private static int binarySearch0(long[] a, int fromIndex, int toIndex,
                                     long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long 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.
    }	
	
    public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }

    public static int binarySearch(int[] a, int fromIndex, int toIndex,
                                   int key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    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.
    }

    public static int binarySearch(short[] a, short key) {
        return binarySearch0(a, 0, a.length, key);
    }

    public static int binarySearch(short[] a, int fromIndex, int toIndex,
                                   short key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(short[] a, int fromIndex, int toIndex,
                                     short key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            short 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.
    }

    public static int binarySearch(char[] a, char key) {
        return binarySearch0(a, 0, a.length, key);
    }

    public static int binarySearch(char[] a, int fromIndex, int toIndex,
                                   char key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(char[] a, int fromIndex, int toIndex,
                                     char key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            char 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.
    }

    public static int binarySearch(byte[] a, byte key) {
        return binarySearch0(a, 0, a.length, key);
    }

    public static int binarySearch(byte[] a, int fromIndex, int toIndex,
                                   byte key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(byte[] a, int fromIndex, int toIndex,
                                     byte key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            byte 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.
    }

    public static int binarySearch(double[] a, double key) {
        return binarySearch0(a, 0, a.length, key);
    }
	
    public static int binarySearch(double[] a, int fromIndex, int toIndex,
                                   double key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(double[] a, int fromIndex, int toIndex,
                                     double key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            double midVal = a[mid];

            if (midVal < key)
                low = mid + 1;  // Neither val is NaN, thisVal is smaller
            else if (midVal > key)
                high = mid - 1; // Neither val is NaN, thisVal is larger
            else {
                long midBits = Double.doubleToLongBits(midVal);
                long keyBits = Double.doubleToLongBits(key);
                if (midBits == keyBits)     // Values are equal
                    return mid;             // Key found
                else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
                    low = mid + 1;
                else                        // (0.0, -0.0) or (NaN, !NaN)
                    high = mid - 1;
            }
        }
        return -(low + 1);  // key not found.
    }
	
    public static int binarySearch(float[] a, float key) {
        return binarySearch0(a, 0, a.length, key);
    }
	
    public static int binarySearch(float[] a, int fromIndex, int toIndex,
                                   float key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(float[] a, int fromIndex, int toIndex,
                                     float key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            float midVal = a[mid];

            if (midVal < key)
                low = mid + 1;  // Neither val is NaN, thisVal is smaller
            else if (midVal > key)
                high = mid - 1; // Neither val is NaN, thisVal is larger
            else {
                int midBits = Float.floatToIntBits(midVal);
                int keyBits = Float.floatToIntBits(key);
                if (midBits == keyBits)     // Values are equal
                    return mid;             // Key found
                else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
                    low = mid + 1;
                else                        // (0.0, -0.0) or (NaN, !NaN)
                    high = mid - 1;
            }
        }
        return -(low + 1);  // key not found.
    }

    public static int binarySearch(Object[] a, Object key) {
        return binarySearch0(a, 0, a.length, key);
    }

    public static int binarySearch(Object[] a, int fromIndex, int toIndex,
                                   Object key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
                                     Object key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            @SuppressWarnings("rawtypes")
            Comparable midVal = (Comparable)a[mid];
            @SuppressWarnings("unchecked")
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

    public static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) {
        return binarySearch0(a, 0, a.length, key, c);
    }

    public static <T> int binarySearch(T[] a, int fromIndex, int toIndex,
                                       T key, Comparator<? super T> c) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key, c);
    }

    // Like public version, but without range checks.
    private static <T> int binarySearch0(T[] a, int fromIndex, int toIndex,
                                         T key, Comparator<? super T> c) {
        if (c == null) {
            return binarySearch0(a, fromIndex, toIndex, key);
        }
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            T midVal = a[mid];
            int cmp = c.compare(midVal, key);
            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

    public static boolean equals(long[] a, long[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    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;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    public static boolean equals(short[] a, short a2[]) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    public static boolean equals(char[] a, char[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    public static boolean equals(byte[] a, byte[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }
    public static boolean equals(boolean[] a, boolean[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

    public static boolean equals(double[] a, double[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
                return false;

        return true;
    }

    public static boolean equals(float[] a, float[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++)
            if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
                return false;

        return true;
    }

    public static boolean equals(Object[] a, Object[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++) {
            Object o1 = a[i];
            Object o2 = a2[i];
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }

        return true;
    }

    
    public static void fill(long[] a, long val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }	
	
    public static void fill(long[] a, int fromIndex, int toIndex, long val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }
	
    public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }
	
    public static void fill(int[] a, int fromIndex, int toIndex, int val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }	
	
    public static void fill(short[] a, short val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }	
	
    public static void fill(short[] a, int fromIndex, int toIndex, short val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }
    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;
    }

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

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

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

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

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

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

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

    @SuppressWarnings("unchecked")
    public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

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

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

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

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

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

    public static float[] copyOf(float[] original, int newLength) {
        float[] copy = new float[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	
    public static double[] copyOf(double[] original, int newLength) {
        double[] copy = new double[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	
    public static boolean[] copyOf(boolean[] original, int newLength) {
        boolean[] copy = new boolean[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
	
    @SuppressWarnings("unchecked")
    public static <T> T[] copyOfRange(T[] original, int from, int to) {
        return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
    }	
	
    public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static byte[] copyOfRange(byte[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        byte[] copy = new byte[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static short[] copyOfRange(short[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        short[] copy = new short[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static int[] copyOfRange(int[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        int[] copy = new int[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static long[] copyOfRange(long[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        long[] copy = new long[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static char[] copyOfRange(char[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        char[] copy = new char[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static float[] copyOfRange(float[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        float[] copy = new float[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

    public static double[] copyOfRange(double[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        double[] copy = new double[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }
	
    public static boolean[] copyOfRange(boolean[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        boolean[] copy = new boolean[newLength];
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }
	
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

wespten
关注
专栏目录
java arrays.setall_Java程序员的日常—— Arrays工具类的使用
weixin_36230515的博客
02-28 1518
这个类在日常的开发中，还是非常常用的。今天就总结一下Arrays工具类的常用方法。最常用的就是asList,sort,toStream,equals,copyOf了。另外可以深入学习下Arrays的排序算法，这个还是非常有用的。所有的方法都是在下面的类中进行测试的:public class ArraysTest {String[] array = new String[]{"a","c","2",...
Java第04章-二维数组及Arrays类
luckyboy!的博客
09-08 475
标识符(数组名) = new 数据类型[长度][长度];或 标识符(数组名) = new 数据类型[长度][];数据类型 [ ][ ] 标识符(数组名)；或者 数据类型 标识符(数组名)[ ][ ]；分配内存空间是第一个[ ]里的长度必须要写，第二个[ ]里的长度可以省略不写。二位数组可以看成是以为一维数组，二位数组里的数据元素是一维数组。语法： 标识符(数组名) 下标][下标] = 数据;标识符(数组名)[下标][下标]
BinarySearch.java
06-04
实现折半查找的程序 希望大家功能学习，共同进步
Arrays.copyOf()与System.arraycopy()的源码分析
ChineseThink的专栏
06-26 736
首先观察先System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)的实现方式： [code="java"] public static native void arraycopy(Object src, int srcPos, ...
Java利用binarySearch实现lower_bound与upper_bound以及partition_point
最新发布
m0_51336955的博客
08-11 295
Java仿照Rust的partition_point()函数思路，利用binarySearch()实现lower_bound()与upper_bound()。
Java之数组查询Arrays类的binarySearch()方法详解
热门推荐
CXHPLY的专栏
10-26 5万+
Arrays类的binarySearch()方法，可以使用二分搜索法来搜索指定的数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供多种重载形式，用于满足各种类型数组的查找需要。 1）  binarySearch(Object[], Object key) a: 要搜索的数组 key：要搜索的值 如果key在数组中，则返回搜索值的索引；否则返
Arrays.binarySearch()方法
小科比的博客
01-28 1万+
通过二分法在已经排好序的数组中查找指定的元素，并返回该元素的下标 1.如果数组中存在该元素，则会返回该元素在数组中的下标 import java.util.Arrays; public class binarySearch { public static void main(String[] args) { int[] scores = {1, 20, 30, 40, 50}; //在数组scores中查找元素20 int res = Arrays.b
Arrays.binarySearch
wjxbj的博客
09-01 471
        今天在开发时，要判断一个逗号分隔的字符串中是否包含指定的字符串，考虑到aaa,aaa10,aaa11这种字符串无法正确判断aaa是否存在。因此先将调String的split方法将其转换成字符串数组。然后再用for循环或ArrayUtils.contains判断即可，后来在使用时发现Array.binarySearch(arr,obj)方法，虽然二分法查找需要被查找的数组已经...
java arrays类.docx
09-27
在深入讲解Arrays类的方法之前，我们先理解一下Java数组的基本概念。数组是一种数据结构，它可以存储固定数量的相同类型的数据。 1. **数组的输出**： - `toString()` 方法：将数组转换为字符串形式，以逗号分隔...
Java中Arrays类详解.docx
01-29
- `binarySearch()`：在排序的数组中查找特定元素的索引，如果找不到则返回负值。 - `asList()`：将数组转换为`ArrayList`，这样就可以使用集合框架的方法。 总的来说，`Arrays`类极大地简化了对数组的操作，提供...
Java中Arrays类中的数组操作方法详解
jcc4261的博客
10-26 1165
🏵在前面我们讲到了一维数组和二维数组以及开发工具eclipse的配置java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：替换元素以及填充元素：通过 fill 方法。对数组排序：通过 sort 方法,按升序。比较数组：通过 equals 方法比较数组中元素值是否相等。查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
Arrays.binarySearch()
yaoguicheng的专栏
01-30 6937
今天学的头疼，有些地方还是要自己深入的琢磨琢磨。虽然java是面向对象的，过程也是要稍微掌握点的。  在使用这个方法的时候，譬如：static intbinarySearch(int[] a, int key)           Searches the specified array of ints for the specified value using the
Arrays中binarySearch
qq_34579060的博客
01-19 226
public class Arrays { /** * 使用二分查找，搜索特定的数组，给定的值 * @param a 数组 * @param key 给定的值 * @return 位置 */ public static int binarySearch(int[] a, int key) { return binarySearch(a,0,a.l
Arrays.binarySearch();
Caster_Saber的专栏
07-16 1219
Arrays.binarySearch();的用法。public static int binarySearch(Object[] a,Object key) 使用二分搜索法来搜索指定数组，以获得指定对象。在进行此调用之前， 必须根据元素的自然顺序对数组进行升序排序（通过 sort(Object[]) 方 法 ）。如果没有对数组进行排序，则结果是不确定的。（如果数
JAVA Arrays.binarySearch
somebodydie的专栏
11-27 1万+
package com.jaky; import java.util.*; public class Quest { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String[] colors = {"blue","red","
Arrays.binarySearch(二分法检索）
hello，Kingshan
09-02 1261
Arrays.binarySearch用法小析二分法检索（binary search）又称折半检索，二分法检索的基本思想是设字典中的元素从小到大有序地存放在数组（array）中binarySearchs方法的声明如下所示 public static int binarySerach(Xxx a[],Xxx key)java.util.Arrays.binarySearch(int[], int, i
【Java+LeetCode训练】binarySearch源码解析
qq_63691275的博客
11-29 422
序：使用Arrays工具类中的binarySearch方法进行二分搜索时，我们知道搜索成功会返回其下标，那么搜索失败它会返回什么呢？分析分析源码。
Arrays.binarySearch详解
Unknownfuture的博客
02-26 1519
Arrays.binarySearch是系统库提供的二分查找api。 先看看源代码中的注释 /** * Searches the specified array of ints for the specified value using the * binary search algorithm. The array must be sorted (as * by...
Java中数组Arrays.binarySearch，快速查找数组内元素位置
hailushijie的专栏
06-28 1万+
在数组中查找一个元素，Arrays提供了一个方便查询的方法。Arrays.binarySearch（）； 测试列子： public class MainTestArray { public static void main(String args[]){ String[] intArray = new String[]{"a","b","c","d","e","f","g","h",
java Arrays. 常用函数
12-28
int index = Arrays.binarySearch(arr, 3); System.out.println(index); // 输出：2 ``` 4. `copyOf()`：复制数组的一部分或整个数组，并返回一个新的数组。可以指定要复制的长度，如果超过原始数组的长度，则用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wespten

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值