Beginnen Sie schnell mit Java-Datenstrukturzeichenfolgen

Dieser Artikel bringt Ihnen relevantes Wissen über Java, das hauptsächlich verwandte Themen zu Strings vorstellt. Ein String ist eine begrenzte Sequenz, die aus null oder mehr Zeichen besteht, auch bekannt als String. Schauen wir uns das an es hilft allen.

Empfohlenes Lernen: „Java-Video-Tutorial“

1. Grundkenntnisse über Zeichenfolgen

Eine Zeichenfolge ist eine begrenzte Folge, die aus null oder mehr Zeichen besteht und auch als Zeichenfolge bezeichnet wird.

Aus diesem Grundkonzept können wir Folgendes erkennen:

• Null oder mehr Zeichen: Dies bedeutet, dass der interne Elementtyp der Zeichenfolge Zeichen ist.
• Begrenzt: Dies bedeutet, dass die Inhaltslänge der Zeichenfolge begrenzt ist, weniger als ein maximaler Bereich, aber innerhalb dieses Bereichs ist die tatsächliche Länge ungewiss.
• Sequenz: Es zeigt, dass benachbarte Zeichen in der Zeichenfolge eine Vorgänger- und Nachfolgerbeziehung haben.

In Java gibt es keinen integrierten String-Typ. Jeder in doppelte Anführungszeichen eingeschlossene String ist eine Instanz der String-Klasse in Java.

Das heißt, String ist kein Datentyp in Java. Alle Strings in Java sind instanziierte Objekte von String.

String in Java

Die String-Klasse in Java stellt einen String dar, und alle String-Literale (z. B. „abc“) in Java-Programmen sind Instanzen dieser Klasse.

Mit anderen Worten: Alle Zeichenfolgen in doppelten Anführungszeichen in Java-Programmen sind Objekte der String-Klasse. Die String-Klasse befindet sich im Paket java.lang, daher ist es nicht erforderlich, das Paket zu importieren, wenn Sie es verwenden!

Das wichtigste Merkmal von String in Java ist:

Die String-Klasse ist unveränderlich. Sobald Sie also ein String-Objekt erstellt haben, kann sein Wert nicht mehr geändert werden. Wir nennen diese Eigenschaft die Unveränderlichkeit von String.

Unveränderlichkeit von Strings

Unveränderlichkeit: Wenn Sie einem String einen Wert neu zuweisen, wird der alte Wert nicht im Speicher zerstört, sondern es wird neu ein Platz zum Speichern des neuen Werts geöffnet.

Das heißt, sobald ein String-Objekt im Speicher erstellt wird, ist es unveränderlich. Alle Methoden in der String-Klasse ändern nicht das String-Objekt selbst, sondern erstellen ein neues String-Objekt. 所有的String类中方法并不是改变String对象自己，而是重新创建一个新的String对象。

例如：

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

当s的值发生改变之后，ddccmm这个值并没有覆盖dcm，只是重新开发了一个新的空间去储存ddccmm然后将s指向它。

如果我们在实际开发中对很含有大量字符的字符串进行遍历赋值修改，会对内存中产生很多无法释放的字符串对象，造成内存垃圾。

正因为String对象的不可变性，如果需要对字符串进行大量的修改、添加字符、删除字符等操作尽量不要使用String对象，因为这样会频繁的创建新的对象导致程序的执行效率下降。

这时我们可以使用Java中另外一个字符串类StringBuilder。

我们在做题的时候关于字符串一般用的都是String类，但是考虑到我们有时候也会用到StringBuilder类这里我就对StringBuilder类进行稍微细致一点的讲解。

2.StringBuilder类

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指StringBuilder对象中的内容是可变的。

2.1 StringBuilder类常用的方法

可以看出来，构建一个StringBuilder的对象只能使用它的构造方法来构造，不像String一样可以直接String s= "123"来创建

因为StringBuilder类对象是可变的，所以当我们对一个字符串需要进行改变比较多的时候一般定义为StringBuilder类。

2.2 String和StringBuilder的区别

String 对象是不可改变的。每次使用String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。

StringBuilder对象是动态对象，允许扩充它所封装的字符串中字符的数量，但是您可以为它可容纳的最大字符数指定一个值，当修改 StringBuilder 时，在达到容量之前，它不会为其自己重新分配空间。当达到容量时，将自动分配新的空间且容量翻倍。也就是说当对字符串进行改变时，都是对当前对象的状态进行更新的。

可以使用重载的构造函数之一来指定 StringBuilder

Zum Beispiel:

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

Wenn sich der Wert von s ändert, deckt der Wert von ddccmm dcm nicht ab. Es entsteht lediglich ein neuer Speicherplatz zum Speichern von ddccmm und zeigt s darauf. Wenn wir in der tatsächlichen Entwicklung eine Zeichenfolge durchlaufen, zuweisen und ändern, die eine große Anzahl von Zeichen enthält, werden im Speicher viele Zeichenfolgenobjekte generiert, die nicht freigegeben werden können, was zu Speichermüll führt.

Aufgrund der Unveränderlichkeit des String-Objekts sollten Sie das String-Objekt nicht verwenden, wenn Sie viele Änderungen an der Zeichenfolge vornehmen, Zeichen hinzufügen, Zeichen löschen usw. müssen, da dadurch häufig neue Objekte erstellt werden die Ausführungseffizienz des Programms verringern.

Zu diesem Zeitpunkt können wir StringBuilder verwenden, eine weitere String-Klasse in Java.

Wenn wir Fragen stellen, verwenden wir im Allgemeinen die String-Klasse für Zeichenfolgen. Da wir jedoch manchmal die StringBuilder-Klasse verwenden, werde ich die StringBuilder-Klasse etwas ausführlicher erläutern.

2. Die StringBuilder-Klasse

StringBuilder ist eine

VariableString-Klasse. Die Variable hier bezieht sich auf den Inhalt von Das /code>r-Objekt ist veränderbar.

2.1 Häufig verwendete Methoden der StringBuilder-Klasse

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

Nach dem Login kopieren

Obwohl die beiden Methoden gleich aussehen, unterscheiden sie sich im Wesentlichen.

Von String erstellte Zeichenfolgen werden im öffentlichen Pool gespeichert, während von new erstellte Zeichenfolgenobjekte auf dem Heap liegen. Gibt es einen Unterschied zwischen der Speicherung im öffentlichen Pool (konstanter Pool) und dem Heap?

Lassen Sie uns ein Beispiel geben:

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

Ausgabe:

Es ist ersichtlich, dass die Adressen der ersten drei Zeichenfolgen gleich sind und die letzten beiden unterschiedlich sind!

Dies liegt daran, dass Sie beim direkten Erstellen einer Zeichenfolge zunächst herausfinden, ob eine solche Zeichenfolge im öffentlichen Pool vorhanden ist. Wenn dies der Fall ist, verweisen Sie direkt darauf, ohne einen neuen Bereich zu entwickeln. Hier verweisen die drei Referenzen von s1, s2 und s3 auf denselben Speicher im öffentlichen Pool.

🎜Wenn ein Objekt erstellt wird, wird jedes Mal ein neuer Speicherplatz auf dem Heap geöffnet, um Zeichenfolgen zu speichern. Das heißt, s4 und s5 verweisen jeweils auf zwei verschiedene Speicher auf dem Heap, aber beide speichern denselben Speicher. etwas. 🎜🎜4. Häufig verwendete APIs der String-Klasse🎜🎜Ich möchte noch einmal betonen, dass wir bei der Bearbeitung von Fragen fast immer die String-Klasse verwenden, um das Problem zu lösen, außer wenn es eine große Anzahl von Änderungen gibt Um den String zu erstellen, verwenden wir möglicherweise vorerst die StringBuilder-Klasse. 🎜🎜Das Vorübergehende hier ist, dass wir den String nach Operationen wie dem Ändern des Strings im Allgemeinen immer noch in die String-Klasse konvertieren müssen. 🎜🎜Die API, die wir lernen müssen, ist also hauptsächlich die String-API. Entsprechend der StringBuilder-API müssen wir nur die beiden oben genannten lernen. 🎜🎜🎜Die String-Klasse befindet sich im Paket java.lang, daher ist es nicht erforderlich, das Paket zu importieren, wenn Sie es verwenden! 🎜🎜🎜4.1 Es gibt drei Möglichkeiten, grundlegende Datentypen in Zeichenfolgen umzuwandeln: 🎜

（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>

Das obige ist der detaillierte Inhalt vonBeginnen Sie schnell mit Java-Datenstrukturzeichenfolgen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!