数组：（引用类型）
        概述；用来存储同一类型元素的容器。
                  可以存基本类型，也可以存引用类型。
                  每个元素都有编号，并且编号是从0开始的。（编号：也叫下标，角标，索引）

                  根据索引获取指定位置的元素：
                                拿第三个元素： arr[2]
                                拿第六个元素： arr[5]
                                总结：
                                        拿哪个位置的元素，就相当于： 数组名[元素个数 - 1]
                                        最后一个元素的索引：        arr[数组长度 - 1];
        初始化：
                概述：
                        就是为数组开辟连续的内存空间，并且给每个数组元素赋值
                分类：
                        动态初始化：我们给长度，系统给默认值
                                数据类型[]        数组名        = new 数据类型[数组的长度或者元素的个数];
                                        推荐：int[] arr = new int[5];        //定义一个长度为5的 int类型的数组，数组名叫arr
                                变形：
                                        int arr[] = new int[5];//定义一个长度为5的 int类型的arr数组

                                各类型的默认值：
                                        基本类型：
                                                整型：0
                                                浮点型：0.0
                                                布尔：false
                                                字符：'\u0000'        每个0代表的是4位，也就是说，这个里边的0都是十六进制的。

                                        引用类型：
                                                null
                        静态初始化：我们给值，系统给长度
                                格式：
                                        int[] arr = new int[]{1,2,3,4,5};
                                        简化版：
                                                int[] arr = {1,2,3,4,5};        //推荐做法

                                        不要写成: int[] arr = new int[5]{1,2,3,4,5};  这种写法是错误的。

        可能遇到的问题：
                数组索引越界异常：ArrayIndexOutOfBoundsException。
                        访问了不存在的索引就会出这个问题。
                空指针异常：NullPointerException。
                        数组已经不存在了，我们还去使用它里边的东西。

        数组的常见操作：
                记忆：方法的功能越单一越好。

                数组的遍历：
                        数组的长度： 数组名.length
                        根据索引获取指定元素：  数组名[索引];
                        public static void print(int[] arr) {
                                //遍历数组的代码
                                for(int i=0; i<arr.length; i++) {
                                        System.out.println(arr[i]);
                                }
                        }

                最值（最大值，最小值）
                        int[] arr = {1,2,3,4,5};
                        思路：
                                1、定义一个统计变量max，用来记录最大值，初始值为 数组中的第一个元素值。
                                2、通过遍历，获取到数组中的每一个元素，然后依次和max进行比较。
                                        如果大了，就把当前遍历到的值给 max
                                        如果小了，什么都不操作。
                                3、循环结束后，max记录的就是最大值。

                        用方法来做：
                                分析：
                                        返回值的数据类型：int
                                        参数列表：int[] arr
                                public static int getMax(int[] arr) {
                                        int max = arr[0];                //定义一个统计变量max，用来记录最大值
                                        for(int i=1; i<arr.length; i++) {        //通过遍历，获取到数组中的每一个元素
                                                //arr[i] 就是遍历到的每一个元素
                                                if(max < arr[i]) {        //依次和max进行比较
                                                        max = arr[i];                                               
                                                }                                       
                                        }
                                        return max;
                                }

                反转：
                        1,2,3,4,5    5,4,3,2,1
                        5,2,3,4,1        第一个和最后一个交换        arr[0]        arr[arr.length-1-0]
                        5,4,3,2,1        第二个和倒数第二个交换        arr[1]        arr[arr.length-1-1]
                                                第三个和单数第三个交换        arr[2]        arr[arr.length-1-2]
                                                ......................        arr[i]  arr[arr.length-1-i]

                        关键点：
                                交换的次数：数组的长度/2
                                谁和谁交换：arr[i] 和 arr[arr.length-1-i]

                        用方法来做：
                                返回值的数据类型：void
                                参数列表：int[] arr
                                public static void reverse(int[] arr) {
                                        for(int i=0; i<arr.length/2; i++) {
                                                int temp = arr[i];
                                                arr[i] =  arr[arr.length-1-i];
                                                arr[arr.length-1-i] = temp;
                                        }

                                }
                查表法：
                        解释：根据 索引（index） 去找 数组中的指定元素
                        public static char getElement(int week) {
                                char[] chs = {' ','一','二','仨','四','五','六','日'};
                                return chs[week];
                        }

                基本查找：
                        解释：找元素在数组中 对应的索引
                        思路：
                                1、遍历数组，获取到每一个元素。
                                2、依次和要查找的值（value）进行比较，
                                        如果相等，就返回该索引。
                                        如果不等，接着循环，进行下一次比较。
                                3、如果循环都结束了，还没有找到，那么就说明数组中没有这个元素，索引就返回-1.
                        定义方法：
                                返回值类型：int
                                参数列表：int[] arr, int value(值)
                                public static int getIndex(int[] arr,int value) {
                                        for(int i=0; i<arr.length; i++) {
                                                //arr[i]就是遍历到的每一个元素
                                                if(arr[i] == value) {
                                                        return i;
                                                }
                                        }
                                        //走到这儿了，说明循环都结束了，还没有找到这个元素，就返回-1
                                        return -1;
                                }

        内存：
                栈：掌握
                        存的是局部变量， 所有代码的执行也是在栈中完成
                        局部变量：定义在方法中，或者方法声明上的变量。
                        栈的特点： 先进（压栈）后出（弹栈）。


                堆：掌握
                        所有new出来的东西（对象）。
                        所有new出来的东西都有自己的地址值。
                                地址值的组成：类名缩写 + @ + 该对象的哈希值的无符号 十六进制形式组成。
                方法区：
                        代码区，方法区，静态区，常量池（String常量池，byte常量池）
                本地方法区：
                        存的是本地方法。
                寄存器：
                        和CPU相关的一些东西。

                三个数组：
                        int[] arr1 = new int[3];
                        int[] arr2 = new int[3];
                        int[] arr3 = arr2;

二维数组：       
        概述：每个元素都是 一维数组的 数组。
        格式：
                格式1：规则的矩形。
                        int[][] arr = new int[3][2];                               
                        变形为：
                                int[] arr[] = new int[3][2];
                                int arr[][] = new int[3][2];

                        解释：
                                3：代表二维数组中 有3个一维数组
                                2：代表每个一维数组有两个元素。
                                arr[2]:        代表的是 二维数组的第三个元素（第三个一维数组）
                                arr[1][2]： 代表的是二维数组的 第二个元素（第二个一维数组）的第三个元素
                格式2：不规则的矩形。
                        int[][] arr = new int[5][];
                        /*arr[0] = new int[2];
                        arr[1] = new int[2];
                        arr[2] = new int[2];*/
                格式3：
                        int[] arr = {1,2,3,4,5};
                        int[][] arr = { {1,2,3},{4,5},{6,7,8}};
                常见操作：
                        int[][] arr = { {1,2,3},{4,5},{6,7,8,9}};
                        数组名.length
                                1,2,3
                                4,5
                                6,7,8,9
                        遍历：
                                思路：
                                        1、通过for遍历二维数组，获取到每一个元素（一维数组）。
                                        2、一维数组的遍历我们讲过了。
                                for(int i=0; i<arr.length; i++) {//遍历二维数组，获取到每一个元素（一维数组）
                                        //arr[i]就是当前遍历到的元素，也就是一维数组
                                        for(int j=0; j<arr[i].length; j++) {
                                                System.out.print(arr[i][j] + " ");
                                        }
                                        System.out.println();
                                }
                        求和：
                                思路：
                                        1、定义一个统计变量sum，来记录和。
                                        2、遍历二维数组，获取到每一个元素（一维数组）
                                        3、继续遍历获取到的一维数组，然后获取到每一个元素，和sum累加即可。
                                        int sum = 0;
                                        for(int i=0; i<arr.length; i++) {//遍历二维数组，获取到每一个元素（一维数组）
                                                //arr[i]就是当前遍历到的元素，也就是一维数组
                                                for(int j=0; j<arr[i].length; j++) {
                                                        //arr[i][j]
                                                        sum += arr[i][j];
                                                }
                                }

Java中的参数传递问题：
        Java中只有值传递，引用传递传递的是地址值。
        如果方法的形参是：
                基本类型：形参的改变对实参没有影响。
                引用类型：形参的改变直接影响实际参数（String类有点特殊，常用API讲）。



               
                反转：
                        数组元素是 1,2,3,4,5，打印结果就是：5,4,3,2,1
                       
                基本查找:
                        给定一个值，然后找它在数组中的索引，存在就返回该索引，不存在就返回-1
                                比如说：
                                        找元素值为3的索引，返回值就是2
                                        找元素值为6的索引，返回值就是-1
                                               

赞一个。