Ganti pernyataan di Java

Bayangkan Anda berdiri di persimpangan jalan, seperti pahlawan dari lukisan terkenal. Jika kamu ke kiri, kamu akan kehilangan kudamu, jika kamu ke kanan, kamu akan mendapat ilmu. Bagaimana memprogram situasi seperti ini? Kemungkinan besar Anda sudah tahu bahwa kami membuat pilihan seperti itu menggunakan konstruksi if-then dan if-then-else .

if (turn_left) {
    System.out.println(«Коня потеряешь»);
}
if (turn_right) {
    System.out.println(“Знания обретёшь”);
}
else
    System.out.println(“Так и будешь стоять?”);

Bagaimana jika tidak ada dua trek seperti itu, tapi 10? Apakah ada jalan “ke kanan”, “sedikit ke kiri”, “sedikit lagi ke kiri” dan seterusnya yang berjumlah 10 buah? Bayangkan bagaimana kode if-then-else Anda akan berkembang di versi ini!

if (вариант1)
{… }
else if (вариант2)
{…}
…
else if (вариантN) ….

Jadi, Anda tidak memiliki satu kondisi fork, tetapi beberapa, katakanlah, 10 (yang penting di sini adalah jumlah fork dibatasi). Untuk situasi seperti itu, ada operator pilihan khusus - switch case java .

switch (ВыражениеДляВыбора) {
           case  (Значение1):
               Код1;
               break;
           case (Значение2):
               Код2;
               break;
...
           case (ЗначениеN):
               КодN;
               break;
           default:
               КодВыбораПоУмолчанию;
               break;
       }

Urutan eksekusi dalam pernyataan tersebut adalah sebagai berikut:

• SelectionExpression dievaluasi. Selanjutnya, pernyataan switch membandingkan ekspresi yang dihasilkan dengan Nilai berikutnya (dalam urutan yang tercantum).
• Jika SelectExpression cocok dengan Nilai, maka kode yang mengikuti titik dua akan dieksekusi.
• Jika konstruksi break ditemukan , maka kontrol ditransfer ke luar perintah switch.
• Jika tidak ditemukan kecocokan antara ExpressionForSelection dan Values, maka kontrol ditransfer ke DefaultSelectionCode.

Poin penting

• Tipe SelectionExpression untuk pernyataan pemilihan saklar di Java harus berupa salah satu dari berikut ini:

  • byte , pendek , char , int .
  • Pembungkusnya adalah Byte , Short , Character , Integer .
  • String (sejak Java 7).
  • Pencacahan ( Enum ).
• Blok default adalah opsional, maka jika SelectionExpression dan Values ​​​​tidak cocok, tidak ada tindakan yang akan dilakukan.
• break bersifat opsional; jika tidak ada, kode akan terus dieksekusi (mengabaikan perbandingan nilai lebih lanjut dalam blok kasus) hingga breakpernyataan switch pertama ditemukan atau hingga akhir.
• jika perlu mengeksekusi kode yang sama untuk beberapa opsi pemilihan, untuk menghindari duplikasi, kami menunjukkan beberapa nilai yang sesuai di depannya dalam blok kasus yang berurutan .

Mari beralih ke praktik penggunaan pernyataan switch di Java

Jangan khawatir, kita sudah selesai dengan teorinya, dan setelah contoh lebih lanjut semuanya akan menjadi lebih jelas. Jadi mari kita mulai. Mari kita lihat contoh ilmu astronomi tentang planet-planet di tata surya. Sesuai dengan peraturan internasional terbaru, kami akan mengecualikan Pluto (karena sifat orbitnya). Ingatlah bahwa planet-planet kita terletak dari Matahari dengan urutan sebagai berikut: Merkurius, Venus, Bumi, Mars, Jupiter, Saturnus, Uranus, dan Neptunus. Mari kita buat metode Java yang menerima masukan nomor seri planet (relatif terhadap jarak dari Matahari), dan sebagai keluaran menghasilkan komposisi utama atmosfer planet ini dalam bentuk Daftar <String> . Izinkan saya mengingatkan Anda bahwa beberapa planet memiliki komposisi atmosfer yang serupa. Jadi, Venus dan Mars sebagian besar mengandung karbon dioksida, Jupiter dan Saturnus terdiri dari hidrogen dan helium, dan Uranus dan Neptunus, selain pasangan gas terakhir, juga mengandung metana. Fungsi kami:

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No Atmosphere");
            break;
        case 2:
        case 4: result.add("Carbon dioxide");
            break;
        case 3: result.add("Carbon dioxide");
            result.add("Nitrogen");
            result.add("Oxygen");
            break;
        case 5:
        case 6: result.add("Hydrogen");
            result.add("Helium");
            break;
        case 7:
        case 8: result.add("Methane");
            result.add("Hydrogen");
            result.add("Helium");
            break;
        default:
            break;
    }
    return result;
}

Harap diperhatikan: kami membandingkan kode yang sama dengan planet dengan komposisi atmosfer yang identik. Dan kami melakukan ini dengan menggunakan konstruksi kasus yang berurutan . Jadi, jika kita ingin mendapatkan komposisi atmosfer planet asal kita, kita memanggil metode kita dengan parameter 3:

getPlanetAtmosphere(3).
System.out.println(getPlanetAtmosphere(3)) вернет нам [Углекислый газ, Азот, Кислород].

Bereksperimenlah dengan break Apa yang terjadi jika kita menghapus semua pernyataan break ? Mari kita coba praktiknya:

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No Atmosphere");
        case 2:
        case 4: result.add("Carbon dioxide");
        case 3: result.add("Carbon dioxide");
            result.add("Nitrogen");
            result.add("Oxygen");
        case 5:
        case 6: result.add("Hydrogen");
            result.add("Helium");
        case 7:
        case 8: result.add("Methane");
            result.add("Hydrogen");
            result.add("Helium");
        default:
    }
    return result;
}

Jika kita mencetak hasil dari metode tersebut System.out.println(getPlanetAtmosphere(3)), maka planet asal kita tidak akan begitu cocok untuk kehidupan. Atau cocok? Nilailah sendiri: [Karbon dioksida, Nitrogen, Oksigen, Hidrogen, Helium, Metana, Hidrogen, Helium], Mengapa ini bisa terjadi? Program mengeksekusi semua kasus setelah pertandingan pertama dan sampai akhir blok saklar.

Istirahat pengoptimalan yang berlebihan

Perhatikan bahwa kita dapat meningkatkan metode ini dengan pengaturan arahan break dan opsi pemilihan yang berbeda

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No Atmosphere");
                break;
        case 3: result.add("Nitrogen");
                result.add("Oxygen");
        case 2:
        case 4: result.add("Carbon dioxide");
                break;
        case 7:
        case 8: result.add("Methane");
        case 5:
        case 6: result.add("Hydrogen");
                result.add("Helium");
    }
     return result;
}

Terlihat lebih pendek, bukan? Kami mengurangi jumlah total pernyataan dengan bermain-main dengan urutan kasus dan mengelompokkan kembali. Sekarang setiap jenis gas ditambahkan ke daftar hanya dalam satu baris kode. Daftar contoh terakhir dari metode ini ditampilkan hanya untuk mendemonstrasikan pekerjaan; sangat tidak disarankan untuk menulis dengan gaya seperti itu. Jika pembuat (dan terlebih lagi pemrogram pihak ketiga) dari kode serupa harus memeliharanya, maka akan sangat sulit untuk mengembalikan logika pembentukan blok pilihan dan kode yang dapat dieksekusi untuk pernyataan java switch.

Perbedaan dari jika

Meskipun pernyataan if dan switch memiliki tampilan yang mirip , jangan lupa bahwa operator pilihan ganda switch mendasarkan pilihan opsi eksekusi pada NILAI KHUSUS, sedangkan pada if. dapat berupa ekspresi logis apa pun. Pertimbangkan fakta ini saat mendesain kode Anda. Mari kita lihat lebih dekat inovasi switch di berbagai versi Java.

Beralih di Java 7

Sebelum Java 7, primitif byte, short, char dan int dapat digunakan sebagai nilai untuk switch. Ada juga dukungan untuk enum dan wrapper dari tipe primitif yang tercantum di atas: Karakter, Byte, Pendek, dan Integer. Namun seringkali kita perlu menemukan nilai string switch java! Ini adalah apa yang akan terlihat seperti di Java 6:

DayOfWeek day = DayOfWeek.fromValue("Thursday");

switch (day) {
  case MONDAY:
     System.out.println("Today is windy !");
     break;
  case THURSDAY:
     System.out.println("Today is sunny !");
     break;
  case WEDNESDAY:
     System.out.println("Today is rainy!");
     break;
  default:
     System.out.println("Oooops, something wrong !");

Dan enum:

public enum DayOfWeek {
  MONDAY("Monday"),
  THURSDAY("Thursday"),
  WEDNESDAY("Wednesday"),
  NOT_FOUND("Not found");

  private final String value;

  DayOfWeek(final String value) {
     this.value = value;
  }

  public static DayOfWeek fromValue(String value) {
     for (final DayOfWeek dayOfWeek : values()) {
        if (dayOfWeek.value.equalsIgnoreCase(value)) {
           return dayOfWeek;
        }
     }
     return NOT_FOUND;
  }
}

Namun mulai dari Java 7, tipe String dapat digunakan sebagai nilai untuk switch:

String day = "Thursday";

switch (day) {
  case "Monday":
     System.out.println("Today is windy !");
     break;
  case "Thursday":
     System.out.println("Today is sunny !");
     break;
  case "Wednesday":
     System.out.println("Today is rainy!");
     break;
  default:
     System.out.println("Oooops, something wrong !");
}

Meskipun ada fitur baru, pendekatan menggunakan enum lebih fleksibel dan direkomendasikan untuk digunakan: kita dapat menggunakan kembali enum ini berkali-kali.

Beralih di Java 12

Java 12 telah meningkatkan ekspresi Switch untuk pencocokan pola. Jika kita menggunakan Switch seperti pada contoh di atas, untuk menetapkan nilai suatu variabel, kita harus menghitung nilainya dan menetapkannya ke variabel tertentu, lalu menggunakan break:

int count = 2;
int value;
switch (count) {
  case 1:
     value = 12;
     break;
  case 2:
     value = 32;
     break;
  case 3:
     value = 52;
     break;
  default:
     value = 0;
}

Namun berkat kemampuan Java 12, kita dapat menulis ulang ekspresi ini sebagai berikut:

int value = switch (count) {
  case 1:
     break 12;
  case 2:
     break 32;
  case 3:
     break 52;
  default:
     break 0;
};

Mari kita bahas sedikit perubahannya:

1. Jika sebelumnya kita menetapkan nilai variabel di dalam blok case, karena pernyataan switch itu sendiri tidak dapat mengembalikan apa pun, sekarang kita memiliki kesempatan seperti itu, dan kita langsung mengembalikan nilai tersebut menggunakan switch.

2. Sebelumnya, kita tidak bisa lagi memiliki apapun di sebelah kanan break, tapi sekarang kita menggunakannya sebagai pernyataan return untuk mengembalikan nilai switch kita. Tanda titik dua menandai titik masuk ke dalam blok pernyataan. Artinya, sejak saat itu, eksekusi semua kode di bawah ini dimulai, bahkan ketika label lain ditemukan.

   Hasilnya adalah transisi ujung ke ujung dari satu tanda ke tanda lainnya, yang juga disebut kegagalan .

Untuk menyelesaikan lintasan seperti itu, Anda harus melewati semua elemen secara lengkap, atau menggunakan break atau return. Inovasi di Java 12 memberi kita kemampuan untuk menggunakan operator lambda, yang pada gilirannya memastikan bahwa hanya kode di sebelah kanannya yang akan dieksekusi. Tanpa ada “kegagalan”. Seperti apa contoh sebelumnya dalam kasus ini:

int count = 2;
int value = switch (count) {
  case 1 -> 12;
  case 2 -> 32;
  case 3 -> 52;
  default -> 0;
};

Kodenya menjadi lebih sederhana, bukan? Dan satu hal lagi: operator lambda juga dapat berfungsi sebagai analog khas dari titik dua, setelah itu ada seluruh blok dengan beberapa operasi:

int count = 2;
int value = switch (count) {
  case 1 -> {
     //some computational operations...
     break 12;
  }
  case 2 -> {
     //some computational operations...
     break 32;
  }
  case 3 -> {
     //some computational operations...
     break 52;
  }
  default -> {
     //some computational operations...
     break 0;
  }
};

Nah, bagaimana jika untuk beberapa kasus nilai kembaliannya sama? Ternyata kita sebenarnya mempunyai kasus yang sama untuk beberapa nilai yang berbeda. Berikut cara mempersingkatnya menggunakan fitur baru di Java 12:

int count = 2;
int value = switch (count) {
  case 1, 3, 5 -> 12;
  case 2, 4, 6 -> 52;
  default -> 0;
};

Beralih di Java 13

Di Java 13, cara switch mengembalikan nilai telah berubah. Jika di java 12 kita menulis nilai kembalian setelah break, yang berfungsi sebagai pengembalian bagi kita untuk blok switch, sekarang kita akan mengembalikan nilai tersebut menggunakan kata yield . Mari lihat:

int value = switch (count) {
  case 1:
     yield 12;
  case 2:
     yield 32;
  case 3:
     yield 52;
  default:
     yield 0;
};

Pada saat yang sama, kode yang ditulis di Java 12 menggunakan break untuk kembali tidak akan dikompilasi (( Break akan digunakan, tetapi dalam situasi di mana kita tidak perlu mengembalikan apa pun.

Total

• Gunakan pernyataan case ketika ada lebih dari dua cabang untuk menghindari kekacauan kode Anda dengan struktur if.
• Jangan lupa untuk mengakhiri blok logis dari setiap cabang yang sesuai dengan nilai tertentu (blok kasus) dengan break call .
• Selain beberapa tipe primitif, pernyataan switch juga dapat menggunakan tipe Enum dan String sebagai ekspresi .
• Ingat blok default - gunakan untuk menangani nilai pilihan yang tidak direncanakan.
• Untuk mengoptimalkan performa, pindahkan cabang kode dengan pilihan paling umum ke awal blok switch.
• Jangan terbawa oleh "optimasi" dengan menghilangkan jeda di akhir blok pemilihan kasus - kode seperti itu sulit untuk dipahami, dan akibatnya, sulit untuk dipertahankan selama pengembangannya.