Comment supprimer un seul caractère d’une chaîne

Pour accéder aux caractères individuels d’une chaîne en Java, nous avons Ssortingng.charAt(2) . Existe-t-il une fonction intégrée pour supprimer un caractère individuel d’une chaîne dans java?

Quelque chose comme ça:

 if(Ssortingng.charAt(1) == Ssortingng.charAt(2){ //I want to remove the individual character at index 2. } 

Vous pouvez également utiliser la classe SsortingngBuilder qui est mutable.

 SsortingngBuilder sb = new SsortingngBuilder(inputSsortingng); 

Il a la méthode deleteCharAt() , ainsi que de nombreuses autres méthodes de mutation.

Supprimez simplement les caractères à supprimer, puis obtenez le résultat comme suit:

 Ssortingng resultSsortingng = sb.toSsortingng(); 

Cela évite la création d’objects de chaîne inutiles.

Une possibilité:

 Ssortingng result = str.subssortingng(0, index) + str.subssortingng(index+1); 

Notez que le résultat est une nouvelle chaîne (ainsi que deux objects Ssortingng intermédiaires), car les chaînes en Java sont immuables.

Vous pouvez utiliser la méthode Java Ssortingng appelée replace, qui remplacera tous les caractères correspondant au premier paramètre par le second paramètre:

 Ssortingng a = "Cool"; a = a.replace("o",""); //variable 'a' contains the ssortingng "Cl" 

Non, car les chaînes en Java sont immuables. Vous devrez créer une nouvelle chaîne en supprimant le caractère que vous ne voulez pas.

Pour remplacer un seul caractère c à la position d’index idx dans la chaîne str , faites quelque chose comme ça et rappelez-vous qu’une nouvelle chaîne sera créée:

 Ssortingng newstr = str.subssortingng(0, idx) + str.subssortingng(idx + 1); 
 Ssortingng str = "M1y java8 Progr5am"; 

deleteCharAt ()

 SsortingngBuilder bulid = new SsortingngBuilder(str); bulid.deleteCharAt(1); // Shift the positions front. bulid.deleteCharAt(8-1); bulid.deleteCharAt(15-2); System.out.println("Builder : "+bulid); 

remplacer()

 SsortingngBuffer buffer = new SsortingngBuffer(str); buffer.replace(1, 2, ""); // Shift the positions front. buffer.replace(7, 8, ""); buffer.replace(13, 14, ""); System.out.println("Buffer : "+buffer); 

carboniser[]

 char[] c = str.toCharArray(); Ssortingng new_Str = ""; for (int i = 0; i < c.length; i++) { if (!(i == 1 || i == 8 || i == 15)) new_Str += c[i]; } System.out.println("Char Array : "+new_Str); 

Considérez le code suivant:

 public Ssortingng removeChar(Ssortingng str, Integer n) { Ssortingng front = str.subssortingng(0, n); Ssortingng back = str.subssortingng(n+1, str.length()); return front + back; } 

Vous pouvez également utiliser la machine regexp (énorme).

 inputSsortingng = inputSsortingng.replaceFirst("(?s)(.{2}).(.*)", "$1$2"); 
  • "(?s)" - Indique à regexp de gérer les nouvelles lignes comme les caractères normaux (juste au cas où).
  • "(.{2})" - groupe $ 1 recueillant exactement 2 caractères
  • "." - "." - tout caractère à l’index 2 (à extraire).
  • "(.*)" - groupe $ 2 qui collecte le rest de la chaîne inputSsortingng.
  • "$1$2" - regroupant le groupe 1 $ et le groupe 2 $.

Utilisez la fonction replaceFirst de la classe Ssortingng. Il existe tellement de variantes de la fonction de remplacement que vous pouvez utiliser.

Si vous avez besoin de contrôle logique sur la suppression de caractères, utilisez ceci

 Ssortingng ssortingng = "sdsdsd"; char[] arr = ssortingng.toCharArray(); // Run loop or whatever you need Ssortingng ss = new Ssortingng(arr); 

Si vous n’avez pas besoin d’un tel contrôle, vous pouvez utiliser ce qu’Oscar ou Bhesh a mentionné. Ils sont sur place.

Par la méthode using replace, nous pouvons changer le caractère unique de la chaîne.

 ssortingng= ssortingng.replace("*", ""); 

La manière la plus simple de retirer un caractère de la chaîne

 Ssortingng str="welcome"; str=str.replaceFirst(Ssortingng.valueOf(str.charAt(2)),"");//'l' will replace with "" System.out.println(str);//output: wecome 
 public class RemoveCharFromSsortingng { public static void main(Ssortingng[] args) { Ssortingng output = remove("Hello", 'l'); System.out.println(output); } private static Ssortingng remove(Ssortingng input, char c) { if (input == null || input.length() < = 1) return input; char[] inputArray = input.toCharArray(); char[] outputArray = new char[inputArray.length]; int outputArrayIndex = 0; for (int i = 0; i < inputArray.length; i++) { char p = inputArray[i]; if (p != c) { outputArray[outputArrayIndex] = p; outputArrayIndex++; } } return new String(outputArray, 0, outputArrayIndex); } } 
 public static Ssortingng removechar(Ssortingng fromSsortingng, Character character) { int indexOf = fromSsortingng.indexOf(character); if(indexOf==-1) return fromSsortingng; Ssortingng front = fromSsortingng.subssortingng(0, indexOf); Ssortingng back = fromSsortingng.subssortingng(indexOf+1, fromSsortingng.length()); return front+back; } 
  BufferedReader input=new BufferedReader(new InputStreamReader(System.in)); Ssortingng line1=input.readLine(); Ssortingng line2=input.readLine(); char[] a=line2.toCharArray(); char[] b=line1.toCharArray(); loop: for(int t=0;t 

Dans la plupart des cas d’utilisation de SsortingngBuilder ou de la subssortingngsubssortingng est une bonne approche (comme déjà répondu). Cependant, pour le code de performance critique, cela pourrait être une bonne alternative.

 /** * Delete a single character from index position 'start' from the 'target' Ssortingng. * * ```` * deleteAt("ABC", 0) -> "BC" * deleteAt("ABC", 1) -> "B" * deleteAt("ABC", 2) -> "C" * ```` */ public static Ssortingng deleteAt(final Ssortingng target, final int start) { return deleteAt(target, start, start + 1); } /** * Delete the characters from index position 'start' to 'end' from the 'target' Ssortingng. * * ```` * deleteAt("ABC", 0, 1) -> "BC" * deleteAt("ABC", 0, 2) -> "C" * deleteAt("ABC", 1, 3) -> "A" * ```` */ public static Ssortingng deleteAt(final Ssortingng target, final int start, int end) { final int targetLen = target.length(); if (start < 0) { throw new IllegalArgumentException("start=" + start); } if (end > targetLen || end < start) { throw new IllegalArgumentException("end=" + end); } if (start == 0) { return end == targetLen ? "" : target.substring(end); } else if (end == targetLen) { return target.substring(0, start); } final char[] buffer = new char[targetLen - end + start]; target.getChars(0, start, buffer, 0); target.getChars(end, targetLen, buffer, start); return new String(buffer); } 

* Vous pouvez supprimer la valeur de chaîne en utilisant SsortingngBuilder et deletecharAt.

 Ssortingng s1 = "aabc"; SsortingngBuilder sb = new SsortingngBuilder(s1); for(int i=0;i 

Quand j’ai ce genre de questions, je demande toujours: “Que feraient les gourous de Java?” 🙂

Et je répondrais à cela, dans ce cas, en regardant l’implémentation de Ssortingng.sortingm() .

Voici une extrapolation de cette implémentation qui permet d’utiliser plus de caractères de découpe.

Cependant, notez que le découpage original supprime tous les caractères < = ' ' , vous devrez donc combiner cela avec l'original pour obtenir le résultat souhaité.

 Ssortingng sortingm(Ssortingng ssortingng, Ssortingng toTrim) { // input checks removed if (toTrim.length() == 0) return ssortingng; final char[] sortingmChars = toTrim.toCharArray(); Arrays.sort(sortingmChars); int start = 0; int end = ssortingng.length(); while (start < end && Arrays.binarySearch(trimChars, string.charAt(start)) >= 0) start++; while (start < end && Arrays.binarySearch(trimChars, string.charAt(end - 1)) >= 0) end--; return ssortingng.subssortingng(start, end); } 

Oui. Nous avons une fonction intégrée pour supprimer un caractère individuel d’une chaîne dans java, c’est-à-dire deleteCharAt

Par exemple,

 public class SsortingngBuilderExample { public static void main(Ssortingng[] args) { SsortingngBuilder sb = new SsortingngBuilder("helloworld"); System.out.println("Before : " + sb); sb = sb.deleteCharAt(3); System.out.println("After : " + sb); } } 

Sortie

 Before : helloworld After : heloworld 
 public Ssortingng missingChar(Ssortingng str, int n) { Ssortingng front = str.subssortingng(0, n); // Start this subssortingng at n+1 to omit the char. // Can also be shortened to just str.subssortingng(n+1) // which goes through the end of the ssortingng. Ssortingng back = str.subssortingng(n+1, str.length()); return front + back; } 

Par exemple, si vous souhaitez calculer le nombre de a dans la chaîne, vous pouvez le faire comme ceci:

 if (ssortingng.contains("a")) { numberOf_a++; ssortingng = ssortingng.replaceFirst("a", ""); }