bilibiliJava学习数组练习

1.JVM分为五个区域

方法区，本地方法栈，Java虚拟机栈，堆，程序计数器

今日重点学习Java虚拟机栈和堆的内容 

 2.昨日小内容

public static void main(String[] args) {
    int[] array = {1,2,3,4};
    int[] array2 = array;

    //当前array3不引用任何对象
    int[] array3 = null;
    //开辟了一块新的内存；
    int[] array4 = new int[]{1,2,3,4,5};
    
    //这样是错误的，没有初始化
   int[] array5;
   //array5 = {1,2,3,4};只能写为
    array5 = new int[]{1,2,3,4,5};
    

3.数组转字符串

解析：用到的是 Arrays.toString(array);

public static void main(String[] args) {
    int[] array = {1,2,3,4};
    String ret = Arrays.toString(array);
    System.out.println(ret);
}

.Arrays;是操作数组相关的工具类，还可以自己写一个toString来进行转字符串

public class Test {
    public static String mytoString(int[] tmp){
        if(tmp == null){
            return null;
        }
        String ret = "[";
        for (int i = 0; i < tmp.length; i++) {
            ret = ret + tmp[i];
            if(i != tmp.length-1){
                ret +=", ";
            }
        }ret +="]";
        return ret;

    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        String ret = Arrays.toString(array);
        String ret1 = mytoString(array);
        System.out.println(ret);
        System.out.println(ret1);
    }

4.数组拷贝

（1）自己写的

public static void main(String[] args) {
    int[] array = {1,2,3,4};
    int[] temp = new int[array.length];
    for (int i = 0; i < array.length; i++) {
        temp[i] = array[i];
    }
    System.out.println(Arrays.toString(temp));


}

就是这样，牛逼

（2）勾八，有一个新方法Arrays.copyOf(拷贝的数组，拷贝多长)

int[] array2 = Arrays.copyOf(array,array.length);
System.out.println(Arrays.toString(array2));

他居然还能扩容

//扩容两倍
int[] array2 = Arrays.copyOf(array,array.length*2);
System.out.println(Arrays.toString(array2));

所得到的就是下面的结果

[1, 2, 3, 4]
[1, 2, 3, 4, 0, 0, 0, 0]

 （3）还有一个更牛逼的

还支持局部的拷贝

int[] array3 = {1,3,5,7,9};
int[] copy = new int[array3.length];

System.arraycopy(array3,0,copy,0,array3.length);
System.out.println(Arrays.toString(copy));

（4）拷贝范围copyrange新方法

//方法4拷贝范围
int[] array = {1,2,3,4};
int[] array4 = Arrays.copyOfRange(array,1,3);
System.out.println(Arrays.toString(array4));

他这个结果案例来说应该得到的是2,3,4.

但是实际结果是2,3

原因是在Java它的集合是左闭右开的，就是[0,4)，它不包括右集合

（5）克隆

int[] array = {1,2,3,4};
//方法5克隆
int[] array5 = array.clone();
System.out.println(Arrays.toString(array5));

用2,3比较多，就是Arrays.copyOf和System.arraycopy(array3,0,copy,0,array3.length);

注意：数组当中储存的是基本数据类型时，不论怎么拷贝基本都不会出现什么问题，但是如果存储型，拷贝时需要考虑深浅拷贝的问题，关于深浅拷贝在后续详细再说。 

5.求数组中元素的平均值

public static double avg(int[] array){
    int sum = 0;
    for (int x:
         array) {
        sum += x;
    }
    return sum*1.0 / array.length;
}
public static void main(String[] args) {
    int[] array = {1,2,3,4};
    System.out.println(avg(array));
}

6.查找数组中指定元素（顺序查找）

public static int find(int[] array,int n){
    for (int i = 0; i < array.length ; i++) {
        if(array[i] == n){
            return i;
        }
    }
    //代表没找到，因为-1是不存在于下标中的
    return -1;
}
public static void main(String[] args) {
    int[] array = {1,2,3,4,5,6};
    System.out.println(find(array,5));
}

（二分查找）一定是建立在有序的情况下才能用

public static int binarySearch(int[]array,int n){
    int left = 0;
    int right = array.length - 1;
    //   就是除以2
    while(left <= right){
        int mid = (left + right) / 2;
        if(array[mid] < n){
            left = mid + 1;
        }else if(array[mid] > n){
            right = mid - 1;
        }else {
            return mid;
        }
    }return -1;
}
public static void main(String[] args) {
    int[] array = {1,2,3,4,8,9,7,2,10,56,88,0,-1,6,7};
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));
   int ret = binarySearch(array,8);
    System.out.println(ret);
}

Arrays.sort是函数的一个快排,不是冒泡排序，它是默认升序的。它是存在于函数库里的可以直接用

int ret1 = Arrays.binarySearch(array,9);
System.out.println(ret1);

要是想搞降序

Integer[] array = {1,2,3,4,8,9,7,2,10,56,88,0,-1,6,7};
Arrays.sort(array);
Arrays.sort(array, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1-o2;//降序就是o2-o1
    }
});

具体步骤就是把数组搞成Integer类型的，然后打代码Array.sort(array, new Comparator<Interger>)回车就行了

7.数组逆序

public static void  reverse(int[] array){
    int left = 0;
    int right = array.length - 1;
    int tmp = 0;
    while(left != right){
        tmp = array[left];
        array[left] = array[right];
        array[right] = tmp;
        left++;
        right--;
    }
    return array[left];
}

public static void main(String[] args) {
    int[] array = {15,16,17,18,19};
    reverse(array);
    System.out.println(Arrays.toString(array));
}

8.数组判断相等

public static void main(String[] args) {
    int[] array = {5,5,5,5,9,9,5,7452,2,4544,5};
    int[] array2 = {5,5,5,5,9,9,5,7452,2,4544,5};
    boolean flg = Arrays.equals(array,array2);
    System.out.println(flg);

Arrays.equals的源码

 9.让数组初始化为固定数值

public static void main(String[] args) {
    int[] array1 = new int[10];
    //让array1全初始化为-1
    Arrays.fill(array1,-1);
    System.out.println(Arrays.toString(array1));
    //让array1从[2到5)初始化为-1
    Arrays.fill(array1,2,5,-1);
    System.out.println(Arrays.toString(array1));
}