Rentetan Java. Soalan dan jawapan temu bual, bahagian 2

Malangnya, artikel itu tidak muat dalam satu serpihan; saya terpaksa membahagikannya kepada dua bahagian. Lihat permulaan di sini

12. Tulis satu fungsi untuk mencari palindrom terpanjang dalam rentetan tertentu

Rentetan boleh mengandungi rentetan palindromik, dan mencari palindrom terpanjang adalah masalah pengaturcaraan. Perkara utama di sini ialah dari tengah mana-mana palindrom, jika kita pergi ke kanan dan kiri dengan 1 aksara, ia akan sentiasa menjadi watak yang sama. Sebagai contoh, 12321, tengah ialah 3, dan jika kita terus bergerak dari kedudukan semasa dalam kedua-dua arah, kita akan mendapat 2 dan kemudian 1. Kami menggunakan logik yang sama dalam program Java kami untuk mencari palindrom terpanjang. Walau bagaimanapun, jika panjang palindrom genap, panjang tengah juga genap, jadi kita perlu memastikan bahawa ini juga disediakan dalam program kita, contohnya, 12333321, tengah ialah 33, dan jika kita terus bergerak dalam kedua-dua arah, kami akan mendapat 3, 2 dan 1. Dalam program kami, kami melalui rentetan yang dihasilkan dengan tengah di tempat pertama dan semak aksara kiri dan kanan. Kami juga mempunyai dua pembolehubah global untuk menyimpan kedudukan awal palindrom. Kita juga perlu menyemak sama ada terdapat palindrom yang lebih panjang telah ditemui, kerana kita boleh menemui berbilang palindrom dalam rentetan tertentu. Di bawah ialah contoh program yang berfungsi dengan baik dalam semua kes. Kita boleh menambah baik kod di atas dengan mengalihkan gelung while ke kaedah yang berasingan, tetapi saya akan meninggalkan bahagian itu untuk anda. Sila beritahu saya jika anda mempunyai pelaksanaan yang lebih baik atau jika program gagal dalam beberapa cara.

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

Program ini akan mengeluarkan yang berikut:

1
12321
12321
12333321
454454

13. Apakah perbezaan antara String, StringBuffer dan StringBuilder

Rentetan tidak boleh diubah dan dimuktamadkan dalam Java, jadi semua manipulasi rentetan kami akan sentiasa mencipta rentetan baharu. Manipulasi rentetan adalah intensif sumber, jadi Java menyediakan dua kelas berguna untuk manipulasi rentetan - StringBufferdan StringBuilder. StringBufferdan StringBuildermerupakan kelas boleh ubah. Operasi dengan StringBufferbenang selamat dan disegerakkan, tetapi kaedah StringBuildertidak selamat untuk benang. Jadi apabila berbilang benang berfungsi pada rentetan yang sama kita harus gunakan StringBuffer, tetapi dalam persekitaran berulir tunggal kita harus gunakan StringBuilder. StringBuilderlebih produktif daripada StringBufferkerana ia tidak dibebani dengan penyegerakan.

14. Mengapakah rentetan tidak boleh diubah dan dimuktamadkan di Jawa?

Terdapat beberapa kelebihan untuk kebolehubahan rentetan:

1. Pengumpulan rentetan hanya mungkin kerana rentetan tidak boleh diubah di Jawa, oleh itu mesin maya menjimatkan banyak ruang timbunan kerana pembolehubah rentetan yang berbeza menghala ke pembolehubah yang sama dalam kolam. Jika rentetan tidak boleh diubah, maka rentetan interning tidak akan dapat dilakukan, kerana jika mana-mana pembolehubah mengubah nilainya, pembolehubah lain yang merujuk rentetan itu juga akan terjejas.

2. Jika rentetan boleh berubah, maka ia menjadi risiko keselamatan yang serius untuk aplikasi. Sebagai contoh, nama pengguna dan kata laluan pangkalan data diluluskan sebagai rentetan untuk mendapatkan sambungan ke pangkalan data dan dalam pengaturcaraan soket, butiran hos dan port diluluskan sebagai rentetan. Memandangkan rentetan itu tidak boleh diubah, nilainya tidak boleh diubah, jika tidak, mana-mana penggodam boleh mengubah nilai pautan dan menyebabkan masalah dalam keselamatan aplikasi.

3. Memandangkan rentetan tidak boleh diubah, ia selamat untuk benang dan satu contoh rentetan boleh dikongsi antara benang yang berbeza. Ini mengelakkan penyegerakan untuk keselamatan benang, rentetan benar-benar selamat benang.

4. Rentetan digunakan dalam Java classloaderdan kebolehubahan memastikan kelas dimuatkan dengan betul menggunakan Classloader. Sebagai contoh, fikirkan tentang contoh kelas apabila anda cuba memuatkan java.sql.Connectionkelas, tetapi nilai rujukan ditukar kepada myhacked.Connectionkelas yang mungkin melakukan perkara yang tidak diingini pada pangkalan data anda.

5. Oleh kerana rentetan tidak boleh diubah, ia hashcodedicache pada masa penciptaan dan tidak perlu mengiranya lagi. Ini menjadikan rentetan calon yang sangat baik untuk kunci masuk Mapdan pemprosesannya akan lebih cepat daripada kunci lain HashMap. Inilah sebab mengapa rentetan ialah objek yang paling biasa digunakan sebagai kunci HashMap.

15. Bagaimana untuk membelah tali kepada bahagian?

Kita boleh menggunakan kaedah split(String regex)untuk memisahkan rentetan kepada tatasusunan rentetan menggunakan ungkapan biasa sebagai pembatas.

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

Kaedah ini split(String regex, int numOfStrings)ialah kaedah terlebih beban untuk membelah rentetan kepada bilangan baris tertentu. Kita boleh menggunakan garis miring ke belakang untuk menggunakan aksara khas ungkapan biasa sebagai aksara biasa. Program ini akan mengeluarkan yang berikut:

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. Mengapakah tatasusunan rentetan lebih disukai daripada rentetan untuk menyimpan kata laluan?

Rentetan tidak boleh diubah di Jawa dan disimpan dalam kolam rentetan. Sebaik sahaja ia dibuat, ia kekal di dalam kolam sehingga ia dikumpul sampah, jadi apabila kita fikir kita telah selesai dengan kata laluan, ia kekal tersedia dalam ingatan untuk seketika dan tidak ada cara untuk mengelakkan ini. Ini adalah risiko keselamatan kerana sesiapa yang mempunyai akses kepada pembuangan memori akan dapat mencari kata laluan dalam teks yang jelas. Jika kami menggunakan tatasusunan aksara untuk menyimpan kata laluan, kami boleh mengosongkannya selepas kami selesai menggunakannya. Dengan cara ini kita boleh mengawal berapa lama ia kekal dalam ingatan, mengelakkan risiko keselamatan yang wujud dalam rentetan.

17. Bagaimanakah anda menyemak dua rentetan untuk persamaan dalam Java?

Terdapat dua cara untuk menyemak sama ada dua rentetan adalah setara - menggunakan ==pengendali “ ”, atau menggunakan equals. Apabila kita menggunakan pengendali “ ==”, ia menyemak nilai rentetan sebagai rujukan, tetapi dalam pengaturcaraan kebanyakan masa kita menyemak kesetaraan rentetan hanya untuk nilai. Oleh itu, kita mesti menggunakan kaedah sama untuk menguji dua rentetan untuk kesamaan. Terdapat juga kaedah equalsIgnoreCaseyang boleh kita gunakan untuk mengabaikan kes.

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. Apakah kolam rentetan?

Seperti namanya, kolam rentetan ialah koleksi rentetan yang disimpan dalam timbunan Java. Kami tahu bahawa Stringini adalah kelas khas dalam Java dan kami boleh mencipta objek kelas ini menggunakan operator baharu seperti kami boleh mencipta objek dengan memberikan nilai rentetan dalam petikan berganda. Rajah di bawah menerangkan cara kumpulan rentetan diperuntukkan dalam timbunan Java dan perkara yang berlaku apabila kita menggunakan cara yang berbeza untuk mencipta rentetan. Pengumpulan rentetan adalah mungkin semata-mata kerana kebolehubahan rentetan Java dan pelaksanaan idea rentetan interning. Kolam rentetan juga merupakan contoh corak Flyweight. Kolam rentetan membantu menjimatkan banyak memori, tetapi sebaliknya, mencipta baris memerlukan lebih banyak masa. Apabila kita menggunakan petikan berganda untuk mencipta rentetan, ia mula-mula mencari rentetan dalam kolam dengan nilai yang sama, jika ditemui kemudian hanya mengembalikan rujukan, jika tidak rentetan baharu dibuat dalam kolam dan kemudian mengembalikan rujukan. Walau bagaimanapun, apabila kami menggunakan operator baharu, kami memaksa kelas Stringuntuk mencipta objek rentetan baharu, dan kemudian kami boleh menggunakan kaedah intern()untuk meletakkan rentetan ke dalam kolam, atau mendapatkan rujukan daripada kolam ke objek lain Stringdengan nilai yang sama. Di bawah ialah contoh yang menunjukkan cara kolam rentetan berfungsi.

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

Program ini akan mengeluarkan yang berikut:

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

19. Apakah yang dilakukan oleh kaedah intern()?

Apabila kaedah intern()dipanggil, jika kolam rentetan sudah mengandungi rentetan yang setara dengan objek kita, seperti yang disahkan oleh kaedah equals(Object), maka rujukan kepada rentetan daripada kolam itu dikembalikan. Jika tidak, objek rentetan ditambahkan pada kolam dan rujukan kepada objek itu dikembalikan. Kaedah ini sentiasa mengembalikan rentetan yang mempunyai nilai yang sama dengan rentetan semasa, tetapi menjamin bahawa ia akan menjadi rentetan daripada kumpulan rentetan unik. Di bawah ialah contoh cara kaedah itu berfungsi 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. Adakah benang rentetan selamat di Jawa?

Rentetan tidak boleh diubah, jadi kami tidak boleh mengubah nilainya dalam program. Oleh itu ia selamat untuk benang dan boleh digunakan dengan selamat dalam persekitaran berbilang benang.

21. Mengapakah String menjadi kunci popular dalam HashMap di Java?

Oleh kerana rentetan tidak boleh diubah, kod cincangnya dicache pada masa penciptaan dan tidak memerlukan pengiraan semula. Ini menjadikan rentetan sebagai calon yang sangat baik untuk kunci Mapdan ia diproses lebih cepat daripada objek utama yang lain HashMap. Inilah sebabnya mengapa rentetan kebanyakannya digunakan sebagai kunci HashMap. Saya harap soalan yang disenaraikan dalam artikel ini akan membantu anda dalam temu duga anda, sila beritahu saya jika saya terlepas apa-apa. Pautan ke artikel asal Pengarang: Pankaj Kumar