String class sa Java

Ang String class sa Java ay idinisenyo upang gumana sa mga string sa Java. Ang lahat ng string literal na tinukoy sa isang Java program (halimbawa, "abc") ay mga instance ng String class. Tingnan natin ang mga pangunahing katangian nito:

1. Ang klase ay nagpapatupad ng Serializableat mga interface CharSequence. Dahil kasama ito sa package java.lang, hindi na ito kailangang i-import.
2. Ang String class sa Java ay isang panghuling klase at hindi maaaring magkaroon ng mga anak.
3. Ang String class ay isang hindi nababagong klase, ibig sabihin, ang mga object nito ay hindi na mababago pagkatapos nilang gawin. Anumang mga operasyon sa isang String object na magreresulta sa isang object ng String class ay magreresulta sa paglikha ng isang bagong object.
4. Dahil sa kanilang immutability, ang String class objects ay thread safe at maaaring gamitin sa isang multi-threaded na kapaligiran.
5. Ang bawat bagay sa Java ay maaaring ma-convert sa isang string sa pamamagitan ng isang pamamaraan toStringna ang lahat ng mga klase ng Java ay minana mula sa klase Object.

Paggawa gamit ang Java String

Ito ay isa sa mga pinakakaraniwang ginagamit na klase sa Java. Mayroon itong mga pamamaraan para sa pagsusuri ng ilang mga character sa isang string, para sa paghahambing at paghahanap ng mga string, pagkuha ng mga substring, paglikha ng isang kopya ng isang string na ang lahat ng mga character ay na-convert sa lower at upper case, at iba pa. Ang isang listahan ng lahat ng mga pamamaraan ng String class ay matatagpuan sa opisyal na dokumentasyon . Ang Java ay nagpapatupad din ng isang simpleng mekanismo para sa concatenation (pagkonekta ng mga string), pag-convert ng mga primitive sa isang string at vice versa. Tingnan natin ang ilang halimbawa ng pagtatrabaho sa String class sa Java.

Paglikha ng Strings

Ang pinakamadaling paraan upang lumikha ng isang instance ng String class ay ang italaga dito ang halaga ng isang string literal:

String s = "I love movies";

Gayunpaman, ang String class ay may maraming mga constructor na nagbibigay-daan sa iyo na:

• lumikha ng isang bagay na naglalaman ng isang walang laman na string
• lumikha ng kopya ng string variable
• lumikha ng isang string batay sa isang array ng character
• lumikha ng isang string batay sa isang byte array (isinasaalang-alang ang mga pag-encode)
• atbp.

Pagdaragdag ng string

Ang pagdaragdag ng dalawang string sa Java ay medyo simple gamit ang +. Binibigyang-daan ka ng Java na magdagdag ng parehong mga variable at string literal sa bawat isa:

public static void main(String[] args) {
    String day = "Day";
    String and = "And";
    String night = "Night";

    String dayAndNight = day + " " + and + " " + night;
}

Sa pamamagitan ng pagdaragdag ng mga object ng String class na may mga object ng ibang klase, binabawasan namin ang huli sa string form. Ang pag-convert ng mga bagay ng iba pang mga klase sa isang representasyon ng string ay ginagawa sa pamamagitan ng isang implicit method na tawag toStringsa object. Ipakita natin ito sa sumusunod na halimbawa:

public class StringExamples {
    public static void main(String[] args) {
        Human max = new Human("Max");
        String out = "java object: " + max;
        System.out.println(out);
        // Output: Java object: Person named Max
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

Paghahambing ng string

Upang ihambing ang mga string, maaari mong gamitin ang pamamaraan equals():

public static void main(String[] args) {
    String x = "Test String";
    System.out.println("Test String".equals(x)); // true
}

Kapag ang kaso ay hindi mahalaga sa amin kapag naghahambing ng mga string, kailangan naming gamitin ang pamamaraan equalsIgnoreCase():

public static void main(String[] args) {
       String x = "Test String";
       System.out.println("test string".equalsIgnoreCase(x)); // true
}

Pag-convert ng object/primitive sa isang string

Upang i-convert ang isang instance ng anumang klase ng Java o anumang primitive na uri ng data sa isang representasyon ng string, maaari mong gamitin ang paraan String.valueOf():

public class StringExamples {
    public static void main(String[] args) {
        String a = String.valueOf(1);
        String b = String.valueOf(12.0D);
        String c = String.valueOf(123.4F);
        String d = String.valueOf(123456L);
        String s = String.valueOf(true);
        String human = String.valueOf(new Human("Alex"));

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(s);
        System.out.println(human);
        /*
        Output:
        1
        12.0
        123.4
        123456
        true
        Person named Alex
         */
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

Pag-convert ng string sa isang numero

Kadalasan kailangan mong i-convert ang isang string sa isang numero. Ang mga klase ng primitive na uri ng wrapper ay may mga pamamaraan na eksaktong nagsisilbi sa layuning ito. Ang lahat ng mga pamamaraang ito ay nagsisimula sa salitang parse. Isaalang-alang ang pagsasalin ng isang string sa integer ( Integer) at fractional ( Double) na mga numero sa ibaba:

public static void main(String[] args) {
    Integer i = Integer.parseInt("12");
    Double d = Double.parseDouble("12.65D");

    System.out.println(i); // 12
    System.out.println(d); // 12.65
}

Pag-convert ng isang koleksyon ng mga string sa isang representasyon ng string

Kung kailangan mong i-convert ang lahat ng elemento ng ilang koleksyon ng mga string sa isang representasyon ng string sa pamamagitan ng arbitrary delimiter, maaari mong gamitin ang mga sumusunod na pamamaraan ng Java String class:

• join(CharSequence delimiter, CharSequence... elements)
• join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

Nasaan delimiterang element separator, at elementsito ay isang string array / string collection instance. Tingnan natin ang isang halimbawa kung saan iko-convert natin ang isang listahan ng mga string sa isang string, na pinaghihiwalay ang bawat isa gamit ang isang semicolon:

public static void main(String[] args) {
    List<String> people = Arrays.asList(
            "Philip J. Fry",
            "Turanga Leela",
            "Bender Bending Rodriguez",
            "Hubert Farnsworth",
            "Hermes Conrad",
            "John D. Zoidberg",
            "Amy Wong"
    );

    String peopleString = String.join("; ", people);
    System.out.println(peopleString);
    /*
    Output:
    Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong
     */
}

Paghahati ng string sa hanay ng mga string

Ang operasyong ito ay isinasagawa sa pamamagitan ng pamamaraan split(String regex) Ang separator ay isang string na regular na expression regex. Sa halimbawa sa ibaba, gagawin namin ang kabaligtaran na operasyon sa kung ano ang ginawa namin sa nakaraang halimbawa:

public static void main(String[] args) {
    String people = "Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong";

    String[] peopleArray = people.split("; ");
    for (String human : peopleArray) {
        System.out.println(human);
    }
    /*
    Output:
    Philip J. Fry
    Turanga Leela
    Bender Bending Rodriguez
    Hubert Farnsworth
    Hermes Conrad
    John D. Zoidberg
    Amy Wong
     */
}

Pagtukoy sa posisyon ng isang elemento sa isang linya

Sa wikang Java, ang String ay nagbibigay ng isang hanay ng mga pamamaraan upang matukoy ang posisyon ng isang character/substring sa isang string:

1. indexOf(int ch)
2. indexOf(int ch, int fromIndex)
3. indexOf(String str)
4. indexOf(String str, int fromIndex)
5. lastIndexOf(int ch)
6. lastIndexOf(int ch, int fromIndex)
7. lastIndexOf(String str)
8. lastIndexOf(String str, int fromIndex)

saan:

1. ch— ang simbolo na iyong hinahanap ( char)
2. str- string ng paghahanap
3. fromIndex— ang posisyon kung saan hahanapin ang elemento
4. pamamaraan indexOf- ibalik ang posisyon ng unang elemento na natagpuan
5. pamamaraan lastIndexOf- ibalik ang posisyon ng huling elemento na natagpuan

Kung ang elemento na iyong hinahanap ay hindi natagpuan, ang mga pamamaraan ay magbabalik ng linya -1. Subukan nating hanapin ang serial number ng mga titik A, K, Z, Яsa alpabetong Ingles, ngunit tandaan na ang pag-index ng mga character sa isang string sa Java ay nagsisimula sa zero:

public static void main(String[] args) {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    System.out.println(alphabet.indexOf('A')); // 0
    System.out.println(alphabet.indexOf('K')); // 10
    System.out.println(alphabet.indexOf('Z')); // 25
    System.out.println(alphabet.indexOf('Я')); // -1
}

Pagkuha ng substring mula sa isang string

Upang kunin ang isang substring mula sa isang string, ang String class sa Java ay nagbibigay ng mga pamamaraan:

• substring(int beginIndex)
• substring(int beginIndex, int endIndex)

Tingnan natin kung paano natin magagamit ang pagpoposisyon ng elemento at mga pamamaraan ng pagkuha ng substring para makuha ang pangalan ng file mula sa landas nito:

public static void main(String[] args) {
    String filePath = "D:\\Movies\\Futurama.mp4";
    int lastFileSeparatorIndex = filePath.lastIndexOf('\\');
    String fileName = filePath.substring(lastFileSeparatorIndex + 1);
    System.out.println(fileName); //9
}

I-convert ang string sa upper/lower case:

Ang String class ay nagbibigay ng mga pamamaraan para sa pag-convert ng string sa uppercase at lowercase:

• toLowerCase()
• toUpperCase()

Tingnan natin kung paano gumagana ang mga pamamaraang ito gamit ang isang halimbawa:

public static void main(String[] args) {
    String fry = "Philip J. Fry";

    String lowerCaseFry = fry.toLowerCase();
    String upperCaseFry = fry.toUpperCase();

    System.out.println(lowerCaseFry); // philip j. fry
    System.out.println(upperCaseFry); // PHILIP J. FRY
}

Ang pagtatrabaho sa Java class na ito ay pinag-aaralan sa mga unang antas ng JavaRush online na kurso:

• Ang isang panimula sa String ay ibinibigay sa antas 1, panayam 4 ng Java Syntax quest
• Ang panloob na istraktura ng String, ang pamamaraan ng substring ay pinag-aralan sa ika-2 antas, ika-3 lecture ng Java Multithreading quest
• Ang paghahanap, pagkuha, pagtanggal ng substring sa isang String ay pinag-aaralan sa 2nd level, ika-4 na lecture ng Java Multithreading quest
• Ang paraan ng String.format ay sakop sa antas 2, lecture 6 ng Java Multithreading quest

Mga karagdagang mapagkukunan

Ang impormasyon tungkol sa klase ng String ay ibinibigay din sa iba pang mga artikulo sa komunidad ng JavaRush:

1. Mga String sa Java - Sinasaklaw ng artikulong ito ang ilang pangunahing kaalaman sa pagtatrabaho sa mga string sa Java.
2. Java String. Mga tanong at sagot sa panayam, bahagi 1 - tinatalakay ng artikulong ito ang mga tanong sa pakikipanayam sa paksa String, at nagbibigay din ng mga sagot sa mga tanong na may mga paliwanag at mga halimbawa ng code.
3. Strings sa Java (class java.lang.String) - ang artikulong ito ay nagbibigay ng mas malalim na pagsusuri ng String class, at tinatalakay din ang mga intricacies ng pagtatrabaho sa klase na ito.