数组：Array
        为什么要有数组？
                用来存储多个同类型的数据。
        什么是数组？（掌握）
                就是用来存储多个同类型数据的容器。数组即可以存基本类型，也可以存引用类型。
                数组的索引(角标，下标)是从0开始的，
                数组的最大索引： arr.length - 1;
        格式：
                动态初始化：给出长度，让系统来给定初始化值。
                        数据类型[] 数组名 = new 数据类型[数组的长度];
                        int[] arr = new int[5];
                        各数据类型的默认初始化值：（掌握）
                                byte，short，long，int ：0
                                float，double ： 0.0
                                char： '\u0000'
                                boolean：false
                        了解：
                                System.out.println(arr);   //[I@19bb25a  
                                I:Integer是基本类型int类型的包装类
                                19bb25a：该对象的哈希码的无符号的十六进制形式。
                        内存是如何划分：
                                栈：存的是局部变量。 (特点：先进后出)
                                        局部变量：定义在方法中或者方法的声明上的变量。
                                        public static int getSum(int a,int b){
                                                int sum = a + b;
                                                return sum;
                                        }
                                堆：存的是所有new出来的东西（数组，对象）。
                        int[] arr1 = new int[3];   //0x0011
                        sop(arr1);
                        int[] arr2 = new int[3];
                        int[] arr3 = arr1;

                静态初始化：给出初始化值，让系统来定义长度。
                        普通版：int[] arr = new int[]{1,2,3,4,5};  //注意，=号右边的括号中不能写长度
                        简化版：int[] arr = {1,2,3,4,5};

数组的常见操作：（掌握）
        遍历：
                1、获取到数组的长度，根据数组的长度计算出数组的最大索引。
                2、通过for循环遍历。
        获取最值：
                最大值：
                        1、定义一个变量max，来记录最大值，初始值是数组中的第一个元素。
                        2、通过for循环，遍历数组，拿到数组中的每一个元素，然后依次和max比较，
                                如果遍历到的元素比max大，就把该元素的值给max。
                                循环结束后，max记录的就是最大值。
                                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;
                                }
        数组反转：
                1、如何定义出方法.
                        A：返回值：void
                        B：参数列表：int[]

                2、定义一个第三方变量。
                3、通过for循环获取到数组中的每一个元素，按照第一个和最后换，第二个和倒数第二个换的规则。。
                  进行交换变量。（规则：arr[i] 和 arr[arr.length-1-i]）
                  public static void reverseArray(int[] arr){
                                int temp = 0;
                                for(int i = 1; i<arr.length/2; i++){
                                        //就是交换：arr[i] 和 arr[arr.length-1-i]
                                        temp = arr[i];
                                        arr[i] = arr[arr.length-1-i];
                                        arr[arr.length-1-i] = temp;
                                }

                  }

        查表法：（大白话，就是根据索引，找数组中对应位置的元素）
                做完的同学思考：
                        通过键盘录入一个数据，然后打印出数组中对应位置的元素，应该怎么做？
                        数组如下：
                                char[] chs = {'','一','二','三','四','五','六','七'};

        基本查找：（查找某个值在数组中的索引）
                1、遍历数组，拿到数组中的每一个元素。
                2、判断当前遍历到的元素和要查找的元素是否一致。
                        如果一致，就将当前元素的索引返回。
                        如果不一致，就返回-1。


二维数组：
        概述：每个元素都是一维数组的数组，就叫二维数组。
        格式1：
                int[][] arr = new int[3][2];
                //二维数组中多个一维数组的长度可以不同（之后学习），且存储的是一维数组的地址值
        格式2：
                int[][] arr = new int[3][];
        格式3：
                int[][] arr = { {1,2,3},{4,5},{7,8,9},{12,13}};

                //int[][] arr = { A,B,C,D};

        二维数组的遍历：
                1、通过for循环遍历二维数组，拿到每一个一维数组。
                2、遍历一维数组的代码，咱们讲过了。
                for(int i = 0; i<arr.length; i++){   //这一步是拿到二维数组中的所有一维数组（arr[i]）
                        //arr[i]就是当前遍历到的一维数组  ABC
                        for(int j = 0; j<arr[i].length; j++){
                                Sysetm.out.print(arr[i][j] + " ");
                        }
                        System.out.println();
                }

        二维数组求和：
                1、通过for循环遍历二维数组，拿到每一个一维数组。
                2、遍历每个一维数组，拿到一维数组中的每一个元素，然后累加即可。
                某商场：
                        第一季度：20，60,80
                        第二季度：10，1，20
                        第三季度：5，50，150
                        第四季度：60，0，0

Java中的参数传递问题：
        Java中只有值传递，引用传递传递的是地址值。
        基本类型：形参的改变不影响实参。
        引用类型：形参的改变直接影响实参。（String有点特殊）
               
                需求：
                        1、定义一个长度为5的数组，然后分别给各个元素赋值为：1，2,3，4,5，然后打印各个元素的值
                                int[] arr = new int[5];
                                arr[0] = 1;
                        2、第一个数组，元素为（6,7,8,9,10），然后给第三个元素赋值为：521，打印各个元素的值。
                                int[] arr = {1,2,3,4,5};
                                打印第一个元素：sop(arr[0]);
                                打印最后一个元素：sop(arr[4]);
                                sop(arr[14]);
                        3、int[] arr = {1,2,3,4,5};    //自己写一个print()，来遍历数组

值得学习ing!

管理员规定论坛不许发笔记之类的  

6666                     

很嗨很不错