数组
        一维数组

                数组的定义: 用来存储多个元素的一个容器
                            数组可以存储基本数据类型也可以存储引用数据类型
                格式:
                        格式1: 数据类型[] 数组名 ;
                        格式2: 数据类型 数组名[] ;

                数组的初始化:
                        (1): 动态初始化                由我们给定数组的长度,由系统来分配初始化值
                        (2): 静态初始化                由我们给定初始化值,由系统来决定长度

                        注意事项: 不能进行动静结合       
               
                java语言的内存分配
                        (1): 栈:        存储的都是局部变量
                                        局部变量: 就是在方法定义中或者方法声明上的变量
                        (2): 堆:        存储都是new出来的东西
                                        特点:
                                                (1): 系统会为每一个new出来的东西分配一个地址值
                                                (2): 系统会为每一个元素赋一个默认的初始化值
                                                        byte,short,int,long        ---  0
                                                        float,double                ---  0.0
                                                        char                        ---  '\u0000'
                                                        boolean                        ---  false
                                                        引用数据类型                ---  null
                                                (3): 使用完毕以后就变成了垃圾,等待垃圾回收器对其回收
                        (3): 方法区(面向对象部分)
                        (4): 本地方法区(和系统相关)
                        (5): 寄存器(CPU)

                内存图:
                        一个数组的内存图:                数组在内存中是如何构建的
                        二个数组的内存图:                每new一次会在堆内存中重新开辟空间
                        3个引用2个数组的内存图:                栈内存中的多个引用可以指向堆内存中的同一个地址
       
                数组的静态初始化:
                        格式:         数据类型[] 数组名 = new 数据类型[]{元素1 , 元素2 , ....};
                        简化格式:
                                数据类型[] 数组名 = {元素1 , 元素2 , ...} ;

                数组的常见操作:
                        (1): 遍历
                                public static void print(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.print(arr[x] + ", ");
                                                }
                                        }
                                }
                        (2): 获取最值
                                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 ;
                                }
                        (3): 反转
                                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 ;
                                        }
                                }
                        (4): 查表法
                        (5): 基本查找(查找某一个元素在数组中第一次出现的索引)
                                public static int getIndex(int[] arr , int value){
                                        for(int x = 0 ; x < arr.length ; x++){
                                                if(arr[x] == value){
                                                        return x ;
                                                }
                                        }

                                        return -1;
                                }

                                public static int getIndex2(int[] arr , int value){
                                        int index = -1 ;
                                        for(int x = 0 ; x < arr.length ; x++){
                                                if(arr[x] == value){
                                                        index = x ;
                                                        break ;
                                                }
                                        }
                                        return index ;
                                }
        二维数组
                第一种经典格式:
                        数据类型[][] 数组名 = new 数据类型[m][n];
                        m: 在这个二维数组中有m个一维数组
                        n: 每一个一维数组的长度是n
                       
                        非经典格式:
                                数据类型 数组名[][] = new 数据类型[m][n];
                                数据类型[] 数组名[] = new 数据类型[m][n];
                第二种格式:
                        数据类型[][] 数组名 = new 数据类型[m][];
                        m: 在这个二维数组中有m个一维数组
                        而我们的每一个一维数组可以动态给出

                第三种格式:
                        数据类型[][] 数组名 = new 数据类型[][]{{元素...} ,{元素 ....} ,{元素...}....};
                        简化格式:
                                数据类型[][] 数组名 = {{元素...} ,{元素 ....} ,{元素...}....};

                遍历二维数组
                        public static void print(int[][] arr){
                                for(int x = 0 ; x < arr.length ; x++){
                                        for(int  y = 0 ; y < arr[x].length ; y++){
                                                System.out.print(arr[x][y] + "\t");
                                        }
                                        System.out.println();
                                }
                        }

                        两个练习:        求年销售额 , 杨辉三角

java语言中的参数传递问题

        基本数据类型的参数传递,形式参数的改变对实际参数没有影响
        引用数据类型的参数传递,形式参数的改变对实际参数是有直接影响的

        java中只有值传递,没有址传递

总结的很详细,让我受益匪浅