JavaSE自学笔记整理(三)

控制流程语句:

一、条件语句    格式1：        if(判断条件){            符合条件的语句;        }    格式2：        if(判断条件){            符合条件的语句;        }else{            不符合条件的语句;        }        简写格式：条件表达式？表达式1:表达式2;(三元运算符)        与三元运算符的区别：三元运算符运算完要有值出现。    格式3：        if(判断条件1){            执行的代码块1；        }else  if(判断条件2){            执行语句;        }else if(判断条件3){            执行语句；        }        ...

二、选择判断语句    switch语句选择的类型有int、short、byte、char、字符串(jdk7开始)。    switch(表达式)        {            case 取值1:                执行语句；                break；            case 取值2:                执行语句；                break；            ......            default:                执行语句；                break；        }

三、while循环语句    格式：        while(判断条件){            执行语句；        }

四、do-while循环语句    do{        执行语句；    }while(判断条件)；    注意：do-while语句无论是否符合条件，执行语句都会执行一次；而while循环语句只有符合条件才执行；

五、for循环语句    普通for循环格式：        for(初始化表达式；判断条件表达式；循环后的表达式){            执行语句；        }        注意：初始化表达式中如果定义了一个变量，则该变量在循环结束之后就会死亡    增强for循环格式（javaSE5.0之后出现）：        for(变量类型   变量名 : 需要遍历的目标){        }        注意：            1.作用范围：数组、或实现Iterable接口的集合类            2.底层还是运用了迭代器，增强for循环只是简化了书写

六、break、continue关键字    break关键字：适用于for循环 、 switch两种循环语句。        1.可以单独使用；        2.可以配套使用，例如：break outer        注意：在循环中break关键字后面不能出现语句，否则会报错，因为永远不可能执行到该语句；    continue关键字：适用于while 、 do while 、 for循环语句        1.可以单独使用；        2.可以配套使用，例如：break outer        注意：continue出现在循环的第一条语句，编译会报错，因为后面的语句都无法执行；

数组：

一、数组的定义及初始化：        存储同一种数据类型的集合，其实就是一个容器，它可以自动给里面的元素进行编号，编号从0开始;        定义格式：            格式一：                元素类型[] 数组名 = new 元素类型[元素的个数或者数组长度]；                注意：可以初始化一个长度为0的数组                例如：int[] arr = new int[0];            格式二：                元素类型[] 数组名 = {元素1,元素2,元素3...};                例如：int[] arr = {1,43,45,5,3};            格式三：匿名数组                new 元素类型[]{元素1,元素2,元素3...}        初始化：            方式1：                    元素类型[] 数组名 = new 元素类型[元素的个数或者数组长度]；                数组名[0] = 元素1；                数组名[1] = 元素2；                数组名[2] = 元素3；                ...            方式2：                元素类型[] 数组名 = {元素1,元素2,元素3...};

二、数组类：Arrays        常用的方法：            toString()  遍历数组，返回字符串类型，内部维护了一个StringBuilder的字符串容器，把数组的元素放进字符串容器，在调用StringBuilder的头String方法            sort(数组名, fromIndex, toIndex)       升序排序，无返回值，内部调用了DualPivotQuicksort(没有在文档中找到这个类)的sort方法，可以指定从第几个开始到第几个结束排序            binarySearch(数组名  查找的数组)    二分查找，必须在排好序的前提下查找

三、数组排序        求最大值：            public static void main(String[] args) {                int[] arr = {3,1,5,4,9,6};                int max = arr[0];                for(int i = 1;i<arr.length;i++){                    if(arr[i]>max){                        max = arr[i];                    }                }                System.out.println(max);            }

直接排序：            public static void main(String[] args) {                int[] arr = {3,1,5,4,9,6};                for(int i = 0;i<arr.length-1;i++){                    for(int j = i+1;j<arr.length;j++){                        if(arr[i]>arr[j]){                            int temp = arr[i];                            arr[i] = arr[j];                            arr[j] = temp;                        }                    }                }                System.out.println(Arrays.toString(arr));            }

冒泡排序：相邻的两个进行排序            public static void main(String[] args) {                int[] arr = {3,1,5,4,9,6};                for(int i = 0;i<arr.length-1;i++){                    for(int j = 0;j<arr.length-i-1;j++){                        if(arr[j]>arr[j+1]){                            int temp = arr[j];                            arr[j] = arr[j+1];                            arr[j+1] = temp;                        }                    }                }                System.out.println(Arrays.toString(arr));            }

二分查找法：只对有序数组            public static int binarySerach(int[] arr,int key){                int min = 0;                int max = arr.length-1;                int mid = (min+max)/2;                while(arr[mid]!=key){                    if(arr[mid]>key){                        max = mid;                    }else {                        min = mid;                    }                    mid = (min+max)/2;                }                return mid;            }

数组翻转：            public static void main(String[] args) {                int[] arr = {1, 3, 4, 5, 6, 9,10};                for(int startIndex = 0,endIndex = arr.length-1; startIndex < endIndex ; startIndex ++,endIndex --){                    int temp = arr[startIndex];                    arr[startIndex] = arr[endIndex];                    arr[endIndex] = temp;                }                System.out.println(Arrays.toString(arr));            }

四、数组常见的异常        java.lang.ArrayIndexOutOfBoundsException  //角标越界        java.lang.NullPointerException  //空指针异常

五、数组的内存分析        int[] arr = {1,2,3};            arr是个变量存放在栈内存中，{1，2，3}存放在堆内存中并有一个地址，arr就是通过这个地址在堆内存找到{1，2，3}的            arr[0]就表示arr这个变量通过地址找到数组容器后，在指向该容器的第一个元素

二维数组

一、定义格式及初始化        定义格式：            数组类型[][] 数组名 = new 数组类型[一维数组的个数][每个一维数组的元素的个数]        初始化：            静态初始化：                int[][] arr = new int[][]{{12,34,45,89},{34,56,78,10},{1,3,6,4}};            动态初始化：                int[][] arr = new int[3][4];

二、常用的操作        遍历二维数组：            public static void main(String[] args) {                int[][] arr = new int[][]{{12,34,45,89},{34,56,78,10},{1,3,6,4}};                for(int i = 0;i<arr.length;i++){                    for(int j = 0;j<arr[i].length;j++){                        if(j == 0){                            System.out.print("{"+arr[i][j]+",");                        }else if(j == arr[i].length-1){                            System.out.print(arr[i][j]+"}");                        }else{                            System.out.print(arr[i][j]+",");                        }                    }                }            }

本想把面向对象整理完，整理一半结果大脑不听使唤了，明天继续。。。