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

Sa kasamaang palad, ang artikulo ay hindi magkasya sa isang fragment; kailangan kong hatiin ito sa dalawang bahagi. Tingnan ang simula dito

12. Sumulat ng isang function upang mahanap ang pinakamahabang palindrome sa isang ibinigay na string

Ang isang string ay maaaring maglaman ng mga palindromic string, at ang paghahanap ng pinakamahabang palindrome ay isang bagay ng programming. Ang pangunahing punto dito ay na mula sa gitna ng anumang palindrome, kung pupunta tayo sa kanan at kaliwa ng 1 character, ito ay palaging magiging parehong karakter. Halimbawa, 12321, ang gitna ay 3, at kung magpapatuloy kami sa paglipat mula sa kasalukuyang posisyon sa parehong direksyon, makakakuha kami ng 2 at pagkatapos ay 1. Gumagamit kami ng katulad na lohika sa aming Java program upang mahanap ang pinakamahabang palindrome. Gayunpaman, kung ang haba ng palindrome ay pantay, ang haba ng gitna ay pantay din, kaya kailangan nating tiyakin na ito ay ibinigay din sa ating programa, halimbawa, 12333321, ang gitna ay 33, at kung patuloy tayong gumagalaw. sa parehong direksyon, makakakuha tayo ng 3, 2 at 1. Sa aming programa, dumaan kami sa resultang string na ang gitna ay nasa unang lugar at suriin ang kaliwa at kanang mga character. Mayroon din kaming dalawang pandaigdigang variable upang iimbak ang paunang posisyon ng palindrome. Kailangan din nating suriin kung mayroon nang mas mahabang palindrome na natagpuan, dahil mahahanap natin ang maraming palindrome sa isang naibigay na string. Nasa ibaba ang isang halimbawang programa na gumagana nang maayos sa lahat ng kaso. Mapapabuti namin ang code sa itaas sa pamamagitan ng paglipat ng while loop sa isang hiwalay na paraan, ngunit iiwan ko ang bahaging iyon para sa iyo. Mangyaring ipaalam sa akin kung mayroon kang mas mahusay na pagpapatupad o kung nabigo ang programa sa ilang paraan.

package com.journaldev.util;

public class LongestPalindromeFinder {

    public static void main(String[] args) {
        System.out.println(longestPalindromeString("1234"));
        System.out.println(longestPalindromeString("12321"));
        System.out.println(longestPalindromeString("9912321456"));
        System.out.println(longestPalindromeString("9912333321456"));
        System.out.println(longestPalindromeString("12145445499"));
    }

    public static String longestPalindromeString(String in) {
        char[] input = in.toCharArray();
        int longestPalindromeStart = 0;
        int longestPalindromeEnd = 0;

        for (int mid = 0; mid < input.length; mid++) {
            // для случая нечетного палиндрома How 12321, 3 будет серединой
            int left = mid-1;
            int right = mid+1;
            // нам необходимо двигаться влево и вправо на 1 позицию до конца
            while (left >= 0 && right < input.length) {
                // ниже проверка, является ли это палиндромом
                if (input[left] == input[right]) {
                    // обновление глобальных позиций, только если палиндром длиннее имеющегося
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
            // для четного палиндрома у нас должна быть подобная логика с размером середины 2
            // для этого мы начнем на одну позицию правее
            left = mid-1;
            right = mid + 2;// к примеру, для 12333321 мы выбрали 33 в качестве середины
            while (left >= 0 && right < input.length)
            {
                if (input[left] == input[right]) {
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
        }
        // теперь у нас есть позиции для самого длинного палиндрома
        return in.substring(longestPalindromeStart, longestPalindromeEnd + 1);
    }
}

Ilalabas ng programa ang sumusunod:

1
12321
12321
12333321
454454

13. Ano ang mga pagkakaiba sa pagitan ng String, StringBuffer at StringBuilder

Ang isang string ay hindi nababago at tinatapos sa Java, kaya lahat ng aming mga manipulasyon ng string ay palaging lilikha ng bagong string. Ang pagmamanipula ng string ay masinsinang mapagkukunan, kaya ang Java ay nagbibigay ng dalawang kapaki-pakinabang na klase para sa pagmamanipula ng string - StringBufferat StringBuilder. StringBufferat StringBuildermga nababagong klase. Ang mga operasyon sa StringBufferthread ay ligtas at naka-synchronize, ngunit ang mga pamamaraan StringBuilderay hindi ligtas sa thread. Kaya kapag maraming mga thread ay gumagana sa parehong string na dapat nating gamitin StringBuffer, ngunit sa isang solong sinulid na kapaligiran ay dapat nating gamitin StringBuilder. StringBuildermas produktibo kaysa StringBufferdahil hindi ito nabibigatan sa pag-synchronize.

14. Bakit ang string ay hindi nababago at tinatapos sa Java?

Mayroong ilang mga pakinabang sa string immutability:

1. Ang string pooling ay posible lamang dahil ang string ay hindi nababago sa Java, kaya ang virtual machine ay nakakatipid ng maraming heap space habang ang iba't ibang string variable ay tumuturo sa parehong variable sa pool. Kung ang isang string ay hindi nababago, ang string interning ay hindi magiging posible, dahil kung ang anumang variable ay magbabago ng halaga nito, ang iba pang mga variable na tumutukoy sa string na iyon ay maaapektuhan din.

2. Kung ang string ay nababago, ito ay nagiging isang seryosong panganib sa seguridad para sa application. Halimbawa, ang database username at password ay ipinapasa bilang isang string upang makakuha ng koneksyon sa database at sa socket programming ang mga detalye ng host at port ay ipinapasa bilang isang string. Dahil ang string ay hindi nababago, hindi mababago ang halaga nito, kung hindi, maaaring baguhin ng sinumang hacker ang halaga ng link at magdulot ng mga problema sa seguridad ng application.

3. Dahil ang string ay hindi nababago, ito ay thread-safe at ang isang instance ng string ay maaaring ibahagi sa iba't ibang mga thread. Iniiwasan nito ang pag-synchronize para sa kaligtasan ng thread, ang mga string ay ganap na ligtas sa thread.

4. Ginagamit ang mga string sa Java classloaderat tinitiyak ng immutability na ang klase ay na-load nang tama gamit ang Classloader. Halimbawa, isipin ang tungkol sa isang halimbawa ng klase kapag sinusubukan mong mag-load java.sql.Connectionng isang klase, ngunit ang reference na halaga ay binago sa myhacked.Connectionisang klase na maaaring gumawa ng mga hindi gustong bagay sa iyong database.

5. Dahil ang string ay hindi nababago, ito hashcodeay naka-cache sa oras ng paglikha at hindi na kailangang kalkulahin itong muli. Ginagawa nitong isang mahusay na kandidato ang string para sa susi Mapat ang pagproseso nito ay magiging mas mabilis kaysa sa iba pang mga susi HashMap. Ito ang dahilan kung bakit ang string ay ang pinakakaraniwang ginagamit na bagay na ginagamit bilang isang susi HashMap.

15. Paano hatiin ang isang string sa mga bahagi?

Maaari tayong gumamit ng paraan split(String regex)upang hatiin ang isang string sa isang hanay ng mga string gamit ang isang regular na expression bilang delimiter.

import java.util.Arrays;

public class JavaSplitString {
    public static void main(String[] args) {
        String line = "I am a java developer";
        String[] words = line.split(" ");
        String[] twoWords = line.split(" ", 2);
        System.out.println("String split with delimiter: "+Arrays.toString(words));
        System.out.println("String split into two: "+Arrays.toString(twoWords));
        //split string delimited with special characters
        String wordsWithNumbers = "I|am|a|java|developer";
        String[] numbers = wordsWithNumbers.split("\\|");
        System.out.println("String split with special character: "+Arrays.toString(numbers));
    }
}

Ang pamamaraan split(String regex, int numOfStrings)ay isang overloaded na pamamaraan para sa paghahati ng isang string sa isang tinukoy na bilang ng mga linya. Maaari kaming gumamit ng backslash upang gumamit ng mga regular na expression na mga espesyal na character bilang mga regular na character. Ilalabas ng programa ang sumusunod:

String split with delimiter: [I, am, a, java, developer]
String split into two: [I, am a java developer]
String split with special character: [I, am, a, java, developer]

16. Bakit mas gusto ang string array kaysa string para sa pag-iimbak ng password?

Ang isang string ay hindi nababago sa Java at naka-imbak sa isang string pool. Kapag nalikha na ito, nananatili ito sa pool hanggang sa makolekta ito ng basura, kaya kapag sa tingin natin ay tapos na tayo sa password, ito ay nananatiling available sa memorya nang ilang sandali at walang paraan upang maiwasan ito. Ito ay isang panganib sa seguridad dahil ang sinumang may access sa memory dump ay mahahanap ang password sa malinaw na teksto. Kung gagamit kami ng array ng character upang iimbak ang password, maaari naming i-clear ito pagkatapos naming gawin ito. Sa ganitong paraan makokontrol natin kung gaano ito katagal mananatili sa memorya, na iniiwasan ang mga panganib sa seguridad na likas sa isang string.

17. Paano mo susuriin ang dalawang string para sa pagkakatulad sa Java?

Mayroong dalawang mga paraan upang suriin kung ang dalawang mga string ay katumbas - gamit ang " ==" operator, o gamit ang equals. Kapag ginamit namin ang " ==" operator, sinusuri nito ang halaga ng string bilang isang sanggunian, ngunit sa pagprograma kadalasan ay sinusuri namin ang pagkakapareho ng string para lamang sa halaga. Samakatuwid, dapat nating gamitin ang equals method upang subukan ang dalawang string para sa pagkakapantay-pantay. Mayroon ding isang paraan equalsIgnoreCasena maaari nating gamitin upang huwag pansinin ang kaso.

String s1 = "abc";
String s2 = "abc";
String s3= new String("abc");
System.out.println("s1 == s2 ? "+(s1==s2)); //true
System.out.println("s1 == s3 ? "+(s1==s3)); //false
System.out.println("s1 equals s3 ? "+(s1.equals(s3))); //true

18. Ano ang string pool?

Gaya ng ipinahihiwatig ng pangalan, ang string pool ay isang koleksyon ng mga string na nakaimbak sa isang Java heap. Alam namin na Stringito ay isang espesyal na klase sa Java at maaari kaming lumikha ng mga bagay ng klase na ito gamit ang bagong operator tulad ng paggawa namin ng mga bagay sa pamamagitan ng pagbibigay ng halaga ng isang string sa mga dobleng panipi. Ipinapaliwanag ng diagram sa ibaba kung paano inilalaan ang string pool sa Java heap at kung ano ang mangyayari kapag gumamit kami ng iba't ibang paraan upang lumikha ng mga string. Ang pag-pool ng mga string ay posible lamang dahil sa hindi nababago ng mga string ng Java at ang pagpapatupad ng ideya ng string interning. Ang string pool ay isa ring halimbawa ng pattern ng Flyweight. Nakakatulong ang string pool na makatipid ng maraming memory, ngunit sa kabilang banda, ang paggawa ng row ay tumatagal ng mas maraming oras. Kapag gumamit kami ng double quotes para gumawa ng string, maghahanap muna ito ng string sa pool na may parehong value, kung makita ay magbabalik lang ng reference, kung hindi, gagawa ng bagong string sa pool at pagkatapos ay magbabalik ng reference. Gayunpaman, kapag ginamit namin ang bagong operator, pinipilit namin ang klase Stringna lumikha ng bagong string object, at pagkatapos ay magagamit namin ang paraan intern()upang ilagay ang string sa pool, o kumuha ng reference mula sa pool patungo sa isa pang object Stringna may parehong halaga. Nasa ibaba ang isang halimbawa na nagpapakita kung paano gumagana ang string pool.

public class StringPool {
    public static void main(String[] args) {
        String s1 = "Cat";
        String s2 = "Cat";
        String s3 = new String("Cat");

        System.out.println("s1 == s2 :"+(s1==s2));
        System.out.println("s1 == s3 :"+(s1==s3));
    }
}

Ilalabas ng programa ang sumusunod:

s1 == s2 :true
s1 == s3 :false

19. Ano ang ginagawa ng intern() na pamamaraan?

intern()Kapag tinawag ang pamamaraan , kung ang string pool ay naglalaman na ng string na katumbas ng ating object, bilang na-verify ng method equals(Object), pagkatapos ay ibabalik ang isang reference sa string mula sa pool. Kung hindi, ang string object ay idinagdag sa pool at isang reference sa bagay na iyon ay ibabalik. Ang pamamaraang ito ay palaging nagbabalik ng isang string na may parehong halaga ng kasalukuyang string, ngunit ginagarantiyahan na ito ay magiging isang string mula sa pool ng mga natatanging string. Nasa ibaba ang isang halimbawa kung paano gumagana ang pamamaraan intern():

public class StringPool {
    public static void main(String[] args) {
        String a = "string a";
        String b = new String("string a");
        String c = b.intern();

        System.out.println(a == b);
        System.out.println(b == c);
        System.out.println(a == c);
    }
}
Программа выведет следующее:false
false
true

20. Ligtas ba ang thread ng mga string sa Java?

Ang mga string ay hindi nababago, kaya hindi namin mababago ang kanilang halaga sa programa. Samakatuwid ang mga ito ay ligtas sa thread at maaaring ligtas na magamit sa isang multi-threaded na kapaligiran.

21. Bakit sikat ang String sa HashMap sa Java?

Dahil ang mga string ay hindi nababago, ang kanilang hash code ay naka-cache sa oras ng paglikha at hindi nangangailangan ng muling pagkalkula. Ginagawa nitong isang mahusay na kandidato ang mga string para sa isang susi Mapat ang mga ito ay naproseso nang mas mabilis kaysa sa iba pang mga pangunahing bagay HashMap. Ito ang dahilan kung bakit ang mga string ay pangunahing ginagamit bilang mga susi HashMap. Umaasa ako na ang mga tanong na nakalista sa artikulong ito ay makakatulong sa iyo sa iyong mga panayam, mangyaring ipaalam sa akin kung mayroon akong napalampas. Link sa orihinal na artikulo May-akda: Pankaj Kumar