Java学习笔记----一维数组

• 数组的特点
• 定义格式
• 数组的初始化
• Java的内存分配
• 数组内存图
• 数组的常见操作

---

数组的特点

1、存储同一种数据类型的多个元素的容器。

2、每一个元素都有编号（索引），从0开始，最大编号是长度-1。

数组的定义格式

1、数组类型[] 数组名；

2、数组类型 数组名[]；

推荐使用方式1

数组的初始化

1、动态初始化（只给长度，系统默认给初始值）

举例：int[] arr = new int[3];

2、静态初始化（给出值，系统决定长度）

举例：int[] arr = new int[] {1，2，3，4};

简化版：int[] arr = {1，2，3，4};

注意：int[] arr = new int[4] {1，2，3，4};这样是错误的，不能同时动态和静态进行

Java的内存分配

Java程序运行时，需要字在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据和内存管理的方式。

栈：存储局部变量

堆：存储new出来的东西

注意

a:局部变量 在方法定义中或者方法声明上定义的变量。
b:栈内存和堆内存的区别
    栈：数据使用完毕，就消失。
    堆：每一个new出来的东西都有地址
        每一个变量都有默认值
        byte,short,int,long 0
        float,double 0.0
        char '\u0000'
        boolean false
        引用类型 null
数据使用完毕后，在垃圾回收器空闲的时候回收。

数组内存图

数组静态初始化及内存图

数组的内存图解(一个数组)

数组的内存图解(两个数组)

数组的内存图解(三个数组，两个栈变量指向同一个堆内存)

数组常见操做

        A:遍历
            方式1：
                public static void printArray(int[] arr) {
                    for(int x=0; x<arr.length; x++) {
                        System.out.println(arr[x]);
                    }
                }

            方式2：
                public static void printArray(int[] arr) {
                    System.out.print("[");
                    for(int x=0; x<arr.length; x++) {
                        if(x == arr.length-1) {
                            System.out.println(arr[x]+"]");
                        }else {
                            System.out.println(arr[x]+", ");
                        }
                    }
                }
        B:最值
            最大值：
                public static int getMax(int[] arr) {
                    int max = arr[0];

                    for(int x=1; x<arr.length; x++) {
                        if(arr[x] > max) {
                            max = arr[x];
                        }
                    }

                    return max;
                }

            最小值：
                public static int getMin(int[] arr) {
                    int min = arr[0];

                    for(int x=1; x<arr.length; x++) {
                        if(arr[x] < min) {
                            min = arr[x];
                        }
                    }

                    return min;
                }
        C:逆序
            方式1：
                public static void reverse(int[] arr) {
                    for(int x=0; x<arr.length/2; x++) {
                        int temp = arr[x];
                        arr[x] = arr[arr.length-1-x];
                        arr[arr.length-1-x] = temp;
                    }
                }

            方式2：
                public static void reverse(int[] arr) {
                    for(int start=0,end=arr.length-1; start<=end; start++,end--) {
                        int temp = arr[start];
                        arr[start] = arr[end];
                        arr[end] = temp;
                    }
                }
        D:查表
                public static String getString(String[] strArray,int index) {
                    return strArray[index];
                }
        E:基本查找
            方式1：
                public static int getIndex(int[] arr,int value) {
                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            return x;
                        }
                    }

                    return -1;
                }

            方式2：
                public static int getIndex(int[] arr,int value) {
                    int index = -1;

                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            index = x;
                            break;
                        }
                    }

                    return index;
                }

二维数组的初始化格式：
1、数据类型[][] 数组名 = new 数组类型[m][n];
2、数据类型[][] 数组名 = new 数组类型 [m][];
3、数据类型[][] 数组名 = new 数据类型 [][]{{…},{…},{…}};
4、数据类型[][] 数组名 = {{…},{…},{…}}；