Java String. Mga tanong at sagot sa panayam, bahagi 1

Ang klase Stringay isa sa pinakamalawak na ginagamit na mga klase sa Java. Ang artikulong ito ay nagbibigay ng ilang mahahalagang tanong at sagot sa panayam ng Java String. Malaki ang maitutulong nila sa pagkuha ng kumpletong larawan ng klase Stringat ihahanda ka para sa anumang Stringtanong sa panayam na nauugnay sa klase.

1. Ano ang String sa Java? Anong uri ng data ito?

Ang String ay isang klase sa Java na tinukoy sa java.lang package. Ito ay hindi isang primitive na uri ng data tulad ng int at long. Ang String class ay kumakatawan sa isang string character set. Ginagamit ang mga string sa halos lahat ng mga aplikasyon ng Java at mayroong ilang mga katotohanan na dapat nating malaman tungkol sa klase ng String. Ito ay isang hindi nababago ( immutable) at pinal na uri ng data sa Java at Stringang virtual machine ay nag-iimbak ng lahat ng mga bagay ng klase sa isang string pool. Ang isa pang tampok Stringay ang paraan upang makakuha ng mga bagay sa klase Stringgamit ang mga dobleng panipi at labis na pagkarga sa operator na "+" para sa pagsasama-sama.

2. Ano ang iba't ibang paraan upang lumikha ng String object?

Maaari tayong lumikha ng mga bagay gamit ang bagong operator tulad ng iba pang klase sa Java o maaari tayong gumamit ng mga dobleng panipi upang lumikha ng isang bagay String. Mayroon ding ilang mga konstruktor ng klase Stringpara sa pagkuha ng isang string mula sa isang array ng character, isang byte array, at sa paggamit din StringBufferng o StringBuilder.

String str = new String("abc");
String str1 = "abc";

Kapag gumawa kami ng string gamit ang double quotes, ang Java Virtual Machine ay tumitingin sa string pool para sa isa pang string na may parehong halaga. Kung ang string ay natagpuan, pagkatapos ay isang reference lamang sa isang umiiral na object ng klase ang ibinalik String, kung hindi, isang bagong object ay nilikha na may natanggap na halaga at naka-imbak sa pool. Kapag ginamit namin ang bagong operator, ang virtual machine ay lumilikha ng isang bagay Stringngunit hindi ito iniimbak sa string pool. Maaari naming gamitin ang paraan intern()upang mag-imbak ng string sa isang string pool, o kumuha ng reference kung ang naturang string ay nasa pool na.

3. Sumulat ng isang paraan upang suriin kung ang isang string ay isang palindrome.

Ang isang string ay tinatawag na palindrome kung pareho ang pagbasa nito sa magkabilang direksyon. Halimbawa, ang "aba" ay isang palindromic string. Ang klase Stringay hindi nagbibigay ng anumang paraan para sa pag-reverse ng isang string, ngunit ang mga klase StringBufferay StringBuildermayroong isang paraan ng pag-reverse kung saan maaari naming suriin kung ang aming string ay isang palindrome o hindi.

private static boolean isPalindrome(String str) {
        if (str == null)
            return false;
        StringBuilder strBuilder = new StringBuilder(str);
        strBuilder.reverse();
        return strBuilder.toString().equals(str);
    }

Minsan maaaring hilingin ng tagapanayam na huwag gumamit ng ibang mga klase para sa pagsusuring ito, kung saan maaari nating ihambing ang mga character sa string sa magkabilang panig upang suriin ang palindrome.

private static boolean isPalindromeString(String str) {
        if (str == null)
            return false;
        int length = str.length();
        System.out.println(length / 2);
        for (int i = 0; i < length / 2; i++) {

            if (str.charAt(i) != str.charAt(length - i - 1))
                return false;
        }
        return true;
    }

4. Sumulat ng isang paraan para sa pag-alis ng isang ibinigay na character mula sa isang string.

Maaari kaming gumamit ng isang paraan replaceAllupang palitan ang lahat ng paglitaw ng isang string ng isa pang string. Tandaan na ang pamamaraan ay tumatagal ng isang string bilang isang argumento, kaya ginagamit namin ang klase Characterupang lumikha ng isang string mula sa isang character, at ginagamit ito upang palitan ang lahat ng mga character na may walang laman na string.

private static String removeChar(String str, char ch) {
        if (str == null)
            return null;
        return str.replaceAll(Character.toString(ch), "");
    }

5. Paano natin mako-convert ang isang string sa upper case o lower case?

Maaari kaming gumamit ng mga pamamaraan ng klase String toUpperCaseupang toLowerCacemakakuha ng parehong uppercase at lowercase na mga string. Ang mga paraang ito ay may labis na karga na nangangailangan ng argumento Localeat ginagamit ang mga panuntunan sa localization nito upang i-convert ang string sa upper o lower case.

6. Ano ang ginagawa ng subSequence method?

Ipinakilala ng Java 1.4 ang interface CharSequence, ang isang klase Stringay nagmamana ng interface na ito at iyon ang tanging dahilan upang ipatupad ang isang paraan subSequencesa isang klase String. Panloob na tinatawag nito ang substring. Isang simpleng halimbawa ng paggamit ng pamamaraan:

public class StringSubsequence {

    public static void main(String[] args) {
        String str = "www.journaldev.com";
        System.out.println("Last 4 char String: "+str.subSequence(str.length()-4, str.length()));
        System.out.println("First 4 char String: "+str.subSequence(0, 4));
        System.out.println("website name: "+str.subSequence(4, 14));

        //substring vs subSequence
        System.out.println("substring == subSequence ? "
			+(str.substring(4, 14) == str.subSequence(4, 14)));

        System.out.println("substring equals subSequence ? "
			+(str.substring(4, 14).equals(str.subSequence(4, 14))));
    }
}

Ang output ng programa ay magpapakita ng mga sumusunod:

Last 4 char String: .com
First 4 char String: www.
website name: journaldev
substring == subSequence ? false
substring equals subSequence ? true

Sa isip, dapat mong palaging gamitin ang substring.

7. Paano ihambing ang dalawang string sa Java?

Ang klase Stringay nagmamana ng interface Comparableat may dalawang paraan na opsyon compareTo(). Inihahambing ng pamamaraan compareTo(String anotherString)ang bagay Stringsa natanggap na argumento Stringsa lexicographically. Kung ang kasalukuyang linya ay nauuna sa natanggap na string, ang pamamaraan ay nagbabalik ng isang negatibong integer, at kung ang string ay sumusunod sa natanggap na argumento, ito ay nagbabalik ng isang positibong integer integer. Kung ang pamamaraan ay nagbabalik ng 0, kung gayon ang string ay may parehong halaga, kung saan ang pamamaraan equals(String str)ay babalik din ng totoo. compareToIgnoreCase(String str): Ang pamamaraang ito ay katulad ng nauna maliban sa hindi nito pinapansin ang kaso. Gumagamit ito ng CASE_INSENSITIVE_ORDER Comparator para sa case-insensitive na paghahambing. Kung ang halaga ng pagbabalik ay zero, ang pamamaraan equalsIgnoreCase(String str)ay babalik din ng totoo. Tingnan natin ang isang maliit na halimbawa upang ipaliwanag ang mga pamamaraang ito:

public class StringCompareToExample {
    public static void main(String[] args) {
        String str = "ABC";
        System.out.println(str.compareTo("DEF"));
        System.out.println(str.compareToIgnoreCase("abc"));
    }
}

Ilalabas ng programa ang sumusunod:

-3
0

8. Paano i-convert ang isang string sa isang character at vice versa?

Isa itong trick na tanong dahil ang isang string ay isang sequence ng mga character, kaya maaari lang namin itong i-convert sa isang character. Maaari kaming gumamit ng isang paraan charAtupang makuha ang character na matatagpuan sa isang tinukoy na posisyon o maaari kaming gumamit ng isang paraan toCharArray()upang i-convert ang isang string sa isang array ng mga character. Isang simpleng halimbawa na nagpapakita kung paano i-convert ang string sa character at character sa string sa Java.

import java.util.Arrays;

public class StringToCharToString {
    public static void main(String[] args) {
        //String to char array
        String str = "123";
        char[] chArr = str.toCharArray();
        System.out.println("String to char array: "+Arrays.toString(chArr));
        //String to char
        char c = str.charAt(1);
        System.out.println("String to char: "+c);
        //char to String
        String s = Character.toString(c);
        System.out.println("char to String: "+s);
        //удалить все заданные символы из строки
        System.out.println("removing all chars from String: "
                                 +removeCharFromString("1ABCD12DW", '1'));
    }

    private static String removeCharFromString(String str, char c) {
        return str.replaceAll(Character.toString( c ), "");
    }
}

Ilalabas ng programa ang sumusunod:

String to char array: [1, 2, 3]
String to char: 2
char to String: 2
removing all chars from String: ABCD2DW

9. Paano i-convert ang isang string sa isang byte array at vice versa?

Maaari kaming gumamit ng isang paraan getBytes()upang i-convert ang isang string sa isang byte array at maaari kaming gumamit ng isang constructor new String(byte[] arr)upang i-convert ang isang byte array sa isang string.

import java.util.Arrays;

public class StringByteArray {
     public static void main(String[] args) {
        String str = "www.journaldev.com";
        //преобразование String в byte array
        byte[] byteArr = str.getBytes();
        System.out.println("String to byte array : "+Arrays.toString(byteArr));
        //преобразование byte array и String
        String str1 = new String(byteArr);
        System.out.println("byte array to String : "+str1);
        //посмотрим, str и str1 одинаковые or нет
        System.out.println("str == str1? " + (str == str1));
        System.out.println("str.equals(str1)? " + (str.equals(str1)));
    }
}

Ilalabas ng programa ang sumusunod:

String to byte array : [119, 119, 119, 46, 106, 111, 117, 114, 110, 97, 108, 100, 101, 118, 46, 99, 111, 109]
byte array to String : www.journaldev.com
str == str1? false
str.equals(str1)? true

10. Maaari ba tayong gumamit ng string sa isang switch construct?

Ang nakakalito na tanong na ito ay ginagamit upang subukan ang iyong kaalaman sa kasalukuyang pag-unlad ng wika. Pinapalawak ng Java 7 ang switch statement upang gumamit ng mga string; hindi ito sinusuportahan ng mga naunang bersyon ng Java. Kung nagpapatupad ka ng conditional flow para sa mga string, maaari kang gumamit ng if-else na kundisyon at maaari kang gumamit ng switch statement kung gumagamit ka ng Java 7 o mas bago. Isang maliit na halimbawa ng paggamit ng string sa isang pahayag switchat isa pang paraan na nagpapakita ng parehong lohika gamit ang mga kundisyon if-else.

public class SwitchStringExample {

    public static void main(String[] args) {
        printColorUsingSwitch("red");
        printColorUsingIf("red");
        // оператор switch регистрозависимый
        printColorUsingSwitch("RED");
        printColorUsingSwitch(null);
    }

    private static void printColorUsingIf(String color) {
        if (color.equals("blue")) {
            System.out.println("BLUE");
        } else if (color.equals("red")) {
            System.out.println("RED");
        } else {
            System.out.println("INVALID COLOR CODE");
        }
    }

    private static void printColorUsingSwitch(String color) {
        switch (color) {
        case "blue":
            System.out.println("BLUE");
            break;
        case "red":
            System.out.println("RED");
            break;
        default:
            System.out.println("INVALID COLOR CODE");
        }
    }
}

Ilalabas ng programa ang sumusunod:

RED
RED
INVALID COLOR CODE
Exception in thread "main"
java.lang.NullPointerException
    at com.journaldev.util.SwitchStringExample.printColorUsingSwitch(SwitchStringExample.java:24)
    at com.journaldev.util.SwitchStringExample.main(SwitchStringExample.java:10)

Mga pangunahing punto ng paggamit switchpara sa mga string sa Java.

• ang paggamit ng mga string sa disenyo switchay ginagawang mas nababasa ang code sa pamamagitan ng pag-aalis ng maramihang mga kadena ng mga kundisyon if-else.
• ang mga string sa ay switchcase sensitive, ipinapakita ito ng halimbawa sa itaas.
• Gumagamit ang operator switchng paraan String.equals()upang ihambing ang resultang halaga sa mga halaga ng kaso , kaya magdagdag ng tseke para sa NULL upang maiwasan NullPointerException.
• Ayon sa dokumentasyon ng Java 7 para sa mga string sa switch, ang Java compiler ay bumubuo ng mas mahusay na bytecode para sa mga string sa isang construct switchkaysa para sa mga concatenated na kondisyon if-else.
• tiyaking gagamitin ito sa Java 7 o mas bago, kung hindi, makakakuha ka ng xception.

11. Sumulat ng isang programa na nagpi-print ng lahat ng mga permutasyon ng isang string.

Ito ay isang nakakalito na tanong at kailangan nating gumamit ng recursion upang mahanap ang lahat ng mga permutasyon ng isang string, halimbawa ang mga permutasyon ng "AAB" ay maaaring "AAB", "ABA" at "BAA". Kailangan din naming gamitin ang Set para matiyak na wala kaming mga duplicate na row. Upang makuha ang lahat ng mga permutasyon, kukunin muna namin ang unang character ng string at muling ayusin ang natitirang mga character. Kung String = “ABC” Unang character char = A at mga natitirang permutasyon BC at CB. Ngayon ay maaari na nating ipasok ang unang karakter sa mga magagamit na posisyon sa mga permutasyon. BC -> ABC, BAC, BCA CB -> ACB, CAB, CBA Halimbawa ng programa:

import java.util.HashSet;
import java.util.Set;

public class StringHelper {
    public static Set<String> permutationFinder(String str) {
        Set<String> perm = new HashSet<String>();
        //Handling error scenarios
        if (str == null) {
            return null;
        } else if (str.length() == 0) {
            perm.add("");
            return perm;
        }
        char initial = str.charAt(0); // первый символ
        String rem = str.substring(1); // полная строка без первого символа
        Set<String> words = permutationFinder(rem);
        for (String strNew : words) {
            for (int i = 0;i<=strNew.length();i++){
                perm.add(charInsert(strNew, initial, i));
            }
        }
        return perm;
    }

    public static String charInsert(String str, char c, int j) {
        String begin = str.substring(0, j);
        String end = str.substring(j);
        return begin + c + end;
    }

    public static void main(String[] args) {
        String s = "AAC";
        String s1 = "ABC";
        String s2 = "ABCD";
        System.out.println("\nPermutations for " + s + " are: \n" + permutationFinder(s));
        System.out.println("\nPermutations for " + s1 + " are: \n" + permutationFinder(s1));
        System.out.println("\nPermutations for " + s2 + " are: \n" + permutationFinder(s2));
    }
}

Output ng programa:

Permutations for AAC are:
[AAC, ACA, CAA]

Permutations for ABC are:
[ACB, ABC, BCA, CBA, CAB, BAC]

Permutations for ABCD are:
[DABC, CADB, BCAD, DBAC, BACD, ABCD, ABDC, DCBA, ADBC, ADCB, CBDA, CBAD, DACB, ACBD, CDBA, CDAB, DCAB, ACDB, DBCA, BDAC, CABD, BADC, BCDA, BDCA]

Pagpapatuloy ng artikulo