String Array sa Java

Kadalasan ang unang istraktura ng data na nakikilala ng isang baguhan na programmer ay isang array. Iyon ay dahil ang mga array ay medyo madaling matutunan. Ang isang-dimensional na array ay isang sequence na binubuo ng isang nakapirming bilang ng mga cell kung saan maaaring maimbak ang data. Sa kaso ng wikang Java, maaari kang mag-imbak lamang ng isang uri ng data sa isang array. Sa madaling salita, ang mga array sa Java ay homogenous. Ang mga array cell ay maaaring maglaman ng mga bagay sa anumang uri. Maaari kang maglagay ng mga bagay ng anumang uri, primitive o object, sa isang array. Ngayon ay titingnan natin ang mga string array sa Java language, iyon ay, arrays, ang bawat elemento nito ay isang string. Aalamin natin kung paano ideklara ang Java String Array at kung paano ito gagawin.

Paano magdeklara at magpasimula ng String Array

Maaari mong ideklara at simulan ang isang String array sa Java sa iba't ibang paraan. Halimbawa tulad ng sa code sa ibaba:

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

Dito muna namin idedeklara ang isang variable myArray ng uri String[] . Pagkatapos, sinisimulan namin ang array na may tatlong value ng string na nakapaloob sa mga kulot na brace. Bilang kahalili, maaari kang magkaroon ng String array declaration at initialization sa magkahiwalay na linya:

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

Narito mayroon kaming parehong resulta tulad ng unang snippet ng code ngunit paghiwalayin ang deklarasyon at pagsisimula sa dalawang hakbang. Gayundin, maaari mong simulan ang isang array na may sukat lamang, tulad ng dito sa ibaba:

String[] myArray = new String[5];

Dito ka lumikha ng String array at tukuyin ang laki ng String Array, ngunit hindi ka nagbibigay ng anumang mga paunang halaga. Pagkatapos ay maaari kang magtalaga ng mga halaga sa array gamit ang isang loop o sa pamamagitan ng pagtukoy sa mga halaga nang paisa-isa. Tandaan na sa lahat ng kaso, kailangan mong tukuyin ang uri ng array (sa kasong ito, String ) habang ipinapahayag ang variable.

Paano umulit sa pamamagitan ng String array

Sa Java maaari kang umulit sa pamamagitan ng isang String array gamit ang isang loop. Ito ay maaaring para sa o isang foreach construction. Magkaroon tayo ng isang halimbawa na gumagamit ng parehong uri ng mga loop:

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();
    }
}

Dito muna tayo lumikha ng String array na pinangalanang stringArray na may apat na elemento (String musical instruments). Pagkatapos, ang parehong mga loop ay umulit sa bawat elemento ng string array at i-print ito sa console. Ang foreach loop ay isang mas maigsi na paraan ng pag-ulit sa pamamagitan ng isang array, ngunit ang for loop ay maaaring maging kapaki-pakinabang kung kailangan mong i-access ang index ng bawat elemento. Ang output ng programang ito ay:

Paano magdagdag ng bagong elemento sa Array

Hindi ka maaaring magdagdag ng isang bagong elemento sa isang array sa Java. Gayunpaman ang Java ay may mga espesyal na trick para dito. Kung mayroon kang array ng mga string at kailangan mong magdagdag ng bagong string sa dulo ng iyong array, gamitin ang Arrays.copyOf method. Lumilikha ang paraang ito ng bagong array na may isang dagdag na elemento, at pagkatapos ay idaragdag ang bagong elemento sa dulo ng bagong array. Narito ang isang halimbawa:

//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;

Dito ang Arrays.copyOf method ay lumilikha ng bagong array na pinangalanang newArray na may haba ng isa na mas malaki kaysa sa oldArray. Ang pamamaraan ay nagdaragdag ng newElement sa dulo ng newArray sa pamamagitan ng pagtatalaga nito sa huling elemento ng newArray . Ang mga array sa Java ay may nakapirming haba, kaya hindi ka makakapagdagdag o makapag-alis ng mga elemento mula sa isang array kapag nagawa na ito. Upang dynamic na magdagdag o mag-alis ng mga elemento mula sa isang koleksyon, mas mabuting gumamit ka ng isa pang istraktura ng data. Halimbawa, isang Listahan o isang Mapa .

Paano ayusin ang mga elemento sa String Array

Oo naman, kung interesado ka sa mahusay na mga pagsasanay sa programming, maaari mong isulat ang iyong algorithm ng pag-uuri para sa pamamaraan ng pag-uuri. Gayunpaman, sa mga tunay na gawaing nagtatrabaho, mas madaling gamitin ang paraan ng Arrays.sort() . Narito ang isang halimbawa:

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 + " ");
        }
    }
}

Dito muna tayo lumikha ng String array na pinangalanang stringArray na may apat na elemento. Pagkatapos ay tinawag namin ang Arrays.sort() na paraan upang pagbukud-bukurin ang mga elemento sa array sa pataas na pagkakasunud-sunod. Sa wakas, inuulit namin ang pinagsunod-sunod na array gamit ang para sa bawat loop at i-print ang bawat elemento sa console. Ang output ng program na ito ay susunod: Tulad ng nakikita mo, pinagsunod-sunod ng pamamaraan ang mga elemento sa stringArray ayon sa alpabeto.

Paano maghanap ng partikular na String sa String array

Upang maghanap ng kinakailangang String sa isang String array sa Java, maaari kang gumamit ng loop para sa pag-ulit sa bawat elemento ng array at ihambing ito sa String na iyong hinahanap. Narito ang isang halimbawang programa:

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;
       }
}

Narito kami ay lumilikha ng isang paraan na may dalawang argumento, isang array at isang string na makikita. Lumilikha kami ng boolean na 'nahanap' upang subaybayan kung nakita namin ang String . Ito ang nahanap na halaga na ibabalik ng pamamaraan. Pagkatapos ay gumamit kami ng para sa bawat loop upang umulit sa bawat elemento ng array. Ginagamit namin ang equals() na pamamaraan sa loop upang ihambing ang kasalukuyang elemento sa string ng paghahanap. Kung makakahanap ng tugma ang pamamaraan, itinakda namin ito sa true at ginagamit ang pahayag ng break para maagang lumabas sa loop. Sa wakas, nai-print namin ang resulta depende sa kung ang natagpuan ay totoo o mali. Sa pangunahing pamamaraan, tinatawag namin ang paraan ng paghahanap nang dalawang beses, kasama ang String na nasa array at ang isa na wala. Ang output ng program na ito ay susunod:

Paano i-convert ang String Array sa String

Maaari mong gamitin ang String.join() na paraan upang i-convert ang isang String array sa String sa Java. Ang pamamaraang ito ay nagbabalik ng isang string na pinagsama ng ibinigay na delimiter. Ang delimiter ay kinopya para sa bawat elemento sa String join() method. Narito ang isang halimbawa:

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

Ang output ay ang mga sumusunod: Una, idedeklara namin ang isang string array myArray na may tatlong halaga ng string. Pagkatapos ay gagamitin namin ang String.join() na paraan upang pagsamahin ang lahat ng elemento ng array sa isang string. Ang unang argumento sa String.join() ay ang delimiter na gusto mong gamitin sa pagitan ng bawat elemento ng array. Ginamit namin ang "," (isang kuwit na sinusundan ng isang puwang) bilang delimiter. Ang pangalawang argumento ay ang array na gusto mong samahan. Sa wakas, itinalaga namin ang nagresultang String sa variable na joinedString at i-print ito sa console.