Démarrez rapidement avec les chaînes de structure de données Java

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement des problèmes liés aux chaînes. Une chaîne est une séquence limitée composée de zéro ou plusieurs caractères, également appelée chaîne. Parlons-en ensemble, j'espère. ça aide tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

1. Connaissance de base des chaînes

Une chaîne est une séquence limitée composée de zéro ou plusieurs caractères, également appelée chaîne.

On peut savoir à partir de ce concept de base :

• Zéro ou plusieurs caractères : Cela signifie que le type d'élément interne de la chaîne est caractère.
• Limitée : cela signifie que la longueur du contenu de la chaîne est limitée, inférieure à une plage maximale, mais dans cette plage, la longueur réelle est incertaine.
• Séquence : elle montre que les caractères adjacents dans la chaîne ont une relation de prédécesseur et de successeur.

Il n'y a pas de type de chaîne intégré en Java, chaque chaîne entourée de guillemets doubles est une instance de la classe String en Java.

C'est-à-dire que String n'est pas un type de données en Java. Toutes les chaînes en Java sont des objets instanciés de String.

String en Java

La classe String en Java représente une chaîne, et tous les littéraux de chaîne (tels que "abc") dans les programmes Java sont des instances de cette classe.

En d'autres termes, toutes les chaînes entre guillemets dans les programmes Java sont des objets de la classe String. La classe String se trouve sous le package java.lang, il n'est donc pas nécessaire d'importer le package lors de son utilisation !

La fonctionnalité la plus importante de String en Java est la suivante :

La classe String est immuable, donc une fois que vous créez un objet String, sa valeur ne peut pas être modifiée. Nous appelons cette propriété immuabilité de String.

Immuabilité des chaînes

Immuabilité : Lorsque vous réaffectez une valeur à une chaîne, l'ancienne valeur n'est pas détruite dans la mémoire, mais un espace est nouvellement ouvert pour stocker la nouvelle valeur.

C'est-à-dire qu'une fois qu'un objet String est créé en mémoire, il sera immuable Toutes les méthodes de la classe String ne modifient pas l'objet String lui-même, mais recréent un nouvel objet String. 所有的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

Par exemple :

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

Lorsque la valeur de s change, la valeur de ddccmm ne couvre pas dcm. Elle développe simplement un nouvel espace pour stocker ddccmm et pointe s vers lui. Si nous parcourons, attribuons et modifions une chaîne contenant un grand nombre de caractères en développement réel, de nombreux objets chaîne qui ne peuvent pas être libérés seront générés dans la mémoire, provoquant des déchets de mémoire.

En raison de l'immuabilité de l'objet String, si vous devez apporter un grand nombre de modifications à la chaîne, ajouter des caractères, supprimer des caractères, etc., essayez de ne pas utiliser l'objet String, car cela créera fréquemment de nouveaux objets et réduire l’efficacité d’exécution du programme.

Pour le moment, nous pouvons utiliser StringBuilder, une autre classe de chaînes en Java.

Lorsque nous posons des questions, nous utilisons généralement la classe String pour les chaînes, mais étant donné que nous utilisons parfois la classe StringBuilder, je vais expliquer la classe StringBuilder un peu plus en détail.

2. La classe StringBuilder

StringBuilder est une classe

variablestring Nous pouvons la considérer comme un conteneur. La variable fait ici référence à StringBuilde<. les objets>r sont mutables. </.>

2.1 Méthodes couramment utilisées de la classe StringBuilder

On peut voir que la construction d'un objet de StringBuilder ne peut être construite qu'en utilisant sa méthode de construction, contrairement à String qui peut être directement String s= "123" pour créer Parce que l'objet de classe StringBuilder est variable, lorsque nous devons beaucoup changer une chaîne, il est généralement défini comme StringBuilder classe.

2.2 La différence entre les objets String et StringBuilder

String est immuable. Chaque fois que vous utilisez l'une des méthodes de la classe String, un nouvel objet chaîne est créé en mémoire, ce qui nécessite l'allocation d'un nouvel espace pour le nouvel objet.

L'objet StringBuilder est un objet dynamique qui permet d'étendre le nombre de caractères dans la chaîne qu'il encapsule, mais vous pouvez spécifier une valeur pour le nombre maximum de caractères qu'il peut contenir lors de la modification de StringBuilder, il ne se réattribuera pas d'espace jusqu'à ce que la capacité soit atteinte. Lorsque la capacité est atteinte, un nouvel espace est automatiquement alloué et la capacité est doublée. C'est-à-dire que lorsque la chaîne est modifiée, l'état de l'objet courant est mis à jour. <p></p>La capacité de la classe <code>StringBuilder peut être spécifiée à l'aide de l'un des constructeurs surchargés.

2.3 Conversion entre la classe String et la classe StringBuilder

Convertir la classe String en classe StringBuilder

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

Convertir la classe StringBuilder en classe String

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

3. Initialiser la classe String

🎜 des objets String Deux méthodes : 🎜🎜

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

🎜Bien que les deux méthodes se ressemblent, elles sont essentiellement différentes. 🎜 Les chaînes créées par String sont stockées dans le pool public, tandis que les objets chaîne créés par new sont sur le tas. Y a-t-il une différence entre le stocker dans le pool public (pool constant) et dans le tas ? 🎜🎜🎜Donnons un exemple : 🎜🎜

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()

🎜Sortie : 🎜🎜🎜 On voit que les adresses des trois premières chaînes sont les mêmes, et les deux dernières sont différentes ! 🎜🎜En effet, lorsque vous créez directement une chaîne, vous découvrirez d'abord s'il existe une telle chaîne dans le pool public. Si c'est le cas, pointez directement la référence vers elle sans développer un nouvel espace. Ici, les trois références s1, s2 et s3 pointent vers la même mémoire dans le pool public. 🎜🎜Lorsqu'un objet est créé, un nouvel espace sera ouvert sur le tas pour stocker les chaînes à chaque fois. C'est-à-dire que s4 et s5 pointent respectivement vers deux mémoires différentes sur le tas, mais toutes deux stockent la même mémoire. quelque chose. 🎜🎜4. API couramment utilisées de la classe String🎜🎜Je voudrais souligner à nouveau que lorsque nous rencontrons des questions liées aux chaînes lors de la rédaction de questions, nous utilisons presque toujours la classe String pour résoudre le problème, sauf en cas de grand nombre de changements. sont apportées à la chaîne, nous pouvons Pour le moment, la classe StringBuilder est utilisée. 🎜🎜La chose temporaire ici est que nous devons généralement toujours convertir la chaîne en classe String après des opérations telles que la modification de la chaîne. 🎜🎜Donc, l'API que nous devons apprendre est principalement l'API String. Correspondant à l'API de StringBuilder, il suffit d'apprendre les deux cités ci-dessus. 🎜🎜🎜La classe String se trouve sous le package java.lang, il n'est donc pas nécessaire d'importer le package lors de son utilisation ! 🎜🎜🎜4.1 Il existe trois façons de convertir des types de données de base en chaînes🎜🎜 :🎜

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!