数组
                一维数组
                        数组: 用来存储同一种数据类型的容器
                        数组的格式:
                                数据类型[] 数组名 ;
                                数据类型 数组名[];

                        数据的初始化:
                                静态初始化:        由我们给定出初始化值,由系统分配长度
                                动态初始化:        由我们给定数组的长度,由系统给出初始化值
                                注意事项:
                                        不能进行动静结合
                        动态初始化:
                                数据类型[] 数组名 = new 数据类型[数组长度];
                                数组长度: 就是该数组中元素的个数
                        java语言的内存分配:
                                (1): 栈:        存储的都是局部变量
                                                        局部变量: 就是在方法定义中或者方法声明上的变量
                                (2): 堆:        存储的都是new出来的东西
                                                        a: 系统会为每一个new出来的东西分配一个地址值
                                                        b: 系统会为每一个元素赋一个默认的初始化值
                                                                byte, short, int, long                -----  0
                                                                float , double                                -----  0.0
                                                                char                                                -----  '\u0000'
                                                                boolean                                                -----  false
                                                                引用数据类型                                -----  null
                                                        c: 使用完毕以后就变成了垃圾,等待垃圾回收器对其回收
                                (3): 方法区(面向对象部分)
                                (4): 本地方法区(和系统相关)
                                (5): 寄存器(CPU)
                        内存图:
                                一个数组的内存图                                想让大家知道数组在内存中是如何构建的
                                二个数组的内存图                                每new一次都会在堆内存中重新开辟空间
                                3个引用两个数组的内存图                        我们栈内存中的多个引用可以指向堆内存中的同一个地址
                       
                        静态初始化:
                                格式: 数据类型[] 数组名 = new 数据类型[]{元素1 , 元素2 , 元素3 ,....};
                                简化版:         数据类型[] 数组名 = {元素1 , 元素2 , 元素3 ,....};
                       
                        数组的常见操作:
                               
                                遍历                       
                                                                public static void print(int[] arr){
                                                                        System.out.print("[ ");
                                                                        for(int x = 0 ; x < arr.length ; x++){
                                                                                if(x == arr.length - 1){
                                                                                        System.out.print(arr[x] + " ]");
                                                                                }else {
                                                                                        System.out.print(arr[x] + ", ");
                                                                                }
                                                                        }
                                                                }
                                获取最值               
                                                                public static int getMax(int[] arr){
                                                                        int max = arr[0] ;
                                                                        for(int x = 0 ; x < arr.length ; x++){
                                                                                if(arr[x] > max){
                                                                                        max = arr[x] ;
                                                                                }
                                                                        }
                                                                        return max ;
                                                                }
                                查表法:                思路: 通过数组模拟一张表,录入索引查处指定的元素
                                反转
                                                                public static void reverseArr(int[] arr){
                                                                        for(int x = 0 , y = arr.length - 1 ; x <= y ; x++ , y-- ){
                                                                                int temp = arr[x] ;
                                                                                arr[x] = arr[y] ;
                                                                                arr[y] = temp ;
                                                                        }
                                                               
                                                                }
                                基本查找
                                                                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 ;
                                                                }

不错，总结得很好！！