Auteur: Rukawa Maple Knock Code
Page d' accueil du blog : Blog de Rukawa Kaede
Chronique : Apprendre java avec moi
Citation : Restez affamé, restez stupide
Si vous voulez faire de bonnes choses, vous devez d'abord affûter vos outils. Laissez-moi vous présenter un outil super puissant pour gagner des offres de grands fabricants - Niuke.com
Cliquez pour vous inscrire gratuitement et effleurez les questions avec moi
Annuaire d'articles
1. Construction commune des cordes
2. Comparaison des objets String
1. == compare s'il fait référence au même objet
2. méthode booléenne equals(Object anObject) : comparer dans l'ordre lexicographique
3. méthode int compareTo(String s) : comparer lexicographiquement
4. méthode int compareToIgnoreCase(String str)
int indexOf(int ch, int fromIndex)
int indexOf(String str, int fromIndex)
int lastIndexOf(int ch, int fromIndex)
int lastIndexOf(String str, int fromIndex)
1. Conversion numérique et chaîne
1. Remplacer tout le contenu spécifié
2. Remplacez le premier contenu
2. La chaîne est divisée en groupes de limites dans le format spécifié
1. Intercepter de l'index spécifié à la fin
1. Construction commune des cordes
1. Utilisez une construction constante
2. Construire en utilisant newString
3. Utiliser la construction de tableaux de caractères
public class Test {
public static void main(String[] args) {
//1
String str1 = "hello";
System.out.println(str1);
//2
String str2 = new String("hello");
System.out.println(str2);
//3
char[] chars = {'h','e','l','l','o'};
System.out.println(chars);
}
}
Référence lors de l'utilisation d'autres méthodes : chaîne documentation officielle
Les chaînes ne peuvent pas être héritées , voici le code source de la classe String
value est un tableau de type char, la chaîne est en fait stockée dans le tableau de type char et il n'y a pas de /0 à la fin de la chaîne
String est donc un type de référence et ne stocke pas la chaîne elle-même en interne , voir un exemple :
public class Test {
public static void main(String[] args) {
String str1 = new String("hello");
String str2 = new String("world");
String str3 = str1;
System.out.println(str3);
}
}
str1 et str2 font référence à des objets différents str1 et str3 font référence au même objet
public class Test {
public static void main(String[] args) {
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
}
}
Étant donné que la classe String est un type référence, même si le contenu des chaînes est identique, elles ne sont pas égales. Pour comparer si elles sont égales, la méthode doit être comparée en appelant l'objet.
En Java, "" est également un objet de la classe String.
public class Test {
public static void main(String[] args) {
System.out.println("hello".toString());
}
}
Vous pouvez appeler des méthodes telles que toString()
2. Comparaison des objets String
1. == compare s'il fait référence au même objet
Pour les variables de type primitif, la comparaison est de savoir si la valeur stockée dans les deux variables est la même
Pour les variables de type référence, la comparaison est de savoir si les deux variables de référence font référence au même objet
comme mentionné ci-dessus
2. méthode booléenne equals(Object anObject) : comparer dans l'ordre lexicographique
ordre lexicographique : l'ordre des tailles de caractères
La classe String remplace la méthode equals dans la classe parent Object, et les equals dans Object sont comparés par == par défaut.
La logique de comparaison après réécriture :
public boolean equals(Object anObject) {
//1. 先检测this和anObject是否为同一个对象比较，如果是返回true
if (this == anObject) {
return true;
}
//2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
if (anObject instanceof String) {
//向下转型
String anotherString = (String)anObject;
int n = value.length;
//3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
//4. 按照字典序，从前往后逐个字符进行比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}3. méthode int compareTo(String s) : comparer lexicographiquement
equals renvoie un type booléen, tandis que compareTo renvoie un type int
Comment comparer :
1. Comparez d'abord la taille selon l'ordre du dictionnaire, s'il y a des caractères inégaux, renvoyez directement la différence de taille entre les deux caractères
2. Si les k premiers caractères sont égaux (k est la longueur minimale de deux caractères), la valeur de retour est la différence entre les longueurs des deux chaînes
Voir un exemple :
public class Test {
public static void main(String[] args) {
String str1 = new String("hello");
String str2 = new String("hello");
int ret = str1.compareTo(str2);
if(ret>0){
System.out.println("str1>str2");
} else if (ret==0) {
System.out.println("str1=str2");
}
else {
System.out.println("str1<str2");
}
}
}
Code source:
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
4. méthode int compareToIgnoreCase(String str)
Identique à compareTo, mais ignore la comparaison de casse
public class Test {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); //不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); //相同输出0
System.out.println(s1.compareToIgnoreCase(s4)); //前k个字符完全相同，输出长度差值-3
}
}
3. Recherche de chaînes
Méthodes de recherche courantes fournies par la classe String :
char charAt(int index)
Renvoie le caractère à la position de l'index. Si l'index est négatif ou hors limites, une IndexOutOfBoundsException est levée
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdef");
for (int i= 0; i< s1.length(); i++) {
System.out.println(s1.charAt(i));
}
}
}
int indexOf(int ch)
Renvoie la position de la première occurrence de ch, ne renvoie pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdef");
System.out.println(s1.indexOf('c'));
}
}
int indexOf(int ch, int fromIndex)
Commencez à partir de la position fromIndex pour trouver la position où ch apparaît pour la première fois et ne renvoie pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.indexOf('c',3));
}
}
int indexOf(String str)
Renvoie la position de la première occurrence de str, ne renvoie pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.indexOf("cde"));
}
}
int indexOf(String str, int fromIndex)
Partez de la position fromIndex pour trouver la position où str apparaît pour la première fois, sans retourner -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.indexOf("cde",3));
}
}
int lastIndexOf(int ch)
Recherche de l'arrière vers l'avant, retourne la position où ch apparaît pour la première fois, et ne retourne pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.lastIndexOf("c"));
}
}
int lastIndexOf(int ch, int fromIndex)
En partant de la position fromIndex, en cherchant la position où ch apparaît pour la première fois de l'arrière vers l'avant, il ne retourne pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.lastIndexOf("c",4));
}
}
int lastIndexOf(String str)
Recherche de l'arrière vers l'avant, retourne la position de la première occurrence de str, ne retourne pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.lastIndexOf("abc"));
}
}
int lastIndexOf(String str, int fromIndex)
Commencez à partir de la position fromIndex, recherchez la position où str apparaît pour la première fois de l'arrière vers l'avant et ne renvoie pas -1
public class Test {
public static void main(String[] args) {
String s1 = new String("abcdecf");
System.out.println(s1.lastIndexOf("abc",4));
}
}
4. Transformation
1. Conversion numérique et chaîne
public class Test {
public static void main(String[] args) {
String s1 = String.valueOf(123);
System.out.println(s1);
}
}
Vous pouvez voir qu'il existe de nombreuses méthodes surchargées à utiliser, qui peuvent convertir de nombreux types de valeurs différents en chaînes
2. Conversion de cas
toUpperCase()
toLowerCase(）
public class Test {
public static void main(String[] args) {
String s1 = "hellO嗨";
String ret = s1.toUpperCase();
System.out.println(ret);
}
}
toUpperCase() ne convertira que les minuscules en majuscules, rien d'autre ne changera, tout comme toLowerCase()
3. Chaîne vers tableau
toCharArray()
public class Test {
public static void main(String[] args) {
String str1 = "abcdef";
char[] chars = str1.toCharArray();
System.out.println(Arrays.toString(chars));
}
}
tableau en chaîne
public class Test {
public static void main(String[] args) {
char[] chars = {'h','e','l','l','o'};
String s1 = new String(chars);
System.out.println(s1);
}
}
4. Formatage
String.format()
public class Test {
public static void main(String[] args) {
String s = String.format("%d-%d-%d",2022,8,14);
System.out.println(s);
}
}
5. Remplacement des cordes
Remarque : Les chaînes étant des objets immuables, le remplacement ne modifie pas la chaîne actuelle, mais produit une nouvelle chaîne.
Utilisez une chaîne pour remplacer les données de chaîne existantes, méthode :
1.String replaceAll(String regex, String replacement)
2.String replaceFirst(String regex, String replacement)
1. Remplacer tout le contenu spécifié
public class Test {
public static void main(String[] args) {
String s = "abcadeafagf";
String ret = s.replaceAll("a","c");
System.out.println(s);
System.out.println(ret);
}
}
On peut voir que la chaîne d'origine est inchangée après la chaîne de remplacement et qu'une nouvelle chaîne doit être reçue après le remplacement.
2. Remplacez le premier contenu
public class Test {
public static void main(String[] args) {
String s = "abcadeafagf";
String ret = s.replaceFirst("a","c");
System.out.println(s);
System.out.println(ret);
}
}
6. Séparation des cordes
Diviser une chaîne complète en plusieurs sous-chaînes selon le délimiteur spécifié
Chaîne [] fractionnée (Regex de chaîne)
String[] split(String regex, int limit)
1. Diviser toutes les chaînes
public class Test {
public static void main(String[] args) {
String s = "hello world hello";
String[] ret = s.split(" ");
System.out.println(s);
System.out.println(Arrays.toString(ret));
}
}
2. La chaîne est divisée en groupes de limites dans le format spécifié
public class Test {
public static void main(String[] args) {
String s = "hello world hello";
String[] ret = s.split(" ",2);
System.out.println(s);
System.out.println(Arrays.toString(ret));
}
}
3. "." divisé
public class Test {
public static void main(String[] args) {
String s = "hello.world.hello";
String[] ret = s.split(".");
System.out.println(s);
System.out.println(Arrays.toString(ret));
}
}
Utilisez normalement split(".") pour diviser, nous avons constaté que le tableau d'impression est vide, indiquant que la division n'a pas réussi
Raison : "." doit être échappé, après avoir ajouté "\\.", il peut être divisé
public class Test {
public static void main(String[] args) {
String s = "hello.world.hello";
String[] ret = s.split("\\.");
System.out.println(s);
System.out.println(Arrays.toString(ret));
}
}
Résumer:
1. Les caractères "|", "*", "+" doivent être échappés, précédés de "\\"
2. Si c'est "\", alors il doit être écrit comme "\\\\"
3. S'il y a plusieurs séparateurs dans une chaîne, vous pouvez utiliser "|" comme trait d'union, c'est-à-dire que s.split("=|&"); consiste à diviser la chaîne s par = et &
7. Interception de cordes
Sous-chaîne de chaîne (int beginIndex)
Sous-chaîne de chaîne (int index de début, int index de fin)
1. Intercepter de l'index spécifié à la fin
public class Test {
public static void main(String[] args) {
String s = "hello world";
String ret = s.substring(5);
System.out.println(s);
System.out.println(ret);
}
}
2. Intercepter du contenu
public class Test {
public static void main(String[] args) {
String s = "hello world";
String ret = s.substring(0,5);
System.out.println(s);
System.out.println(ret);
}
}
Résumer:
1. L'indice commence à 0
2. Faites attention à la méthode d'écriture de l'intervalle avant-fermé et arrière-ouvert, la sous-chaîne (0, 5) signifie le caractère avec l'indice 0, à l'exclusion de l'indice 5
8. Garniture de chaîne()
Fonction : supprimer les espaces gauche et droit dans la chaîne, conserver les espaces du milieu
public class Test {
public static void main(String[] args) {
String s = " hello world ";
String ret = s.trim();
System.out.println(s);
System.out.println(ret);
}
}
Résumer:
Nous avons remarqué que la plupart des méthodes de la classe String ne manipulent pas directement la chaîne d'origine, mais renvoient une nouvelle chaîne
« Le partage de ce numéro est là, pensez à donner un trois-lien au blogueur, votre soutien est le plus grand moteur de ma création !