java 数组 array

一、数组复制copyOfRange

import java.util.Arrays;
/*
与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。
 */
public class ArrayCopy {
    public static void main(String[] args) {
        int a[] =new int [] {5,6,2,8,9,};
        System.out.print("The Original array is:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"    ");
        }
        System.out.println();
        System.out.print("after copy's array:");
        //copyOfRange(int [] original,int from,int end)
        //original 表示源数组
        //from     表示复制的初始位置
        //end      表示复制末位置
        int [] b= Arrays.copyOfRange(a,0,4);
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+"     ");
        }
    }
}

运行后的结果：

The Original array is:5    6    2    8    9    
after copy's array:5     6     2     8   

二、数组转换为字符串

import java.util.Arrays;

//如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
//但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容
public class ToString_Test {
    public static void main(String[] args) {
        int [] a=new int []{3,8,6,9,1};
        String b= Arrays.toString(a);
        System.out.println(b);
    }
}

转译后的字符串: [3, 8, 6, 9, 1]

三、排序

import java.util.Arrays;

//使用Arrays.sort(int [] a)方法即可对数组进行排序
public class Sort_Test {
    public static void main(String[] args) {
        int [] a=new int [] {78,34,54,23,12,99};
        System.out.println("after sort:"+Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("befor sort:"+Arrays.toString(a));
    }
}

运行结果

after sort:[78, 34, 54, 23, 12, 99]
befor sort:[12, 23, 34, 54, 78, 99]

四、搜索

public class BinarySearch {
    /*
 查询元素出现的位置
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的
     */
    public static void main(String[] args) {
        int [] a=new int[]{4,8,89,63,67};
        Arrays.sort(a);
        System.out.println("The array is: "+ Arrays.toString(a));
        System.out.println("数子63出现的位置是:");
        System.out.println(Arrays.binarySearch(a,63));
    }
}

排序前：

The array is: [4, 8, 89, 63, 67]
数子63出现的位置是:
-3

排序后：

The array is: [4, 8, 63, 67, 89]
数子63出现的位置是:
2

五、判断是否相同

import java.util.Arrays;

/*
比较两个数组的内容是否一样
第二个数组的最后一个元素是8，和第一个数组不一样，所以比较结果是false
 */

public class Equals_Test {
    public static void main(String[] args) {
        int [] a=new int[] {12,34,54,65,23};
        int [] b=new int[] {12,34,54,65,87};
        System.out.println(Arrays.equals(a,b));
    }
}

结果：false

六、填充

import java.util.Arrays;

public class Fill_Test {
    //使用同一个值，填充整个数组
    public static void main(String[] args) {
        int a[] =new int[10];
        Arrays.fill(a,4);
        System.out.println(Arrays.toString(a));
    }
}

结果：[4, 4, 4, 4, 4, 4, 4, 4, 4, 4]

七、二维数组排序

import java.util.Arrays;
import java.util.Random;
public class Test {
    //练习-二维数组排序
    /*
    首先定义一个5X8的二维数组，然后使用随机数填充满。
借助Arrays的方法对二维数组进行排序。
参考思路：
先把二维数组使用System.arraycopy进行数组复制到一个一维数组
然后使用sort进行排序
最后再复制回到二维数组。
关于随机数
0-100的 随机整数的获取办法有多种，下面是参考办法之一:

(int) (Math.random() * 100)

Math.random() 会得到一个0-1之间的随机浮点数，然后乘以100，并强转为整型即可。
     */

        public static void main(String[] args) {
            int[][] a = new int[5][8];
            int[] b = new int[a.length * a[0].length];
            for (int i = 0; i < a.length; i++)
                for (int j = 0; j < a[i].length; j++) {
                    a[i][j] = new Random().nextInt(100);
                }
            System.out.println("打印二维数组：" + Arrays.deepToString(a));
            System.out.println();
            //降维，把二位数组赋值到一维数组
            int x = 0;
            for (int i = 0; i < a.length; i++) {
                System.arraycopy(a[i], 0, b, x, a[i].length);
                x+=a[i].length;
            }

            //升维，把已经排好序的一维数组编程二位数组
            Arrays.sort(b);
            int y = 0;
            for (int i=0;i<a.length;i++){
                System.arraycopy(b,y,a[i],0,a[i].length);
                y += a[i].length;
            }

            System.out.println("打印排序后的二维数组：" + Arrays.deepToString(a));
        }
}

结果：`打印二维数组：[[43, 7, 70, 35, 5, 96, 41, 50], [6, 82, 86, 47, 10, 67, 68, 57], [30, 28, 97, 78, 92, 20, 18, 8], [48, 9, 1, 43, 87, 31, 57, 20], [70, 48, 26, 15, 94, 60, 69, 52]]

打印排序后的二维数组：[[1, 5, 6, 7, 8, 9, 10, 15], [18, 20, 20, 26, 28, 30, 31, 35], [41, 43, 43, 47, 48, 48, 50, 52], [57, 57, 60, 67, 68, 69, 70, 70], [78, 82, 86, 87, 92, 94, 96, 97]]

注：详情https://how2j.cn/