Rentetan dalam Jawa

Rentetan ialah jujukan aksara, tetapi dalam java, ia dianggap sebagai objek dan sifatnya tidak berubah; java menyediakan pakej java.lang.String dengan kaedah berbeza yang tersedia untuk beroperasi pada rentetan, tetapi kami juga boleh mencipta rentetan boleh ubah dalam java.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Bagaimana untuk Mentakrifkan Rentetan dalam Java?

Kita boleh mentakrifkannya dengan menggunakan rentetan kata kunci literal dan baharu. Tetapi perbezaannya adalah literal tidak akan mencipta objek baharu melainkan dan sehingga ia tidak tersedia dalam kolam rentetan. Walau bagaimanapun, kata kunci baharu akan sentiasa mencipta objek baharu tanpa mengira kumpulan pemalar rentetan kerana ia mencipta rentetan dalam kawasan timbunan.

• Rentetan boleh ubah
• Rentetan tidak boleh ubah

Bagaimana untuk Mencipta Rentetan dalam Java?

Dalam java, kita boleh menentukan rentetan menggunakan dua cara iaitu seperti berikut:

• Dengan menggunakan literal rentetan
• Dengan menggunakan kata kunci baharu

1. Rentetan literal

Rentetan yang kami cipta dengan menggunakan literal terus pergi ke kolam pemalar rentetan. Ini bermakna jika rentetan yang diminta sudah ada dalam kolam rentetan, maka rentetan sedia ada akan dikembalikan jika rentetan yang diminta tidak wujud, maka hanya contoh rentetan baharu yang akan dibuat dan diletakkan dalam kolam untuk rujukan masa hadapan. JVM melaksanakan semua perkara ini.

Sintaks:

String s="abc";
String s1 = "abc" ;

Dalam senario di atas, hanya satu objek akan dibuat dalam kolam rentetan kerana JVM tidak akan dapat mencari objek yang diminta, jadi ia akan membuatnya dan meletakkannya ke dalam kolam, dan s1 akan menunjuk kepada rujukan itu sahaja untuk kegunaan selanjutnya. Jadi string literal juga menjimatkan memori dengan tidak mencipta contoh yang sama lagi. Oleh itu, ia menjadikan memori kod kami cekap.

2. kata kunci baharu

Di java, kami menggunakan kata kunci baharu untuk mencipta objek baharu. Setiap kali kami menggunakan kata kunci baharu, ia akan mencipta objek baharu untuk kami. Selain itu, objek yang dibuat menggunakan kata kunci baharu diletakkan ke dalam kawasan ingatan timbunan.

Sintaks:

String s = new Stirng("abc");

Dalam contoh di atas, objek ini akan diletakkan ke dalam kawasan ingatan timbunan, bukan kumpulan rentetan, kerana kami menciptanya menggunakan kata kunci baharu.

Contoh:

public class Main {
public static void main(String[] args) {
String s = "abc";
String s1 = "abc";
String ss = new String("abc");
System.out.println("Output will be :: " + s + " "+ s1 +" "+ ss);
}
}

Output:

Peraturan dan Peraturan untuk String dalam Java

Ia tidak boleh diubah, jadi kami tidak boleh menukar nilainya setelah ditetapkan. Jadi untuk mencipta rentetan boleh ubah, kita perlu menggunakan penimbal Rentetan untuk ini.

Beberapa perkara perlu diingat:

•  Semasa mentakrifkan rentetan, pastikan ia sentiasa dipetik dengan petikan berganda.
• Itu tidak boleh diubah, iaitu, nilai tidak boleh diubah setelah ditetapkan.
• Operator ‘+’ boleh menggabungkan dua atau lebih rentetan.
• Kami boleh menetapkan rentetan secara langsung kepada pembolehubah tanpa memanggil pembinanya.

Kaedah Kelas Rentetan dalam Java

Pelbagai kaedah yang ada adalah seperti berikut:

• trim()
• kepadaUpperCase
• ke Huruf Kecil
• valueOf(int value)
• kepada Huruf Kecil(Tempatan l)
• pelatih()
• indexOf(int ch)
• indexOf(String substring, int fromIndex)
• indexOf(Subrentetan rentetan)
• split(String regex, int limit)
• concat(String str)
• indexOf(int ch, int fromIndex)
• panjang()
• sama dengan(Bantah yang lain)
• sertai(pembatas CharSequence, Iterable)
• kosong()
• ganti(aksara lama, aksara baharu)
• equalsIgnoreCase(String another)
• pisah(String regex)
• kepadaUpperCase(Locale l)
• mengandungi(CharSequence s)
• charAt(int index)
• ganti(CharSequence lama, CharSequence baharu)
• sertai(pembatas CharSequence, elemen CharSequence…)
• subrentetan(int beginIndex)
• ubstring(int beginIndex, int endIndex)
• Kelas rentetan dalam java melaksanakan antara muka yang berbeza bernama
• Boleh bersiri
• Setanding
• CharSequence

Selain itu, kelas rentetan melaksanakan satu lagi antara muka, iaitu antara muka CharSequence; StringBuilder dan String Buffer juga melaksanakan antara muka ini. StringBuffer dan StringBuilder digunakan untuk mencipta rentetan boleh ubah dalam java.

Contoh – Menggunakan StringBuffer

Kod:

public class Demo{
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("creating string ");
sb.append("executed");//original string will get chnage
System.out.println("Result is " +sb);//it will print creating string executed
}
}

Output :

Contoh – Menggunakan StringBuilder

Kod:

public class Main{
public static void main(String[] args) {
StringBuilder sb=new StringBuilder("Creating string");
sb.append(" using string Builder");//original will get change
System.out.println("Result is "+sb);
}
}

Output:

Contoh

Di bawah ialah contoh :

Contoh #1

Kod:

public class Main{
public static void main(String[] args) {
String s1="demoforsting";
System.out.println("String is " +s1.substring(2,4));
System.out.println( "with one parameter " +s1.substring(2));
}
}

Output:

Example #2

Code:

public class Demo{
public static void main(String[] args) {
String s1="abc";
String s2="abc";
String s3="ABC";
String s4="java";
System.out.println("Result is " +s1.equals(s2));//true
System.out.println("Result is " +s1.equals(s3));//false
System.out.println("Result is " +s1.equals(s4));//false
}
}

Output:

Example #3

Code:

public class Demo{
public static void main(String[] args) {
String s1="convert it into uppercase";
String upper=s1.toUpperCase();
System.out.println("result is "+upper);
}
}

Output:

Example #4

Code:

public class Demo{
public static void main(String[] args) {
String s1="CONVERT IT INTO LOWER CASE";
String s1upper=s1.toLowerCase();
System.out.println("result is "+s1upper);
}
}

Output:

Example #5

Code:

public class Main{
public static void main(String[] args) {
String name="Demo to check contains method";
System.out.println("Result for conatins mehtod is " +name.contains("check"));
System.out.println("Result for conatins mehtod is " +name.contains("method"));
System.out.println("Result for conatins mehtod is " +name.contains("move"));
}
}

Output:

Example #6

Code:

public class Main{
public static void main(String[] args) {
String str1 = "Demo for";
String str2 = "Concat";
String str3 = "Method";
// doing for string one
String str4 = str1.concat(str2);
System.out.println("Result is "+str4);
// for multiple string
String str5 = str1.concat(str2).concat(str3);
System.out.println("Result is "+str5);
}
}

Output:

Example #7

Code:

public class Main {
public static void main(String[] args) {
String s1 =" Provide space to see use of trim method in java ";
System.out.println(s1.length());
System.out.println("without trim output is "+s1); //Not using trim here
String tr = s1.trim();
System.out.println(tr.length());
System.out.println("with trim output is "+tr); //using trim here
}
}

Output:

Conclusion

So java string is an immutable object that provides security in various aspects like URL reading, database username and password, port, and many other things. But if we want to create a mutable string, we should use a string buffer and builder.

Atas ialah kandungan terperinci Rentetan dalam Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!