反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射詳情 - 數據結構,java,intellij idea,jvm,System,Spark,大數據香奈兒博客

文章目錄

字符串常量池

創建對象的思考
字符串常量池(StringTable)
再談String對象創建
intern方法

反射

定義
用途
反射基本信息
反射相關的類
Class類中的相關方法
反射示例
反射優點和缺點

枚舉的使用

使用
枚舉優點缺點
枚舉和反射

Lambda表達式

背景

Lambda表達式的語法
函數式接口

Lambda表達式的基本使用
變量捕獲
Lambda在集合當中的使用

Collection接口
List接口
Map接口

總結

字符串常量池

創建對象的思考

下面兩種創建String對象的方式相同嗎？

public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s3 == s4); // false
}

上述程序創建方式類似，為什麼s1和s2引用的是同一個對象，而s3和s4不是呢？
在Java程序中，類似於：1， 2， 3，3.14，“hello”等字面類型的常量經常頻繁使用，為了使程序的運行速度更快、更節省內存，Java為8種基本數據類型和String類都提供了常量池。
“池” 是編程中的一種常見的, 重要的提升效率的方式, 我們會在未來的學習中遇到各種 “內存池”, “線程池”, “數據庫連接池” …

為了節省存儲空間以及程序的運行效率，Java中引入了：

Class文件常量池：每個.Java源文件編譯後生成.Class文件中會保存當前類中的字面常量以及符號信息
運行時常量池：在.Class文件被加載時，.Class文件中的常量池被加載到內存中稱為運行時常量池，運行時常量池每個類都有一份
字符串常量池

字符串常量池(StringTable)

字符串常量池在JVM中是StringTable類，實際是一個固定大小的HashTable(一種高效用來進行查找的數據結構，後序給大家詳細介紹)，不同JDK版本下字符串常量池的位置以及默認大小是不同的：

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#java

再談String對象創建

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_System_02

當創建對象時，對象之間的關係大致如圖所示

結論：只要是new的對象，都是唯一的。

通過上面例子可以看出：使用常量串創建String類型對象的效率更高，而且更節省空間。用户也可以將創建的字符串對象通過 intern 方式添加進字符串常量池中。

intern方法

public static void main(String[] args) {
        char[]  chars= {'a','b','c'};
        String s1 = new String(chars);
        //s1.intern();
        String s2 = "abc";
        System.out.println(s1==s2);
    }

intern 是一個native方法(Native方法指：底層使用C++實現的，看不到其實現的源代碼)，該方法的作用是手動將創建的String對象添加到常量池中。

反射

定義

Java的反射（reflection）機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性，既然能拿到那麼，我們就以修改部分類型信息；這種動態獲取信息以及動態調用對象方法的功能稱為java語言的反射（reflection）機制。

用途

在日常的第三方應用開發過程中，經常會遇到某個類的某個成員變量、方法或是屬性是私有的或是隻對系統應用開放，這時候就可以利用Java的反射機制通過反射來獲取所需的私有成員或是方法。
反射最重要的用途就是開發各種通用框架，比如在spring中，我們將所有的類Bean交給spring容器管理，無論是XML配置Bean還是註解配置，當我們從容器中獲取Bean來依賴注入時，容器會讀取配置，而配置中給的就是類的信息，spring根據這些信息，需要創建那些Bean，spring就動態的創建這些類。

反射基本信息

Java程序中許多對象在運行時會出現兩種類型：運行時類型(RTTI)和編譯時類型，例如Person p = newStudent()；這句代碼中p在編譯時類型為Person，運行時類型為Student。程序需要在運行時發現對象和類的真實信息。而通過使用反射程序就能判斷出該對象和類屬於哪些類。

反射相關的類

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#jvm_03

Class類中的相關方法

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#數據結構_04

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_System_05

獲得類中構造方法相關的方法：

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#數據結構_06

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_System_07

反射示例

在反射之前，我們需要做的第一步就是先拿到當前需要反射的類的Class對象，然後通過Class對象的核心方法，達到反射的目的，即：在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性，既然能拿到那麼，我們就可以修改部分類型信息。

第一種，使用 Class.forName(“類的全路徑名”); 靜態方法。
前提：已明確類的全路徑名。
第二種，使用 .class 方法。
説明：僅適合在編譯前就已經明確要操作的 Class
第三種，使用類對象的 getClass() 方法

public static void main1(String[] args) throws ClassNotFoundException {

        try{
            Class<Student> c1 = Student.class;
            System.out.println(c1);

            Student s = new Student();
            Class<? extends Student> c2 = s.getClass();
            System.out.println(c2);

            Class<?> c3 = null;
            c3 = Class.forName("refelcetdemo.Student");
            System.out.println(c3);
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }
    }

注意過程中會涉及異常問題，需要解決一下。

public static void main(String[] args) {
        try {
            Class<?> c1 = Class.forName("refelcetdemo.Student");
            Method method =
                    c1.getDeclaredMethod("function", String.class);
            method.setAccessible(true);
            Student student = (Student) c1.newInstance();
            method.invoke(student,"調用成功");
        }catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main4(String[] args) {
        try {
            Class<?> c1 = Class.forName("refelcetdemo.Student");
            Field field = c1.getField("age");
            field.setAccessible(true);
            Student student = (Student) c1.newInstance();
            field.set(student,9);
            System.out.println(student);
        }catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main3(String[] args) {
        try {
            Class<?> c1 = Class.forName("refelcetdemo.Student");
            Constructor<Student> constructor =
                    (Constructor<Student>) c1.getDeclaredConstructor(String.class,int.class );
            constructor.setAccessible(true);
            Student student = constructor.newInstance("小明",6);
            System.out.println(student);
        }catch (ClassNotFoundException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    public static void main2(String[] args) {
        try{
            Class<?> c1 = Class.forName("refelcetdemo.Student");
            Student student = (Student) c1.newInstance();
            System.out.println(c1);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

這一部分是使用反射得到目標類，並且通過特定的方法分別得到目標類中的構造器，私有對象，私有方法。並且修改其中的變量的值。

反射優點和缺點

優點：

對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法
增加程序的靈活性和擴展性，降低耦合性，提高自適應能力
反射已經運用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺點：

使用反射會有效率問題。會導致程序效率降低。
反射技術繞過了源代碼的技術，因而會帶來維護問題。反射代碼比相應的直接代碼更復雜。

枚舉的使用

枚舉是在JDK1.5以後引入的。主要用途是：將一組常量組織起來，在這之前表示一組常量通常使用定義常量的方式：

public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;

但是常量舉例有不好的地方，例如：可能碰巧有個數字1，但是他有可能誤會為是RED，現在我們可以直接用枚舉來進行組織，這樣一來，就擁有了類型，枚舉類型。而不是普通的整形1.

public enum TestEnum {
RED,BLACK,GREEN;
}

優點：將常量組織起來統一進行管理
場景：錯誤狀態碼，消息類型，顏色的劃分，狀態機等等…
本質：是 java.lang.Enum 的子類，也就是説，自己寫的枚舉類，就算沒有顯示的繼承 Enum ，但是其默認繼承了這個類。

使用

switch語句

public enum TestEnum {
RED,BLACK,GREEN,WHITE;
public static void main(String[] args) {
TestEnum testEnum2 = TestEnum.BLACK;
switch (testEnum2) {
case RED:
System.out.println("red");
break;
case BLACK:
System.out.println("black");
break;
case WHITE:
System.out.println("WHITE");
break;
case GREEN:
System.out.println("black");
break;
default:
break;
}
}
}

常用方法：

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#java_08

public static void main(String[] args) {
        testEnum[] enums = testEnum.values();
       for (testEnum anEnum : enums) {
           System.out.println(anEnum.ordinal());
        }

        System.out.println(RED.compareTo(BLACK));
        testEnum testEnum = enumdemo.testEnum.valueOf("heihei");
        System.out.println(testEnum);

    }

補充知識：
1、當枚舉對象有參數後，需要提供相應的構造函數
2、枚舉的構造函數默認是私有的這個一定要記住

RED("red",0),BLACK("black",1),GREEN("green",2),WHITE("white",3);

    private String name;
    private int key;
    /**
     * 1、當枚舉對象有參數後，需要提供相應的構造函數
     * 2、枚舉的構造函數默認是私有的 這個一定要記住
     * @param name
     * @param key
     */
    private testEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }

枚舉優點缺點

優點：

枚舉常量更簡單安全。
枚舉具有內置方法，代碼更優雅

缺點：

不可繼承，無法擴展

枚舉和反射

不能通過反射來獲取枚舉的構造。

原因是newInstance()函數中把枚舉自動過濾了。

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#jvm_09

Lambda表達式

背景

Lambda表達式是Java SE 8中一個重要的新特性。lambda表達式允許你通過表達式來代替功能接口。 lambda表達式就和方法一樣,它提供了一個正常的參數列表和一個使用這些參數的主體(body,可以是一個表達式或一個代碼塊)。 Lambda 表達式（Lambda expression），基於數學中的λ演算得名，也可稱為閉包（Closure）。

Lambda表達式的語法

基本語法: (parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表達式由三部分組成：

paramaters：類似方法中的形參列表，這裏的參數是函數式接口裏的參數。這裏的參數類型可以明確的聲明也可不聲明而由JVM隱含的推斷。另外當只有一個推斷類型時可以省略掉圓括號。
->：可理解為“被用於”的意思
方法體：可以是表達式也可以代碼塊，是函數式接口裏方法的實現。代碼塊可返回一個值或者什麼都不反回，這裏的代碼塊塊等同於方法的方法體。如果是表達式，也可以返回一個值或者什麼都不反回。

// 1. 不需要參數,返回值為 2
() -> 2
// 2. 接收一個參數(數字類型),返回其2倍的值
x -> 2 * x
// 3. 接受2個參數(數字),並返回他們的和
(x, y) -> x + y
// 4. 接收2個int型整數,返回他們的乘積
(int x, int y) -> x * y
// 5. 接受一個 string 對象,並在控制枱打印,不返回任何值(看起來像是返回void)
(String s) -> System.out.print(s)

函數式接口

要了解Lambda表達式,首先需要了解什麼是函數式接口，函數式接口定義：一個接口有且只有一個抽象方法。
注意：

如果一個接口只有一個抽象方法，那麼該接口就是一個函數式接口
如果我們在某個接口上聲明瞭 @FunctionalInterface 註解，那麼編譯器就會按照函數式接口的定義來要求該接口，這樣如果有兩個抽象方法，程序編譯就會報錯的。所以，從某種意義上來説，只要你保證你的接口中只有一個抽象方法，你可以不加這個註解。加上就會自動進行檢測的。

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#jvm_10

但是有這樣一種特殊情況：
JDK1.8新特性，default默認方法可以有具體的實現

反射、枚舉以及lambda表達式_枚舉類為什麼不能被反射_#jvm_11

Lambda表達式的基本使用

特點：語法精簡
1. 參數類型可以省略，如果需要省略，每個參數的類型都要省略。
2. 參數的小括號裏面只有一個參數，那麼小括號可以省略
3. 如果方法體當中只有一句代碼，那麼大括號可以省略
4. 如果方法體中只有一條語句，且是return語句，那麼大括號可以省略，且去掉return關鍵字

public static void main2(String[] args) {
        NoParameterReturn noParameterReturn = () -> 10;
        System.out.println(noParameterReturn.test());
        OneParameterReturn oneParameterReturn = a-> a;
        System.out.println(oneParameterReturn.test(10));
        MoreParameterReturn moreParameterReturn = (a,b) -> a+b;
        System.out.println(moreParameterReturn.test(10,20));
    }
    public static void main1(String[] args) {
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
            @Override
            public void test(){
                System.out.println("測試");
            }
        };
        noParameterNoReturn.test();
        NoParameterNoReturn noParameterNoReturn1 = ()->System.out.println("測試2");
        noParameterNoReturn1.test();
        OneParameterNoReturn oneParameterNoReturn = a-> System.out.println(a);
        oneParameterNoReturn.test(10);
        MoreParameterNoReturn moreParameterNoReturn = (a,b) -> System.out.println(a+b);
        moreParameterNoReturn.test(1,2);
    }

public static void main3(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        });

        PriorityQueue<Integer> priorityQueue1 =
                new PriorityQueue<>((o1,o2)->o1.compareTo(o2));

    }

變量捕獲

public static void main(String[] args) {
        int count = 10;
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {
            System.out.println(count);
            System.out.println(a+b);
        };

        //count = 99;
    }

在上述代碼當中的變量count就是，捕獲的變量。這個變量要麼是被final修飾，如果不是被final修飾的你要保證在使用之前，沒有修改。

Lambda在集合當中的使用

Collection接口

forEach() 方法演示
該方法在接口 Iterable 當中，原型如下：

default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}

該方法表示：對容器中的每個元素執行action指定的動作。

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
list.add("bit");
list.add("hello");
list.add("lambda");
list.forEach(new Consumer<String>(){
@Override
public void accept(String str){
//簡單遍歷集合中的元素。
System.out.print(str+" ");
}
});
}

輸出結果：Hello bit hello lambda
我們可以修改為如下代碼：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.forEach(str -> System.out.println(str+" "));

    }

List接口

sort()方法的演示
sort方法源碼：該方法根據c指定的比較規則對容器元素進行排序。

public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
list.add("bit");
list.add("hello");
list.add("lambda");
list.sort(new Comparator<String>() {
@Override
public int compare(String str1, String str2){
//注意這裏比較長度
return str1.length()-str2.length();
}
});
System.out.println(list);
}

修改之後：

public static void main6(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.sort(
                (str1,str2)-> str1.length() - str2.length()
        );
        System.out.println(list);
    }

Map接口

HashMap 的 forEach()
該方法原型如下：

default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}

作用是對Map中的每個映射執行action指定的操作。
代碼示例：

public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1, "hello");
map.put(2, "bit");
map.put(3, "hello");
map.put(4, "lambda");
map.forEach(new BiConsumer<Integer, String>(){
@Override
public void accept(Integer k, String v){
System.out.println(k + "=" + v);
}
});
}

輸出結果：
1=hello 2=bit 3=hello 4=lambda
使用lambda表達式後的代碼：

public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach((k,v)-> System.out.println(k + "=" + v));
    }

總結

Lambda表達式的優點很明顯，在代碼層次上來説，使代碼變得非常的簡潔。缺點也很明顯，代碼不易讀。
優點：

代碼簡潔，開發迅速
方便函數式編程
非常容易進行並行計算
Java 引入 Lambda，改善了集合操作

缺點：

代碼可讀性變差
在非並行計算中，很多計算未必有傳統的 for 性能要高
不容易進行調試

本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。

香奈兒博客

香奈兒博客

博客 / 詳情