Javaでよく見られる12個の文法糖

67118 ワード
Java SE
必ず前を向いて
前にJavaの基礎を勉強していたとき、文法の砂糖関係をこまごまと見て、今日記録しました.
switch
  • switch
  • 元コード
    public class tesst{
    public static void main(String[] args) {
        String string = "world";
        switch (string){
            case "hello":
                System.out.println(string);
                break;
            case "world":
                System.out.println(string);
                break;
            default:
                break;
        }
    }
}
  • コンパイル後のコード
    public class tesst {
    public static void main(String[] args) {
        String string;
        String string2 = string = "world";
        int n = -1;
        switch (string2.hashCode()) {
            case 99162322: {
                if (!string2.equals("hello")) break;
                n = 0;
                break;
            }
            case 113318802: {
                if (!string2.equals("world")) break;
                n = 1;
            }
        }
        switch (n) {
            case 0: {
                System.out.println(string);
                break;
            }
            case 1: {
                System.out.println(string);
                break;
            }
        }
    }
}
  • 文字列はhashを先に行う必要があり、hash衝突を防ぐためにequals
    • が追加されていることがわかります.
  • の前にアリ妹は公衆番号に5つの問題を出しました.そのうちの1つはこうです.
    public class SwitchTest {
    public static void main(String[] args) {
        String param = null;
        switch (param) {
            case "null":
                System.out.println("null");
                break;
            default:
                System.out.println("default");
        }
    }
}
    という問題には3つの選択肢があります.1つはnullを出力することです.1つはdefaultを歩くことです.最後の1つは間違いを報告することです.構文糖により,switchではhashCodeの値を比較したが,null.hashCode()では空ポインタ異常
    • が自然に爆発することが分かった.
    forEach
  • 元のコード
    public class ForEach {
    public static void main(String[] args) {
        String[] s = {"fxxk","suger","fxxk","java"};
        for (String s1 : s) {
            System.out.println(s1);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}
  • コンパイル後のコード
    public class ForEach{
    public ForEach(){
    }

    public static void main(String args[]){
        String s[] = {
            "fxxk", "suger", "fxxk", "java"
        };
        String args1[] = s;
        int j = args1.length;
        for(int k = 0; k < j; k++){
            String s1 = args1[k];
            System.out.println(s1);
        }

        List list = new ArrayList();
        for(int i = 0; i < 10; i++)
            list.add(Integer.valueOf(i));

        Integer integer;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(integer))
            
            integer = (Integer)iterator.next();
    }
}
  • から分かるように、集合クラスによって反復器によって増強forサイクルが実現され、Stringは通常のforサイクルによって増強forサイクルが実現される.また、反復器を使用しているので、foreachでは遍歴するしかなく、修正できないことに注意する必要があります.そうでないとjava.util.ConcurrentModificationException異常
    • が爆発する
    lambda
  • lambda
  • 元コード
    import java.util.ArrayList;
import java.util.List;
public class Lambda {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.forEach(System.out::println);
    }
}
  • コンパイル後コード
    import java.io.PrintStream;
import java.lang.invoke.LambdaMetafactory;
import java.util.ArrayList;
import java.util.function.Consumer;

public class Lambda {
    public static void main(String[] arrstring) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 0; i < 10; ++i) {
            arrayList.add(i);
        }
        
        PrintStream printStream = System.out;
        printStream.getClass();
        
        arrayList.forEach(
            (Consumer<Integer>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, println(java.lang.Object ), (Ljava/lang/Integer;)V)((PrintStream)printStream));
    }

}
  • 私たちはlambdaと内部クラスの違いを見ることができて、内部クラスは複数のクラスファイルを生成して、lambdaは1つのクラスファイルの中で、最大で複数の方法を生成します
    • if
  • オリジナルファイル
        public static void main(String[] args) {
        if (true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        if (false){
            System.out.println("false");
        }else{
            System.out.println(false);
        }

    }
  • コンパイルされたファイル
        public static void main(String args[])
    {
        System.out.println("true");
        System.out.println(false);
    }
    • enum
  • オリジナルファイル
    public enum EnumClass {
    SPRING,SUMMER,FALL,WINTER;
}
  • コンパイルファイル
    public final class EnumClass extends Enum
{

    public static EnumClass[] values()
    {
        return (EnumClass[])$VALUES.clone();
    }

    public static EnumClass valueOf(String name)
    {
        return (EnumClass)Enum.valueOf(suger/EnumClass, name);
    }

    private EnumClass(String s, int i)
    {
        super(s, i);
    }

    public static final EnumClass SPRING;
    public static final EnumClass SUMMER;
    public static final EnumClass FALL;
    public static final EnumClass WINTER;
    private static final EnumClass $VALUES[];

    static 
    {
        SPRING = new EnumClass("SPRING", 0);
        SUMMER = new EnumClass("SUMMER", 1);
        FALL = new EnumClass("FALL", 2);
        WINTER = new EnumClass("WINTER", 3);
        $VALUES = (new EnumClass[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

    public static final Enum SPRING;
    public static final Enum SUMMER;
    public static final Enum FALL;
    public static final Enum WINTER;
    private static final Enum $VALUES[];

    static 
    {
        SPRING = new Enum("SPRING", 0);
        SUMMER = new Enum("SUMMER", 1);
        FALL = new Enum("FALL", 2);
        WINTER = new Enum("WINTER", 3);
        $VALUES = (new Enum[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}
  • 列挙はEnumクラスを継承していると同時にfinalであり、継承できないことがわかります.

    • tryWithResource
  • ソースコード
    public class TryWith {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new                   FileReader("d:\\TryWith.jad"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • コンパイル後のコード
    public class TryWith
{
    public TryWith()
    {
    }
    public static void main(String args[])
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader("d:TryWith.jad"));
            String line;
            try
            {
                while((line = br.readLine()) != null) 
                    System.out.println(line);
            }
            catch(Throwable throwable)
            {
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
                throw throwable;
            }
            br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}
  • コンパイラが
    • を閉じてくれたことがわかります
    assert
  • 元コード
    public class Assert {
    public static void main(String[] args) {
        int a = 1;
        assert a > 0;
        System.out.println(a);
    }
}
  • コンパイルコード
    public class Assert
{

    public Assert()
    {
    }

    public static void main(String args[])
    {
        int a = 1;
        if(!$assertionsDisabled && a <= 0)
        {
            throw new AssertionError();
        } else
        {
            System.out.println(a);
            return;
        }
    }

    static final boolean $assertionsDisabled = !suger/Assert.desiredAssertionStatus();

}
  • if文によって
    • が実行されると断言することがわかります.
    のびパラメータ
  • 元コード
    public class Long {
    public static void main(String... args) {
        String[] zi = {"i","am","zi","10ng"};
        ma(zi);
    }

    private static void ma(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}
  • コンパイル後
    public class Long{
    public Long(){
    }

    public static transient void main(String args[]){
        String zi[] = {"i", "am", "zi", "10ng"};
        ma(zi);
    }

    private static transient void ma(String args[]){
        String as[] = args;
        int i = as.length;
        for(int j = 0; j < i; j++){
            String arg = as[j];
            System.out.println(arg);
        }
    }
    • じどうとりはずしばこ
  • 自動着脱箱
  • 元コード
        public static void main(String[] args) {
        int a = 1;
        Integer b;
        b  = a;
        a = b;
    }
  • コンパイル後
        public static void main(String args[])
    {
        int a = 1;
        Integer b = Integer.valueOf(a);
        a = b.intValue();
    }
  • 同時に、JDK 5の後、Integerの操作にメモリを節約し、パフォーマンスを向上させるための新しい機能が導入されたことを知る必要があります.すなわち、整数オブジェクトは、同じオブジェクトリファレンスを使用することによってキャッシュと再利用を実現する.整数値区間-128から+127に適用されます.

    • 汎用型
  • 汎用
  • ソースコード
    public class Generic extends Pair<String>{
    private String first;
    @Override
    public void setFirst(String first) {
        this.first = first;
    }
}
class Pair<T>{
    private T first;
    private T second;

    Pair() {
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}
  • コンパイル後のコード
    public class Generic extends Pair{
    private String first;
	public Generic()    {
    }
    public void setFirst(String first)    {
        this.first = first;
    }
    public volatile void setFirst(Object obj)   {
        setFirst((String)obj);
    }
    public volatile void setSecond(Object obj)    {
        super.setSecond(obj);
    }
    public volatile Object getSecond()    {
        return super.getSecond();
    }
    public volatile Object getFirst()    {
        return super.getFirst();
    }
}
class Pair{
    Pair(){
    }
    public Pair(Object first, Object second)    {
        this.first = first;
        this.second = second;
    }
    public Object getFirst()    {
        return first;
    }
    public void setFirst(Object first)    {
        this.first = first;
    }
    public Object getSecond()    {
        return second;
    }
    public void setSecond(Object second)   {
        this.second = second;
    }
    private Object first;
    private Object second;
}
  • ここで継承するブリッジ方法
    • に注意する.
  • 同時に、タイプ消去によるエラーを知る必要があります.詳細は、汎用
    • を参照してください.
    内部クラス
  • 内部クラス
    • マルチステート
  • マルチステート
  • 元コード
    class GrandFather{
    private int a;
    GrandFather() {
        a = 10;
    }
    public GrandFather method() {
        System.out.println("--------  GrandFather method()  ");
        return new GrandFather();
    }
}
//  
class Father extends GrandFather {
    private int b;
    Father() {
        b = 20;
    }
    @Override
    public Father method() {
        System.out.println("--------  Father method()  ");
        return new Father();
    }
}
  • コンパイラコンパイル後のFatherクラス:
    class Father extends GrandFather
{
	private int b;
    Father(){
        b = 20;
    }
    public Father method(){
        System.out.println("--------\u8C03\u7528Father method()\u65B9\u6CD5");
        return new Father();
    }
    public volatile GrandFather method(){
        return method();
    }
}
    • Elasticsearchインストールと基本操作 for ubuntu
    Java異常分類及び統一処理