String Array dalam Java

Selalunya struktur data pertama yang dikenali oleh pengaturcara baru ialah tatasusunan. Itu kerana tatasusunan agak mudah dipelajari. Tatasusunan satu dimensi ialah jujukan yang terdiri daripada bilangan sel tetap di mana data boleh disimpan. Dalam kes bahasa Java, anda boleh menyimpan hanya satu jenis data dalam tatasusunan. Dengan kata lain, tatasusunan dalam Java adalah homogen. Sel tatasusunan boleh mengandungi objek dalam apa jua jenis. Anda boleh meletakkan objek dari sebarang jenis, primitif atau objek, ke dalam tatasusunan. Hari ini kita akan melihat tatasusunan rentetan dalam bahasa Java, iaitu tatasusunan, setiap elemennya ialah rentetan. Kami akan memikirkan cara untuk mengisytiharkan Java String Array dan cara bekerja dengannya.

Bagaimana untuk mengisytiharkan dan memulakan Array String

Anda boleh mengisytiharkan dan memulakan tatasusunan String dalam Java dengan cara yang berbeza. Contohnya seperti dalam kod di bawah:

String[] myArray = {"value1", "value2", "value3"};

Di sini kita mula-mula mengisytiharkan pembolehubah myArray jenis String[] . Kemudian, kami memulakan tatasusunan dengan tiga nilai rentetan yang disertakan dalam pendakap kerinting. Sebagai alternatif, anda boleh mempunyai pengisytiharan tatasusunan String dan permulaan pada baris berasingan:

String[] myArray; // String array declaration
myArray = new String[] {"value1", "value2", "value3"}; // initialize the array

Di sini kita mempunyai hasil yang sama seperti coretan kod pertama tetapi memisahkan pengisytiharan dan permulaan kepada dua langkah. Selain itu, anda boleh memulakan tatasusunan dengan saiz sahaja, seperti di sini di bawah:

String[] myArray = new String[5];

Di sini anda mencipta tatasusunan String dan menentukan saiz Tatasusunan String , tetapi anda tidak memberikan sebarang nilai awal. Anda kemudiannya boleh menetapkan nilai kepada tatasusunan menggunakan gelung atau dengan menentukan nilai secara individu. Ambil perhatian bahawa dalam semua kes, anda perlu menentukan jenis tatasusunan (dalam kes ini, String ) semasa mengisytiharkan pembolehubah.

Bagaimana untuk lelaran melalui tatasusunan String

Di Java, anda boleh lelaran melalui tatasusunan String menggunakan gelung. Ia mungkin untuk atau pembinaan foreach. Mari kita dapatkan contoh yang menggunakan kedua-dua jenis gelung:

public class IterateStringArrayExample {
    public static void main(String[] args) {
        String[] stringArray = {"violin", "viola", "cello", "double bass"};

        // Using a for loop
        for (int i = 0; i < stringArray.length; i++) {
            String s = stringArray[i];
            System.out.print(s + " ");
        }
        System.out.println();

        // Using a foreach loop
        for (String s : stringArray) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

Di sini kita mula-mula mencipta tatasusunan String bernama stringArray dengan empat elemen (alat muzik String). Kemudian, kedua-dua gelung berulang melalui setiap elemen tatasusunan rentetan dan mencetaknya ke konsol. Gelung foreach ialah cara yang lebih ringkas untuk lelaran melalui tatasusunan, tetapi gelung for boleh berguna jika anda perlu mengakses indeks setiap elemen. Output program ini ialah:

Bagaimana untuk menambah elemen baharu pada Array

Anda tidak boleh hanya menambah elemen baharu pada tatasusunan dalam Java. Walau bagaimanapun Java mempunyai helah khas untuknya. Jika anda mempunyai tatasusunan rentetan dan perlu menambah rentetan baharu pada penghujung tatasusunan anda, gunakan kaedah Arrays.copyOf . Kaedah ini mencipta tatasusunan baharu dengan satu elemen tambahan, dan kemudian menambah elemen baharu pada penghujung tatasusunan baharu. Berikut ialah contoh:

//add string Array and a new element
String[] oldArray = {"violin", "viola", "cello"};
String newElement = "double bass";
String[] newArray = Arrays.copyOf(oldArray, oldArray.length + 1);
newArray[newArray.length - 1] = newElement;

Di sini kaedah Arrays.copyOf mencipta tatasusunan baharu bernama newArray dengan panjang satu lebih besar daripada oldArray. Kaedah ini menambah newElement pada penghujung newArray dengan memberikannya kepada elemen terakhir newArray . Tatasusunan dalam Java mempunyai panjang tetap, jadi anda tidak boleh menambah atau mengalih keluar elemen daripada tatasusunan setelah ia dibuat. Untuk menambah atau mengalih keluar elemen secara dinamik daripada koleksi, lebih baik anda menggunakan struktur data lain. Contohnya, Senarai atau Peta .

Bagaimana untuk mengisih elemen dalam String Array

Sudah tentu, jika anda berminat dengan latihan pengaturcaraan yang baik, anda boleh menulis algoritma pengisihan anda untuk prosedur pengisihan. Walau bagaimanapun, dalam tugasan kerja sebenar adalah lebih mudah untuk menggunakan kaedah Arrays.sort() . Berikut ialah contoh:

import java.util.Arrays;

public class SortStringArrayExample {
    public static void main(String[] args) {
        String[] stringArray = {"violin", "viola", "cello", "double bass"};

        // Sorting the array
        Arrays.sort(stringArray);

        // Printing the sorted array
        for (String s : stringArray) {
            System.out.print(s + " ");
        }
    }
}

Di sini kita mula-mula mencipta tatasusunan String bernama stringArray dengan empat elemen. Kami kemudian memanggil kaedah Arrays.sort() untuk mengisih elemen dalam tatasusunan dalam tertib menaik. Akhir sekali, kami mengulangi tatasusunan yang diisih menggunakan gelung untuk setiap dan mencetak setiap elemen ke konsol. Output program ini adalah seterusnya: Seperti yang anda lihat, kaedah mengisih unsur dalam stringArray mengikut abjad.

Bagaimana untuk mencari String tertentu dalam tatasusunan String

Untuk mencari String yang diperlukan dalam Tatasusunan String di Jawa, anda boleh menggunakan gelung untuk melelaran melalui setiap elemen tatasusunan dan membandingkannya dengan String yang anda cari. Berikut ialah contoh program:

public class SearchString {

       public static void main(String[] args) {
           String[] stringArray = {"violin", "viola", "cello", "double bass"};
           String searchString1 = "cello";
           String searchString2 = "piano";
           search(stringArray, searchString1);
           search(stringArray, searchString2);

       }
          public static boolean search (String[] myArray, String myString){

           boolean found = false;

           // Loop through the array to search for the string
           for (String s : myArray) {
               if (s.equals(myString)) {
                   found = true;
                   break;
               }
           }

           // Print the result
           if (found) {
               System.out.println(myString + " found in the array.");
           } else {
               System.out.println(myString + " not found in the array.");
           } return found;
       }
}

Di sini kita sedang mencipta kaedah dengan dua hujah, tatasusunan dan rentetan untuk ditemui. Kami mencipta 'ditemui' boolean untuk menjejaki sama ada kami menjumpai String . Ia adalah nilai yang ditemui bahawa kaedah itu akan kembali. Kami kemudiannya menggunakan satu gelung untuk setiap untuk mengulangi setiap elemen tatasusunan. Kami menggunakan kaedah equals() dalam gelung untuk membandingkan elemen semasa dengan rentetan carian. Jika kaedah itu menemui padanan, kami menetapkannya kepada benar dan menggunakan pernyataan putus untuk keluar dari gelung lebih awal. Akhir sekali, kami mencetak keputusan bergantung pada sama ada yang ditemui adalah benar atau palsu. Dalam kaedah utama , kami memanggil kaedah carian dua kali, dengan String yang ada dalam tatasusunan dan yang tidak. Output program ini adalah seterusnya:

Bagaimana untuk menukar Array String kepada String

Anda boleh menggunakan kaedah String.join() untuk menukar tatasusunan String kepada String dalam Java. Kaedah ini mengembalikan rentetan yang digabungkan oleh pembatas yang diberikan. Pembatas disalin untuk setiap elemen dalam kaedah String join() . Berikut ialah contoh:

String[] myArray = {"value1", "value2", "value3"};
String joinedString = String.join(", ", myArray);
System.out.println(joinedString);

Outputnya adalah seperti berikut: Pertama, kami mengisytiharkan tatasusunan rentetan myArray dengan tiga nilai rentetan. Kami kemudian menggunakan kaedah String.join() untuk menggabungkan semua elemen tatasusunan ke dalam satu rentetan. Argumen pertama untuk String.join() ialah pembatas yang anda mahu gunakan antara setiap elemen tatasusunan. Kami telah menggunakan "," (koma diikuti dengan ruang) sebagai pembatas. Argumen kedua ialah tatasusunan yang anda mahu sertai. Akhir sekali, kami menetapkan String yang terhasil kepada pembolehubah joinedString dan mencetaknya ke konsol.