摘要：三元操作符類型的轉(zhuǎn)換規(guī)則若兩個(gè)操作數(shù)不可轉(zhuǎn)換，則不做轉(zhuǎn)換，返回值為類型。若兩個(gè)操作數(shù)都是直接量數(shù)字，則返回值類型為范圍較大者。

(1)若兩個(gè)操作數(shù)不可轉(zhuǎn)換，則不做轉(zhuǎn)換，返回值為Object類型。
(2)若兩個(gè)操作數(shù)是明確類型的表達(dá)式(比如變量)，則按照正常的二進(jìn)制數(shù)字來轉(zhuǎn)換，int類型轉(zhuǎn)換為long類型，long類型轉(zhuǎn)換為float類型等。
(3)若兩個(gè)操作數(shù)中有一個(gè)數(shù)字S，另外一個(gè)是表達(dá)式，且其類型標(biāo)示為T，那么，若數(shù)字S在T的范圍內(nèi)，則轉(zhuǎn)換為T類型；若S超出T類型的范圍，則T轉(zhuǎn)換為S類型。
(4)若兩個(gè)操作數(shù)都是直接量數(shù)字，則返回值類型為范圍較大者。

示例代碼：

    @Test
    public void test() {
        int i = 80;
        String s1 = String.valueOf(i < 100 ? 90 : 100);
        String s2 = String.valueOf(i < 100 ? 90 : 100.0);
        System.out.println("s1=" + s1);
        System.out.println("s2=" + s2);
    }

結(jié)果：

s1=90
s2=90.0

結(jié)論：三元操作符的類型務(wù)必一致

clone方法提供的是一種淺拷貝方式，也就是說它并不會(huì)把對象的所有屬性全部拷貝一份，而是選擇性的拷貝，它的拷貝規(guī)則如下：
(1)基本變量：如果變量是基本類型，則拷貝其值，比如int、float等
(2)對象：如果變量是一個(gè)實(shí)例對象，則拷貝地址引用，也就是說此時(shí)新拷貝出來的對象與原有對象共享改實(shí)例變量，不受訪問權(quán)限的控制。
(3)String字符串：這個(gè)比較特殊，拷貝的也是一個(gè)地址，是個(gè)引用，但是在修改時(shí)，它會(huì)從字符串池中重新生成新的字符串，原有的字符串對象保持不變，在此處我們可以認(rèn)為String是一個(gè)基本類型

示例代碼：

    @Test
    public void test() {
        //定義父親
        Person father = new Person("父親");
        //定義大兒子
        Person s1 = new Person("大兒子", father);
        //小兒子的信息是通過大兒子拷貝過來的
        Person s2 = s1.clone();
        s2.setName("小兒子");
        System.out.println(s1.getName() + " 的父親是 " + s1.getFather().getName());
        System.out.println(s2.getName() + " 的父親是 " + s2.getFather().getName());
        s1.getFather().setName("干爹");
        System.out.println(s1.getName() + " 的父親是 " + s1.getFather().getName());
        System.out.println(s2.getName() + " 的父親是 " + s2.getFather().getName());
    }

輔助類：

class Person implements Cloneable {
    //姓名
    private String name;
    //父親
    private Person father;

    public Person(String _name) {
        name = _name;
    }

    public Person(String _name, Person _parent) {
        name = _name;
        father = _parent;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person getFather() {
        return father;
    }

    public void setFather(Person father) {
        this.father = father;
    }

    //拷貝的實(shí)現(xiàn)
    @Override
    public Person clone() {
        Person p = null;
        try {
            //淺拷貝
            p = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }
}

結(jié)果：

大兒子 的父親是 父親
小兒子 的父親是 父親
大兒子 的父親是 干爹
小兒子 的父親是 干爹

結(jié)論：淺拷貝只是Java提供的一種簡單拷貝機(jī)制，不便于直接使用

創(chuàng)建一個(gè)字符串時(shí)，首先檢查池中是否有字面值相等的字符串，如果有，則不再創(chuàng)建，直接返回池中該對象的引用，若沒有則創(chuàng)建之，然后放到池里，并返回新創(chuàng)建對象的引用。

示例代碼：

    @Test
    public void test(){
        String str1 = "中國";
        String str2 = "中國";
        String str3 = new String("中國");
        String str4 = str3.intern();
        //兩個(gè)直接量是否相等
        boolean b1 = (str1 == str2);
        //直接量和對象是否相等
        //直接聲明一個(gè)String對象(new String)是不會(huì)檢查字符串池的，也不會(huì)把對象放到池里
        boolean b2 = (str1 == str3);
        //經(jīng)過intern處理后的對象與直接量是否相等
        //intern會(huì)檢查當(dāng)前的對象在對象池(自己理解：字符串池)中是否有字面值相同的引用對象，如果有則返回池中對象，如果沒有則放置到對象池中，并返回當(dāng)前對象
        boolean b3 = (str1 == str4);
        System.out.println(b1);    
        System.out.println(b2);    
        System.out.println(b3);    
    }

結(jié)果：

true
false
true

結(jié)論：推薦使用String直接量賦值

(1)String類是final類，不可繼承，不可能產(chǎn)生一個(gè)String子類
(2)在String類提供的所有方法中，如果有String返回值，就會(huì)新建一個(gè)String對象，不對原對象進(jìn)行修改，這也保證了元對象是不可改變的。

(1)使用String類的場景：在字符串不經(jīng)常變化的場景中可以使用String類，例如常量的聲明、少量的變量運(yùn)算等。
(2)使用StringBuffer類的場景：在頻繁進(jìn)行字符串的運(yùn)算(如拼接、替換、刪除等)，并且運(yùn)行在多線程的環(huán)境中，則可以考慮使用StringBuffer，例如XML解析、HTTP參數(shù)解析和封裝等。
(3)使用StringBuilder類的場景：在頻繁進(jìn)行字符串的運(yùn)算(如拼接、替換、刪除等)，并且運(yùn)行在單線程的環(huán)境中，則可以考慮使用StringBuilder，如SQL語句的拼裝、JSON封裝等。

在使用加號進(jìn)行計(jì)算的表達(dá)式中，只要遇到String字符串，則所有的數(shù)據(jù)都會(huì)轉(zhuǎn)成String類型進(jìn)行拼接，如果是原始數(shù)據(jù)，則直接拼接，如果是對象，則調(diào)用toString方法的返回值然后拼接

示例代碼：

    @Test
    public void test(){
        String str1 = 1 + 2 + " apples";
        String str2 = "apples:" + 1 + 2;
        System.out.println(str1);    
        System.out.println(str2);    
    }

結(jié)果：

3 apples
apples:12

結(jié)論：在"+"表達(dá)式中，String字符串具有最高優(yōu)先級

ArrayList：

插入：只要插入一個(gè)元素，其后的元素就會(huì)向后移動(dòng)一位，雖然arrayCopy是一個(gè)本地方法，效率非常高，
    但頻繁的插入，每次后面的元素都要拷貝一遍，效率就變低了，特別是在頭位置插入元素時(shí)。
刪除：index位置后的元素都要向前移動(dòng)一位，最后一個(gè)位置空出來了，這又是一次數(shù)組拷貝，和插入一樣，
    如果數(shù)據(jù)量大，刪除動(dòng)作必然會(huì)暴露出性能和效率方面的問題。
修改：直接替換

LinkedList：

插入：把自己插入到鏈表，然后再把前節(jié)點(diǎn)的next和后節(jié)點(diǎn)的previous指向自己。
刪除：沒有任何耗時(shí)的操作，全部是引用指針的變更，效率自然高了。
修改：定位方式會(huì)折半遍歷，這是一個(gè)極耗時(shí)的操作。

總結(jié)：

LinkedList的插入效率比ArrayList快50倍以上。
LinkedList在處理大批量的刪除動(dòng)作時(shí)比ArrayList快40倍以上。
修改元素，在這一點(diǎn)上LinkedList輸給了ArrayList

結(jié)論：頻繁插入和刪除時(shí)使用LinkedList

它返回的SubList類也是AbstractList的子類，其所以的方法如get、set、add、remove等都是在原始列表上的操作，它自身并沒有生成一個(gè)數(shù)組或是鏈表，也就是子列表只是原列表的一個(gè)視圖，所有的修改動(dòng)作都反映在了原始列表上。

示例代碼：

    @Test
    public void test(){
        //定義一個(gè)包含兩個(gè)字符串的列表
        List list = new ArrayList<>(2);
        list.add("A");
        list.add("B");
        //構(gòu)造一個(gè)包含list列表的字符串列表
        List list2 = new ArrayList<>(list);
        System.out.println("list == list2? " + list.equals(list2));    
        //subList生成與list相同的列表
        List list3 = list.subList(0, list.size());
        //list3增加一個(gè)元素
        list3.add("C");
        System.out.println("list == list2? " + list.equals(list2));    
        System.out.println("list == list3? " + list.equals(list3));    
        System.out.println(list.size());    
    }

結(jié)果：

list == list2? true
list == list2? false
list == list3? true
3

結(jié)論：subList產(chǎn)生的列表只是一個(gè)視圖，所有的修改動(dòng)作直接作用于原列表

(1)List、List、List擦除后的類型為List。
(2)List[] 擦除后的類型為List[].
(3)List、List擦除后的類型為List。
(4)List擦除后為List。

(1)無構(gòu)造函數(shù)：Class對象是在加載類時(shí)由Java虛擬機(jī)通過調(diào)用類加載器中的defineClass方法自動(dòng)構(gòu)造的。
(2)可以描述基本類型：例如可以使用int.class表示int表示類型的類對象
(3)其對象都是單例模式：一個(gè)Class的實(shí)例可以描述一個(gè)類，并且只描述一個(gè)類，反過來也成立，一個(gè)類只有一個(gè)Class實(shí)例對象

示例代碼：

    @Test
    public void test() {
        //類的屬性class所引用的對象與實(shí)例對象的getClass返回值相同
        System.out.println(String.class.equals(new String("").getClass()));
        System.out.println("ABC".getClass().equals(String.class));
        //class實(shí)例對象不區(qū)分泛型
        System.out.println(ArrayList.class.equals(new ArrayList().getClass()));
    }

結(jié)果：

true
true
true

(1)類屬性方式，如String.class
(2)對象的getClass方法，如new String().getClass()
(3)forName方法加載，如Class.forName("java.lang.String")

getMethod方法獲得的是所以public訪問級別的方法，包括從父類繼承的方法
getDeclareMethod方法獲得的是自身類的所有方法，包括public、private方法，而且不受限于訪問權(quán)限

示例代碼：

    @Test
    public void test() throws NoSuchMethodException {
        //方法名稱
        String methodName = "doStuff";
        Method m1 = Foo.class.getDeclaredMethod(methodName);
        Method m2 = Foo.class.getMethod(methodName);    //Exception in thread "main" java.lang.NoSuchMethodException
    }
    //靜態(tài)內(nèi)部類
    static class Foo{
        void doStuff(){}
    }

結(jié)果：

java.lang.NoSuchMethodException

結(jié)論：適時(shí)選擇getDeclaredXXX和getXXX