Java核心技術卷1掃盲筆記

轉義序列\u

       註釋中不要出現\u，因爲Unicode轉義序列會在解析代碼之前得到處理。

       轉義序列\u和其他轉義序列不同，其他轉義序列，如：\t，\n等只能出現在雙引號之中，而\u可以出現在加引號的字符串外。

java中保留的關鍵字

       const和goto是java中保留的關鍵字。

jdk8新增的join方法

       public static String join(CharSequence delimiter, CharSequence... elements)：delimiter表示分隔符，所有的字符串都實現了CharSequence，這個函數相當於返回一個字符串，這個字符串是根據傳入可變字符串參數，每兩個參數間用分隔符連接起來的。

類型轉換精度問題

       其中藍色線表示不會損失精度，而紅色線表示會損失精度。

       三條紅線的情況，可以看下圖，下圖展示了浮點型(float)數據在計算機中的存儲。

       float的存儲結構是1個符號位，8個指數位，23個尾數。

switch case

       在jdk7中加入了字符串面量。

跳到指定塊的方法

        hello:
        if (x > 0) {
            break hello;
        }

        label:
        while (true) {
            System.out.println("第一層循環...");
            while (true) {
                System.out.println("第二層循環...");
                while (true) {
                    System.out.println("第三層循環...");
                    if (x > 0)
                        break label;
                }
            }
        }

       運行結果：

數組與多維數組

       以下初始化語句是正確的。

        int length = 8;
        int[] b = new int[length];

       輸出一維數組用Arrays.toString，輸出高維數組用Arrays.deepToString。

        for (int i = 0; i < b.length; i++)
            b[i] = i;
        System.out.println(Arrays.toString(b));
        int[][] x = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
        System.out.println(Arrays.deepToString(x));

基於類的訪問權限

       Employee類的方法可以訪問Employee類的任何一個對象的私有域。

	class Employee {
		...
		private String name;
		...
		public boolean equals(Employee other) {
			return name.equals(other.name);
		}
	}

final關鍵字

       1、final用於修飾基本數據類型，表示數據不可再改變。
       2、final用於修飾引用數據類型，變量中的對象引用不會再指向其他對象。

java方法參數的綁定規則

       java總是採用按值調用的，即方法得到的是所有參數指的一個拷貝。只不過如果參數是引用對象的話，拷貝的變量和原變量指向的是一塊內存空間。

       分析下面代碼：

    public static void main(String[] args) {
        Employee a = new Employee("小王", 10000);
        Employee b = new Employee("小李", 13000);
        System.out.println("before do swap... a=" + a + ", b=" + b);
        swap(a, b);
        System.out.println("after do swap... a=" + a + ", b=" + b);
    }

    private static void swap(Employee e1, Employee e2) {
        Employee t = e1;
        e1 = e2;
        e2 = t;
    }

       並不能達到交換對象的目的，這個方法只是交換了對象的拷貝，方法執行完之後，e1和e2會被JVM回收，原來調用方法的a、b對象沒有改變他們所指向的內存空間。

方法重載

       必須是參數類型或者參數數量不同，返回值類型不作數。

靜態導入

       可以導入到方法級別。如：import static java.lang.Math.abs;。

方法調用的底層

方法調用分爲靜態綁定和動態綁定。
       1、靜態綁定：private、static、final
       2、動態綁定：JVM預先爲每個類創建一個方法表(method table)。

訪問修飾符

       1、對本類可見：private。
       2、對本包和所有子類可見：protected。
       3、對所有類可見：public。
       4、對本包可見：默認(缺省)。

Integer包裝類的API

將Integer類型轉換爲String類型，將i轉換爲radix的進制，最後以String返回：String toString(int i, int radix);。
將String類型轉換爲Integer類型，radix指明字符串s所表示的進制數，將其轉爲Integer返回：Integer parseInt(String s, int radix);。

接口中方法的默認實現

       接口中的變量默認都是：public static final。
       接口方法中用default聲明後即可給出默認實現，如：

	public interface Collection {
		int size();
		default boolean isEmpty() {
			return size() == 0;
		}
	}

Objects.equals方法

Objects.equals(Object obj1, Object o2)：
       1、兩個參數都爲null，返回true。
       2、其中一個參數爲null，返回false。
       3、兩個參數都不爲null，調用objq.equals(obj2)。

深拷貝和淺拷貝

本質都是重新new了一塊堆空間。不過兩者也有以下區別：
       淺拷貝：引用類型只是複製引用。
       深拷貝：所有屬性都複製獨立一份。

重寫equals的技巧

       equals爲true的兩個對象，哈希碼必須相同。

       待定。

lambda表達式

       可以將函數式接口或匿名內部類簡化。

		List<String> list = new LinkedList<>();
        list.add("123");
        list.add("234");
        list.add("345");
        list.forEach(string -> {
            System.out.println(string);
        });

泛型

1、類泛型

       class Fanxing<T>，注：尖括號中使用extends關鍵字來對T做限制(不管是接口還是類都是extends)，如果有多個限制，中間用&來分隔，而且如果有繼承的類必須放在第一個位置，而且繼承類的數量也只能有一個。

2、方法泛型

       public static <T> void hello(T t)，泛型參數放在修飾符後面，返回值類型的前面。

3、泛型機制

       “僞泛型”，編譯階段會進行所謂的”類型擦除“，將尖括號中的內容都替換爲具體的類型。

       如果類型擦除之後出現下面的代碼，則會調用橋接方法：

	public Integer info(Integer i) {
		return i;
	}
	public volatile Object info(Object o) {
		return info((Integer)o);
	}

4、泛型注意點

       ① 不能用基本類型實例化類型參數。

       ② 運行時查詢只查原始類型，如：

		FanXing<Employee> fanXing1 = new FanXing<>();
        FanXing<Manager> fanXing2 = new FanXing<>();
        System.out.println("FanXing1: " + fanXing1.getClass() + " , FanXing2: " + fanXing2.getClass());
        System.out.println(fanXing1.getClass() == fanXing2.getClass());

       ③ 不能實例化參數化類型的數組(只能用集合)，也不能實例化類型變量和泛型數組(new出Object的數組之後強轉)。

實例化的時候重寫類的部分方法

新知識！

		Map<String, String> cache = new LinkedHashMap<String, String>(128, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {
                return size() > 100;
            }
        };

       相當於只是將某個類中看的不爽的方法重寫了，應該還是框架和jdk裏面用的多(必須對該類非常熟悉，否則慎用)，自己寫的類玩這種騷操作就離譜。

Map最快的遍歷方法

		map.forEach((k, v) -> {
            System.out.println("key: " + k + "  value: " + v);
        });

迭代器

1、ListIterator API：
       在當前迭代器所在位置前添加元素：void add(E e);。
       替換當前迭代器所在位置的元素：void set(E e);。
       boolean hasNext();。
       返回當前迭代器所在位置的元素，並將迭代器往後挪一個位置：E next();。
       得到當前迭代器所在位置的索引：int nextIndex();。
       boolean hasPrevious();(以下都同next部分)。
       E previous();。
       int previousIndex();。

2、Iterator API：同next部分。

優先隊列

		Queue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;	//增減排序
            }
        });

       遍歷要想下面這樣，而不能直接輸出queue。

		while (!queue.isEmpty()) {
            System.out.print(queue.poll() + " ");
        }

位集的使用

位集可以用來替代布爾數組。

       初始化位集，初始狀態都爲false：BitSet set = new BitSet(100);
       將標記位置置爲true：void set(int index);
       將標記位置置爲false：void clear(int index);
       獲得標記位：boolean get(int index);

Collection的一些API

       計算集合中的最大值：public static max(Collecton<? extends Comparable> c);
       計算集合中的最小值：public static min(Collecton<? extends Comparable> c);
       歸併排序(穩定)：public static sort(List<?> l, Comparator<?> cmp);

List接口的求交集方法

       boolean retainAll(Collection<?> c);