Mulakan dengan pantas dengan rentetan struktur data Java

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu berkaitan tentang rentetan Rentetan ialah urutan terhad yang terdiri daripada sifar atau lebih aksara, juga dikenali sebagai String, mari kita lihat. , saya harap ia akan membantu semua orang.

Pembelajaran yang disyorkan: "tutorial video java"

Pengetahuan asas rentetan

Rentetan ialah urutan terhad sifar atau lebih aksara, juga dikenali sebagai rentetan.

Kita boleh tahu daripada konsep asas ini:

• Sifar atau lebih aksara: menunjukkan bahawa jenis elemen dalaman rentetan ialah aksara.
• Terhad: Ini bermakna panjang kandungan rentetan adalah terhad, kurang daripada julat maksimum, tetapi dalam julat ini, panjang sebenar tidak pasti. Urutan
• : Ia menunjukkan bahawa terdapat hubungan pendahulu dan pengganti antara aksara bersebelahan dalam rentetan.

Tiada jenis rentetan terbina dalam dalam Java Setiap rentetan yang disertakan dalam petikan berganda ialah contoh kelas String dalam Java.

Maksudnya, String bukan jenis data dalam Java Semua rentetan dalam Java adalah objek String yang di-instantiate.

String dalam Java

Kelas String dalam Java mewakili rentetan, dan semua literal rentetan (seperti "abc") dalam program Java ialah Contoh kelas ini.

Dalam erti kata lain, semua rentetan petikan dua dalam atur cara Java ialah objek kelas String. Kelas rentetan berada di bawah pakej java.lang, jadi tidak perlu mengimport pakej apabila menggunakannya!

Ciri String yang paling penting dalam Java ialah:

Kelas String tidak boleh diubah, jadi sebaik sahaja anda mencipta objek String, nilainya tidak boleh diubah . Kami memanggil harta ini sebagai kebolehubahan String.

Ketidakbolehubahan rentetan

Ketidakbolehubahan: Apabila anda menetapkan semula nilai kepada rentetan, nilai lama tiada di sana Dimusnahkan dalam ingatan , tetapi buka semula ruang untuk menyimpan nilai baharu.

Maksudnya, apabila objek String dicipta dalam ingatan, ia akan menjadi tidak berubah, 所有的String类中方法并不是改变String对象自己，而是重新创建一个新的String对象.

Contohnya:

String s="dcm";String s="ddccmm"

Apabila nilai s berubah, nilai ddccmm tidak meliputi dcm, tetapi ruang baharu dibangunkan untuk menyimpan ddccmm dan s menunjuk kepadanya.

Jika kita melintasi, menetapkan dan mengubah suai rentetan yang mengandungi sejumlah besar aksara dalam pembangunan sebenar, banyak objek rentetan yang tidak dapat dilepaskan akan dijana dalam memori, menyebabkan memori sampah.

Oleh kerana ketidakbolehubah objek String, jika anda perlu membuat sejumlah besar pengubahsuaian pada rentetan, tambah aksara, padam aksara, dsb., cuba jangan gunakan objek String, kerana ini akan kerap mencipta objek baru dan menyebabkan pelaksanaan program berkurangan.

Pada masa ini kita boleh menggunakan StringBuilder, satu lagi kelas rentetan dalam Java.

Apabila kami membuat soalan, kami biasanya menggunakan kelas String untuk rentetan, tetapi memandangkan kami kadangkala menggunakan kelas StringBuilder, saya akan menerangkan kelas StringBuilder dengan lebih terperinci.

2. Kelas StringBuilder

StringBuilder ialah kelas rentetan Kita boleh menganggapnya sebagai bekas kandungan dalam objek r adalah berubah-ubah. StringBuilde

2.1 Kaedah biasa digunakan kelas StringBuilder
Dapat dilihat bahawa membina objek
hanya boleh dibina menggunakan kaedah pembinaan , tidak seperti StringBuilder, anda boleh mencipta String secara langsung dengan String s= "123" Kerana objek kelas

adalah berubah-ubah, apabila kita perlu menukar rentetan dengan banyak, ia biasanya ditakrifkan sebagai Kelas.

StringBuilderStringBuilder2.2 Perbezaan antara String dan StringBuilder

Objek tidak boleh diubah. Setiap kali anda menggunakan salah satu kaedah dalam kelas

, objek rentetan baharu dicipta dalam ingatan, yang memerlukan ruang baharu untuk diperuntukkan untuk objek baharu. Objek

StringString ialah objek dinamik yang membenarkan bilangan aksara dalam rentetan yang dirangkumi untuk dikembangkan, tetapi anda boleh menentukan nilai untuk bilangan maksimum aksara yang boleh disimpan semasa mengubah suai

. Ia tidak memperuntukkan semula ruang untuk dirinya sendiri sehingga kapasiti dicapai. Apabila kapasiti dicapai, ruang baharu diperuntukkan secara automatik dan kapasiti digandakan. Maksudnya, apabila rentetan ditukar, keadaan objek semasa dikemas kini.

StringBuilderKapasiti kelas StringBuilder boleh ditentukan menggunakan salah satu pembina yang terlebih beban.

StringBuilder2.3 Penukaran bersama antara kelas String dan kelas StringBuilder

Penukaran kelas String ke kelas StringBuilder

Kelas StringBuilder ditukar kepada kelas String

public class String{
    public static void main(String[] args){
        String s = "baibai";
        StringBuilder s1 = new StringBuilder(s);
        System.out.println(s1);
    }}

3 Initialize String class

public class String {
    public static void main(String[] args){
        StringBuilder s1 = new StringBuilder();
        //连续连接
        s1.append("abc").append("efg");
        String s = s1.toString();
        System.out.println(s);
    }}

3.1 Dua kaedah untuk memulakan objek String:

<.>Walaupun kedua-dua kaedah kelihatan sama, pada asasnya ia berbeza. Rentetan yang dicipta oleh String disimpan dalam kolam awam, manakala objek rentetan yang dicipta oleh baru berada pada timbunan. Adakah terdapat sebarang perbezaan antara menyimpannya di kolam awam (kolam malar) dan timbunan?

//方法一：直接创建
String s1= "大聪明 超牛的";
//方法二：对象创建
String s2 = new String("大聪明 超牛的"); 
String s3 = new String();//也可以创建一个空串

Mari kita berikan contoh:

Output:

String s1 = "大聪明 超牛的";              // String 直接创建
String s2 = "大聪明 超牛的";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("大聪明 超牛的");   // String 对象创建
String s5 = new String("大聪明 超牛的");   // String 对象创建
System.out.println(System.identityHashCode(s1));
System.out.println(System.identityHashCode(s2));
System.out.println(System.identityHashCode(s3));
System.out.println(System.identityHashCode(s4));
System.out.println(System.identityHashCode(s5));

Dapat dilihat bahawa alamat tiga rentetan pertama ialah sama, dan alamat dua rentetan terakhir adalah sama.

Ini kerana apabila anda mencipta rentetan secara langsung, anda akan mengetahui terlebih dahulu jika terdapat rentetan sedemikian dalam kolam awam Jika ada, kemudian arahkan rujukan terus kepadanya tanpa membangunkan ruang baharu. Di sini, tiga rujukan s1, s2 dan s3 menunjuk kepada memori yang sama dalam kumpulan awam.
Apabila objek dicipta, ruang baharu akan dibuka pada timbunan untuk menyimpan rentetan setiap kali, dengan kata lain, s4 dan s5 menghala ke dua keping memori yang berbeza pada timbunan, tetapi di dalam dua keping ini. ingatan Semua menyimpan perkara yang sama.

4. API biasa kelas String

Biar saya tekankan sekali lagi bahawa apabila kita menghadapi soalan berkaitan rentetan semasa membuat soalan, kita hampir selalu menggunakan kelas String untuk menyelesaikan masalah, kecuali aksara Kita mungkin gunakan kelas StringBuilder buat sementara waktu apabila membuat sejumlah besar perubahan pada rentetan.

Perkara sementara di sini ialah kita secara amnya masih perlu menukar rentetan ke dalam kelas Rentetan selepas operasi seperti menukar rentetan.

Jadi API yang perlu kita pelajari adalah terutamanya String API. Sepadan dengan API StringBuilder, kita hanya perlu mempelajari dua yang disebutkan di atas.

Kelas rentetan berada di bawah pakej java.lang, jadi tidak perlu mengimport pakej apabila menggunakannya!

4.1 Tukar jenis data asas kepada rentetan Terdapat tiga cara:

（1）基本类型数据的值+“” (最常用，最简单)；
（2）使用包装类中的静态方法 static String toString(int i)返回一个表示指定整数的String 对象。如：在Integer中：Integer.toString(6)；
（3）使用String类中的静态方法 static String valueOf(int i) 返回int 参数的字符串表示形式。如：String.valueOf(6)；

String 类别中已经提供了将基本数据型态转换成String 的 static 方法也就是 String.valueOf() 这个参数多载的方法 :

String.valueOf(boolean b) 
//将 boolean 变量 b 转换成字符串 
String.valueOf(char c) 
//将 char 变量 c 转换成字符串 
String.valueOf(char[] data)
//将 char 数组 data 转换成字符串 
String.valueOf(char[] data, int offset, int count)
//将char数组data中由data[offset]开始取 count个元素转换成字符串 
String.valueOf(double d)
//将 double 变量 d 转换成字符串 
String.valueOf(float f)
//将 float 变量 f 转换成字符串 
String.valueOf(int i)
//将 int 变量 i 转换成字符串 
String.valueOf(long l)
//将 long 变量 l 转换成字符串 
String.valueOf(Object obj)
//将 obj 对象转换成 字符串, 等于 obj.toString()

因为是静态方法所以不需要实例化。

4.2 字符串转换为基本数据类型

一般使用包装类的静态方法parseXX("字符串")

要将 String 转换成基本数据类型大多需要使用基本数据型态的包装类别，如：String 转换成 byte可以使用 Byte.parseByte(String s)

Byte.parseByte(String s)
//将 s 转换成 byte 
Byte.parseByte(String s, int radix)
//以 radix 为基底 将 s 转换为 byte
Double.parseDouble(String s)
//将 s 转换成 double 
Float.parseFloat(String s)
//将 s 转换成 float  
Integer.parseInt(String s)
//将 s 转换成 int 
Long.parseLong(String s)
//将 s 转换成 long

注意这里也是静态方法，只不过都是对应包装类的静态方法

4.3 使用length()得到一个字符串的字符个数

int len = String.length();

4.4 使用toCharArray() 将一个字符串转换成字符数组

Char[] arr = String.toCharArray();

4.5 判断两个字符串的内容是否相等返回true/false

String1.equals(String2);//区分大小写
String1.equalsIgnoreCase(String2);//不区分大小写

4.6 与位置相关的字符串

charAt(int)//得到指定下标位置对应的字符
indexOf(String)//得到指定内容第一次出现的下标
lastIndexOf(String)//得到指定内容最后一次出现的下标

4.7 将一个字符串按照指定内容劈开split(String) ，返回字符串数组。

String s = "wa,dcm,nb!";
String[] str = s.split(",");//返回结果中str[1]=dcm

4.8 contains(String) 判断一个字符串里面是否包含指定的内容，返回true/false

Boolean a = String1.contains(String2)

4.9 使用substring()截取字符串，返回子串

String.substring(int)//从指定下标开始一直截取到字符串的最后
String.substring(int,int)//从下标x截取到下标y-1对应的元素

4.10 字符串大小写转换

String.toUpperCase()
//将一个字符串全部转换成大写
String.toLowerCase()//将一个字符串全部转换成小写

4.11 使用replace()进行字符串内容替换

String.replace(String,String)
//将某个内容全部替换成指定内容
String.replaceAll(String,String)
//将某个内容全部替换成指定内容，支持正则
String.repalceFirst(String,String)
//将第一次出现的某个内容替换成指定的内容

5.字符串进阶练习

387. 字符串中的第一个唯一字符

题解：

把字符串的单个字符转化为对应数组下标，遍历一遍字符串获得26个字母分别出现几次。然后在遍历一遍字符串看哪个字符先出现次数为1，就输出对应下标。

class Solution {        
    public int firstUniqChar(String s) {
        int len = s.length();
        int[] vis = new int[26];
        int temp = -1;
        for(int i = 0; i <p>或者我们也可以把字符串先转换为字符数组来解题，原理都是一样的！</p><pre class="brush:php;toolbar:false">class Solution {
    public int firstUniqChar(String s) {
        int[] arr = new int[26];
        char[] chars = s.toCharArray();
        for (int i = 0; i <p>推荐学习：《<a href="https://www.php.cn/course/list/36.html" target="_blank">java视频教程</a>》</p>

Atas ialah kandungan terperinci Mulakan dengan pantas dengan rentetan struktur data Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!