黑马程序员技术交流社区

标题: 0918笔记记录 [打印本页]

---

作者: Zzzack    时间: 2015-9-18 23:42
标题: 0918笔记记录
一、数组【掌握】
        1、数组：存储同一种数据类型的多个元素的容器。

        2、特点：每一个元素都有一个编号，从0开始，最大编号是数组长度 - 1。
                这个编号的专业叫法：索引。

        3、格式：
                (1)动态初始化
                        只指定长度，由系统给出初始化值
                        A:int[] arr = new int[3];
                        //B:int arr[] = new int[3];

                (2)静态初始化
                        给出初始化值，由系统计算长度
                        A:int[] arr = {1,2,3};
                        //B:int[] arr = new int[]{1,2,3};

                两种初始化都推荐A方案

        4、Java内存图：
                A:栈        存储局部变量; 方法在栈里面调用(压栈)
                        局部变量:定义在方法声明上和方法中的变量
                        方法调用完毕会弹栈，方法内部的局部变量也随之消失。

                B:堆        所有new出来的都在堆内存里面。
                        a:每一个对象都有地址值
                        b:堆内存里面每一个基本数据类型的变量都有默认值
                                整数：0                byte, short, int
                                浮点数：0.0        float, double
                                字符：'\u0000'        char
                                布尔：false        boolean

                C:方法区（面向对象部分讲解）
                D:本地方法区（和系统相关）
                E:寄存器（CPU使用）

        5、数组内存图
                A:一个数组
                B:二个数组
                C:三个数组(两个栈里面的局部变量指向同一个堆内存)

        6、常见操作：【重点掌握】
                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;
                                }
                       
                C:反转
                        方式1：
                                public static void reverseArray(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;
                                        }
                                }
                               
                        方式2：
                                public static void reverseArray(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:基本查找
                        public static int getIndex(int[] arr,int value) {
                                for(int x=0; x<arr.length; x++) {
                                        if(arr[x] == value) {
                                                return x;
                                        }
                                }
                                return -1;
                        }


        7、二维数组 【理解】
                格式：
                        A:int[][] arr = new int[3][2];           //有三个一位数组，每个一维数组里面有2个int元素。
                        B:int[][] arr = new int[3][];
                        C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

                遍历：
                        public static void print(int[][] arr) {
                                for (int i = 0; i < arr.length; i++) {
                                        for (int j = 0; j < arr[i].length; j++) {
                                                System.out.println(arr[i][j]);
                                        }
                                }
                        }
               
                求和：
                        public static int getSum(int[][] arr) {
                                int sum = 0;
                                for (int i = 0; i < arr.length; i++) {
                                        for (int j = 0; j < arr[i].length; j++) {
                                                sum += arr[i][j]
                                        }
                                }
                                return sum;
                        }

二、参数传递【掌握】
        public static void main(String[] args) {
                int a = 10;
                int b = 20;
                change(a, b);
                System.out.println("a=" + a + ", b=" + b);        //a=10, b=20

                int[] arr = {1,2,3,4,5};
                change(arr);
                System.out.println(arr[1]);           //arr[1] = 4;
        }

        public static void change(int a, int b) {
                a = b;
                b = a + b;
        }

        public static void change(int[] arr) {
                for(int x=0; x<arr.length; x++) {
                        if(arr[x]%2 == 0) {
                                arr[x] *= 2;
                        }
                }
        }

        结论：
        基本数据类型的值传递,不改变原值,因为方法在栈里面调用，调用完毕后方法会弹栈,局部变量也随之消失;
        引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问

        简单记：
                A: 基本数据类型作为方法参数传递时，形参的改变不影响实参;
                B：引用数据类型(数组，类，接口)作为参数传递时，形参的改变影响实参。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2