【Java】案例：声明一个数组工具类MyArrays，包含如下方法：_int binarysearch(int[] arr, int value):使用二分查找法在arr-优快云博客

本文介绍了一个实用的数组工具类MyArrays，该类提供了多种数组操作方法，包括二分查找、数组复制及排序等功能，并通过示例展示了其具体应用。

声明一个数组工具类MyArrays，包含如下方法：

int binarySearch(int[] arr, int
value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
int binarySearch(char[] arr, char
value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
int binarySearch(double[] arr, double
value)：使用二分查找法在arr数组中查找value的下标，如果value不存在，就返回-1，如果数组arr不是有序的，结果将不一定正确
int[] copy(int[] arr , int
length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
double[] copy(double[] arr , int
length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
char[] copy(char[] arr , int
length)：从指定的arr数组的arr[0]开始复制得到一个新数组，新数组的长度为length。
void sort(int[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
void sort(char[] arr)：可以给arr数组从小到大排序，用冒泡排序实现
void sort(double[] arr)：可以给arr数组从小到大排序，用冒泡排序实现

工具类MyArrays

import java.math.BigDecimal;
import java.util.Arrays;
public class MyArrays {
    public static int binarySearch(int[] arr, int value) {
        if (arr != null) {
            int left = 0;
            int right = arr.length - 1;
            int mid = (left + right) / 2;
            while (left < right) {
                if (arr[mid] == value) {
                    return mid;
                } else if (value > arr[mid]) {
                    left = mid + 1;
                } else if (value < arr[mid]) {
                    right = mid - 1;
                }
                mid = (left + right) / 2;
            }
        }

        return -1;
    }

    public static int binarySearch(char[] arr, char value) {
        if (arr != null) {
            int left = 0;
            int right = arr.length - 1;
            int mid = (left + right) / 2;
            while (left < right) {
                if (Integer.valueOf(arr[mid]) == value) {
                    return mid;
                } else if (value > Integer.valueOf(arr[mid])) {
                    left = mid + 1;
                } else if (value < Integer.valueOf(arr[mid])) {
                    right = mid - 1;
                }
                mid = (left + right) / 2;
            }
        }
        return -1;
    }

    public static int binarySearch(double[] arr, double value) {
        if (arr != null) {
            int left = 0;
            int right = arr.length - 1;
            int mid = (left + right) / 2;
            while (left < right) {
                if (BigDecimal.valueOf(arr[mid]).doubleValue() == value) {
                    return mid;
                } else if (value > BigDecimal.valueOf(arr[mid]).doubleValue()) {
                    left = mid + 1;
                } else if (value < BigDecimal.valueOf(arr[mid]).doubleValue()) {
                    right = mid - 1;
                }
                mid = (left + right) / 2;
            }
        }
        return -1;
    }

    public static int[] copy(int[] arr, int length) {
        int[] nand = new int[length];
        if (arr != null & length < arr.length) {
            for (int i = 0; i < length; i++) {
                nand[i] = arr[i];
            }
        }
        return nand;
    }

    public static double[] copy(double[] arr, int length) {
        double[] nand = new double[length];
        if (arr != null & length < arr.length) {
            for (int i = 0; i < length; i++) {
                nand[i] = arr[i];
            }
        }
        return nand;
    }

    public static char[] copy(char[] arr, int length) {
        char[] nand = new char[length];
        if (arr != null & length < arr.length) {
            for (int i = 0; i < length; i++) {
                nand[i] = arr[i];
            }
        }
        return nand;
    }

    public static void sort(int[] arr) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                for (int j = i; j < arr.length; j++) {
                    if (arr[j] < arr[i]) {
                        int temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            Arrays.stream(arr).forEach(s-> System.out.print(s+" "));
        }
        System.out.println();



    }

    public static void sort(char[] arr) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                for (int j = i; j < arr.length; j++) {
                    if (arr[j] < arr[i]) {
                        char temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            for (char s:arr){
                System.out.print(s+" ");
            }
        }
        System.out.println();


    }

    public static void sort(double[] arr) {
        if (arr != null) {
            for (int i = 0; i < arr.length; i++) {
                for (int j = i; j < arr.length; j++) {
                    if (BigDecimal.valueOf(arr[j]).doubleValue()<BigDecimal.valueOf(arr[i]).doubleValue()) {
                        double temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            Arrays.stream(arr).forEach(s-> System.out.print(s+" "));
        }
        System.out.println();

    }
    public static void print(int[] arr) {
        if (arr != null) {
            Arrays.stream(arr).forEach(s -> System.out.print(s + " "));
        }
    }


}

测试类Test03


import java.util.Arrays;

public class Test03 {
    public static void main(String[] args) {
//      测试3的下标：2
        int[] and = {1, 2, 3, 5, 7, 8, 9, 12, 15, 16, 18};
        System.out.println(MyArrays.binarySearch(and, 3));
//      测试b的下标：1
        char[] cand = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
        System.out.println(MyArrays.binarySearch(cand, 'b'));
//      测试2.2的下标：1
        double[] dand = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9};
        System.out.println(MyArrays.binarySearch(dand, 2.2));
//      测试复制and，长度为三的数组并遍历打印
        Arrays.stream(MyArrays.copy(and, 3)).forEach(s -> System.out.print(s + " "));
        System.out.println();
//      测试复制and，长度为三的数组并遍历打印
        char[] chars = MyArrays.copy(cand, 3);
        for (char s:chars){
            System.out.print(s+" ");
        }
        System.out.println();
//      测试复制and，长度为三的数组并遍历打印
        Arrays.stream(MyArrays.copy(dand, 3)).forEach(s -> System.out.print(s + " "));
        System.out.println("=================");
//        排序测试
//        1.int[] 数组排序
        int []aand={2,5,33,2,1,5,2,4,5,6,};
        MyArrays.sort(aand);
//        2.double[]数组排序
        double[] ddand={2.2,3.3,5.5,1.1,9.9,5.5,4.4,6.6,2.2,8.8};
        MyArrays.sort(ddand);
//        3.char[]数组排序
        char [] ccand={'v','w','e','a','x','b','x','e','h'};
        MyArrays.sort(ccand);







    }
}