数组

线程隔离的数据区	JAVA虚拟机栈（一般说的栈）
	本地方法栈（一般来执行C/C++的方法）
	程序计数器（存放指令）
所有	堆（存放对象）
	方法区（存储静态变量）

int aa=10; int[] array={12,23,34,45,56};

array是引用变量，后面的赋值是数据对象

局部变量在栈上开辟内存，此时的aa，array都是局部变量

表达形式：array这个引用指向了哪个对象

null的情况

int array1=null; sout(array1);

代表array1这个引用不能指向任何对象

若有sout(array1[0]);则有NullPointerException空指针异常

没有人引用堆里的某个对象时，JVM会自动回收该对象

array1=array2;意思是array1这个引用指向了array2这个引用所指向的对象。

理解：存储了值，值是个地址

tips:

1.JAVA中null和0号地址内存并无关联

2.不是传引用就一定会修改实参的值，需要具体看，拿到引用之后形参做了什么动作

字符串的拼接

例：自己写mytostring输出[1,2,3,4]

public class TEXT1 {
    public static String myTOString(int[] array){
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            str += array[i];
            if (i != array.length-1){
                str += ", ";
            }
        }
        str += "]";
        return str;
    }

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

    String str = myTOString(array);
    System.out.println(str);
    }
}

数组的拷贝

import java.util.Arrays;

public class TEXT1 {
    public static int[] copyOf(int[] array){
        int[] copy = new int[array.length];

        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }

    public static void main(String[] args) {
    int[] xxx = {9,9,9,9};

    int[] array2 = copyOf(xxx);
    System.out.println(Arrays.toString(array2));
    //用法一样：
    //String str = Arrrays.tostring(arrray);
    //System.out.println(str);
    }
}

拷贝是把一个图复制出一个图，意思是多了一个对象

int array2={1,2,3,4}; array3=array2; 不叫拷贝

只是指向的对象一样了，并没有多复制出来一个对象

JAVA中的拷贝方法：

一、

int[] xxx = Arrays.copyOf(array，array.length);

参数一：要拷贝的数组

参数二：要拷贝的长度

二、

int[] xxx = Arrays.copyOfRange(array，2，5);

意思是from 2 to 5，JAVA取值范围一般是左闭右开[2,5)

拷贝是连续的，不是跳着的

三、

public static native void arraycopy(Object str,int srcPos,Object dest,int destPos,int length);

其中的native底层是c/c++代码，优点是速度快

例题：求数组全部长度的平均值

public class TEXT2 {
    public static void main(String[] args) {
        //求数组全部长度的平均值
        int[] array = {1,2,3,4,5,6,7,8,9};
        int sum = 0;
        for (int x:array) {
            sum += x;
        }
        System.out.println(sum*1.0 / array.length);
    }
}

查找数组中的指定元素（顺序查找或二分查找）

import java.util.Arrays;

public class TEXT2 { //用二分法查找数组中的指定元素
    public static int search(int[] array, int k) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = (left + right) / 2;
            if (array[mid] < k) {
                 left = mid + 1;
            }
            else if (array[mid] > k) {
                 right = mid - 1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        //用二分法查找数组中的指定元素
        int[] array = {1,2,3,4,5,6,7,8,9};
        System.out.println(search(array, 3));
        System.out.println("====================");
        System.out.println(Arrays.binarySearch(array,3));//java中定义的
    }
}

排序

import java.util.Arrays;

public class TEXT3 {
    public static void bubbleSort(int[] array){//冒泡排序
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j+1]){
                    swap(array,j,j+1);
                }
            }
        }
    }

    public static void swap(int[] array,int k,int p){
        int temp = array[k];
        array[k] = array[p];
        array[p] = temp;
    }

    public static void reverse(int[] array){
        int left = 0;
        int right = array.length-1;
        while (left < right){
            swap(array,left,right);
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] array = {1,99,77,4,5,66};
        
        bubbleSort(array);//自己定义的排序
        System.out.println(Arrays.toString(array));

        System.out.println("=========================");

        Arrays.sort(array);//java中的排序
        System.out.println(Arrays.toString(array));

        System.out.println("=========================");

        reverse(array);//自己定义的逆序排序
        System.out.println(Arrays.toString(array));
    }
}

二维数组

int[][] array={{1,2,3},{1,2,3}};

1	2	3
4	5	6

打印二维数组的三种方式

一、

System.out.print(Arrays.deepToString(array));

二、

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]);
            }
            System.out.println();
        }

三、

        for (int[] temp:array) {
            for (int x:temp) {
                System.out.print(x+"  ");
            }
            System.out.println();
        }
        System.out.println();

（笔记来自比特课程）