JAVASE基礎回顧總結（二）

JAVASE基礎回顧總結（二）

1.運算符：
（1）面試題：s+=1 不等價於：s=s+1;而是等價於s=（s的數據類型）s+1;
（2）面試題：&和&&（|和||）區別：結果相同，但是&&（||）是短路運算；

2.選擇結構if和switch如何選擇？
（1）if的使用場景：

• 針對結果是boolean類型的判斷；因爲switch（byte、short、int、char、String、枚舉）只能判斷這幾種類型；
• 針對一個範圍的判斷；
• 針對幾個常量值的判斷；

（2）switch的使用場景：

• 針對幾個常量值的判斷；

3.（1）求和思想：

• 定義兩個變量，一個變量用於存儲第一個加數，第一個加數實際上保存的是以前的所有數據和，默認初始值爲0；

• 一個變量用於存儲加數，這個變量其實就是每次數據變化的值；

4.for循環和while循環的區別：
（1）如果你想在循環結束後繼續使用控制條件的那個變量，用while循環，否則使用for循環；
（2）不知道選什麼時就用for循環，因爲變量及早的從內存中消失，提高了內存使用效率；
（3）如果是一個範圍的用for循環非常明確；如果循環次數不明確的使用while循環較爲合適；

5.控制跳轉語句：
（1）break:（中斷）：①在switch語句中；②在循環語句中，跳出當前循環（循環語句中加入if判斷的情況）③離開上面兩個場景使用無意義；
（2）continue：（繼續）：①在循環語句中，跳出本次循環，繼續下次循環；
（3）return：（退出方法）：結束一個方法，跳轉到上層調用該方法的地方，return後面的語句不執行；

6.方法的思想：
（1）方法不調用不執行；
（2）方法之間是平級關係，不能嵌套定義；

7.數組：
（1）定義：存儲同一種數據類型的多個元素的容器或集合；
（2）定義格式：（此時數組還未初始化，不能使用）

• ①數據類型 [] 數組名；
• ②數據類型 數組名[];

（3）數組的初始化：

• 定義：所謂初始化就是爲數組中的數組元素分配內存空間，併爲每個數組元素賦值；

• 初始化格式：
  ①動態初始化：初始化時只指定數組的長度，由系統爲數組分配初始值；
  數據類型 [] 數組名 = new 數據類型[數組長度]；（數組長度即數組中元素個數）
  舉例：int [] arr1 = new int [3]; arr[0] = 1;arr[1] = 1; arr[2] = 1;

  ②靜態初始化：初始化時指定每個元素的初始值，由系統決定數組長度；
  格式：數據類型 [] 數組名 = new 數據類型[]{值1，值2，…}
  舉例：int [] arr2 = new int[]{1,2,3}
  簡化格式：數據類型 [] 數組名 = {值1，值2，…}
  舉例：int [] arr2 ={1,2,3}

  ②錯誤始化化：靜態和動態初始化一起使用：
  格式：數據類型 [] 數組名 = new 數據類型[數組長度]{值1，值2，…}
  舉例：int [] arr2 = new int[3]{1,2,3}

（4）數組的遍歷：
①方式一：使用for循環和數組的length屬性；

（5）數組的一些操作：

①獲取數組最大值：（參考代碼如下）：

/*
    數組獲取最值(獲取數組中的最大值最小值)

        分析：
        A:定義一個數組，並對數組的元素進行靜態初始化。
        B:從數組中任意的找一個元素作爲參照物(一般取第一個),默認它就是最大值。
        C:然後遍歷其他的元素，依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。
        D:最後參照物裏面保存的就是最大值。
*/
public class ArrayMax {
    public static void main(String[] args) {
        int arr[] = {12,56,23,21,98,14,13,100};
        System.out.println(new ArrayMax().getArrayMax(arr));

    }

    public int getArrayMax(int[] arr) {
        int max = arr[0];
        for(int i=1; i<arr.length; i++){
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

②數組元素逆序 （參考代碼如下：兩種方式）

/*
 * 實現：數組元素逆序 (就是把元素對調)
 */
public class ArrayReverse {
public static void main(String[] args) {
    int[] arr = {1,45,32,21,67};
    //new ArrayReverse().reverseArrayOne(arr);
    new ArrayReverse().reverseArrayTwo(arr);
    for(int i=0; i<arr.length;i++){
        System.out.print(arr[i]+" ");
    }
}

/*
 * 實現一：
 *  數組元素逆序 (就是把元素對調)

        分析：
            A:定義一個數組，並進行靜態初始化。
            B:思路
                把0索引和arr.length-1的數據交換
                把1索引和arr.length-2的數據交換
                ...
                只要做到arr.length/2的時候即可。
 * 
 */
public void reverseArrayOne(int[] arr) {
    int tmp;
    for(int i=0; i<arr.length/2;i++){
        tmp = arr[i];
        arr[i] = arr[arr.length-1-i];
        arr[arr.length-1-i] = tmp;

    }
}

public void reverseArrayTwo(int[] arr) {
    int tmp;
    for(int start=0,end=arr.length-1; start<end;start++,end--){
        tmp = arr[start];
        arr[start] = arr[end];
        arr[end] = tmp;

    }
}
}

③實訓數組操作總結:

package com.utils;
/**
 * 數組相關的操作:
 * @author 任志燕 
 * 2017年6月20日
 *
 */
public class ArrayTest {
    /**
     * 插入排序(元素是int型的)
     * @param beforeInsertArr:int[] 排好序的數組
     * @param afterInsertArr:int[] 插入後的數組，需要定義，且需要聲明長度(eg:int[] afterInsertArr = new int[beforeInsertArr+1])
     * @param type:String 取值只有兩個:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
     * @param num:int 待插入的數據
     * @return void
     */
    public static void insertNum(int[] beforeInsertArr,int[] afterInsertArr,String type,int num) {
        //1.將插入前的數組的值賦給插入後數組
        for (int i = 0; i < beforeInsertArr.length; i++) {
            afterInsertArr[i] = beforeInsertArr[i];
        }
        //2.默認插入數字的位置是插入後數組的最後一個位置
        int index = beforeInsertArr.length;
        //3.找插入字符的位置
        for (int i = 0; i < beforeInsertArr.length; i++) {
            if ("asc".equals(type)) {
                if (num < beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }else if ("desc".equals(type)) {
                if (num > beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }
        }
        //4.將插入字符位置以後的元素後移
        for (int i = afterInsertArr.length-1; i > index; i--) {
            afterInsertArr[i] = afterInsertArr[i-1];
        }
        afterInsertArr[index] = num;
    }

    /**
     * 插入排序(元素是char型的)
     * @param beforeInsertArr:char[] 排好序的數組
     * @param afterInsertArr:char[] 插入後的數組，需要定義，且需要聲明長度(eg:char[] afterInsertArr = new char[beforeInsertArr+1])
     * @param type:String 取值只有兩個:asc(升序)或desc(降序),指明beforeInsertArr的排序方式
     * @param :character char 待插入的數據
     * @return void
     */
    public static void insertChar(char[] beforeInsertArr,char[] afterInsertArr,String type,char character) {
        for (int i = 0; i < beforeInsertArr.length; i++) {
            afterInsertArr[i] = beforeInsertArr[i];
        }
        int index = beforeInsertArr.length;
        for (int i = 0; i < beforeInsertArr.length; i++) {
            if ("asc".equals(type)) {
                if (character < beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }else if ("desc".equals(type)) {
                if (character > beforeInsertArr[i]) {
                    index = i;
                    break;
                }
            }
        }
        for (int i = afterInsertArr.length-1; i > index; i--) {
            afterInsertArr[i] = afterInsertArr[i-1];
        }
        afterInsertArr[index] = character;
    }
    /**
     * 求數組中元素最大值
     * 
     * @param arrNum int[]
     * @return int
     */
    public static int getMax(int[] arrNum) {
        int max = arrNum[0];
        for (int i = 1; i < arrNum.length; i++) {
            if (max < arrNum[i]) {
                max = arrNum[i];
            }
        }
        return max;
    }

    /**
     * 求數組中元素最小值
     * 
     * @param arrNum int[]
     * @return int
     */
    public static int getMin(int[] arrNum) {
        int min = arrNum[0];
        for (int i = 1; i < arrNum.length; i++) {
            if (min > arrNum[i]) {
                min = arrNum[i];
            }
        }
        return min;
    }

    /**
     * 冒泡排序(升序排列)
     * @param arr int[] 
     * @return void
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    /**
     * 冒泡排序(降序排列)
     * @param arr int[] 
     * @return void
     */
    public static void bubbleSort2(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] < arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    /**
     * 逆序打印數組元素
     * @param arr
     * @return void
     */
    public static void reversePrint(int[] arr) {
        for (int i = arr.length-1; i >= 0; i--) {
            System.out.print(arr[i]+" ");
        }
    }


    public static void main(String[] args) {
        int[] arr = {10,20,5,64,32};
        reversePrint(arr);

    }

}

8.java參數傳遞：
（1）java中的參數傳遞全是值傳遞；
（2）基本類型：形式參數的改變對實際參數沒影響；
（3）引用類型：形式參數的改變直接影響實際參數；