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 String.charAt(2). Existe-t-il une fonction intégrée pour supprimer un caractère individuel d'une chaîne en java?

Quelque chose comme ça:

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

Vous pouvez également utiliser la StringBuilderclasse qui est mutable.

StringBuilder sb = new StringBuilder(inputString);

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

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

String resultString = sb.toString();

Cela évite la création d'objets chaîne inutiles.

Une possibilité:

String result = str.substring(0, index) + str.substring(index+1);

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

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

String a = "Cool";
a = a.replace("o","");

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 idxdans la chaîne str, faites quelque chose comme ceci, et rappelez-vous qu'une nouvelle chaîne sera créée:

String newstr = str.substring(0, idx) + str.substring(idx + 1);

String str = "M1y java8 Progr5am";

deleteCharAt ()

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

remplacer()

StringBuffer buffer = new StringBuffer(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();
String 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 String removeChar(String str, Integer n) {
    String front = str.substring(0, n);
    String back = str.substring(n+1, str.length());
    return front + back;
}

Vous pouvez également utiliser la (énorme) machine d'expression régulière.

inputString = inputString.replaceFirst("(?s)(.{2}).(.*)", "$1$2");

• "(?s)" - dit à regexp de gérer les nouvelles lignes comme des caractères normaux (juste au cas où).
• "(.{2})" - groupe 1 $ collectant exactement 2 caractères
• "." - tout caractère à l'index 2 (à extraire).
• "(.*)" - group $ 2 qui collecte le reste de la chaîne d'entrée.
• "$1$2" - mettre ensemble le groupe 1 $ et le groupe 2 $.

Pour modifier des chaînes, lisez à propos de StringBuilder car il est modifiable à l'exception de String immuable. Différentes opérations peuvent être trouvées ici https://docs.oracle.com/javase/tutorial/java/data/buffers.html . L'extrait de code ci-dessous crée un StringBuilder, puis ajoute le String donné, puis supprime le premier caractère de String, puis le reconvertit de StringBuilder en String.

StringBuilder sb = new StringBuilder();

sb.append(str);
sb.deleteCharAt(0);
str = sb.toString();

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

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

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

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

En utilisant la méthode replace, nous pouvons changer un seul caractère de chaîne.

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

Le moyen le plus simple de supprimer un caractère d'une chaîne

String str="welcome";
str=str.replaceFirst(String.valueOf(str.charAt(2)),"");//'l' will replace with "" 
System.out.println(str);//output: wecome

public class RemoveCharFromString {
    public static void main(String[] args) {
        String output = remove("Hello", 'l');
        System.out.println(output);
    }

    private static String remove(String 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);

    }
}

Dans la plupart des cas d'utilisation, l'utilisation de StringBuilderou substringest une bonne approche (comme déjà répondu). Cependant, pour le code critique de performances, cela peut être une bonne alternative.

/**
 * Delete a single character from index position 'start' from the 'target' String.
 * 
 * ````
 * deleteAt("ABC", 0) -> "BC"
 * deleteAt("ABC", 1) -> "B"
 * deleteAt("ABC", 2) -> "C"
 * ````
 */
public static String deleteAt(final String target, final int start) {
    return deleteAt(target, start, start + 1);
} 


/**
 * Delete the characters from index position 'start' to 'end' from the 'target' String.
 * 
 * ````
 * deleteAt("ABC", 0, 1) -> "BC"
 * deleteAt("ABC", 0, 2) -> "C"
 * deleteAt("ABC", 1, 3) -> "A"
 * ````
 */
public static String deleteAt(final String 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 StringBuilder et deletecharAt.

String s1 = "aabc";
StringBuilder sb = new StringBuilder(s1);
for(int i=0;i<sb.length();i++)
{
  char temp = sb.charAt(0);
  if(sb.indexOf(temp+"")!=1)
  {                             
    sb.deleteCharAt(sb.indexOf(temp+""));   
  }
}

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

Par exemple,

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

Production

Before : helloworld
After : heloworld

Si vous souhaitez supprimer char d'une chaîne str à un spécifique int index :

    public static String removeCharAt(String str, int index) {

        // The part of the String before the index:
        String str1 = str.substring(0,index);

        // The part of the String after the index:            
        String str2 = str.substring(index+1,str.length());

        // These two parts together gives the String without the specified index
        return str1+str2;

    }

public static String removechar(String fromString, Character character) {
    int indexOf = fromString.indexOf(character);
    if(indexOf==-1) 
        return fromString;
    String front = fromString.substring(0, indexOf);
    String back = fromString.substring(indexOf+1, fromString.length());
    return front+back;
}

           BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
   String line1=input.readLine();
   String line2=input.readLine();
         char[]  a=line2.toCharArray();
          char[] b=line1.toCharArray();
           loop: for(int t=0;t<a.length;t++) {

            char a1=a[t];
           for(int t1=0;t1<b.length;t1++) {
               char b1=b[t1];  
               if(a1==b1) {
                   StringBuilder sb = new StringBuilder(line1);
                   sb.deleteCharAt(t1);
                   line1=sb.toString();
                   b=line1.toCharArray();
                   list.add(a1);
                   continue  loop;   
               }


            }

Quand j'ai ce genre de questions, je me demande toujours: "Que feraient les gourous de Java?" :)

Et je répondrais à cela, dans ce cas, en examinant la mise en œuvre de String.trim().

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

Cependant, notez que le découpage d'origine supprime en fait tous les caractères qui le sont <= ' ', vous devrez donc peut-être le combiner avec l'original pour obtenir le résultat souhaité.

String trim(String string, String toTrim) {
    // input checks removed
    if (toTrim.length() == 0)
        return string;

    final char[] trimChars = toTrim.toCharArray();
    Arrays.sort(trimChars);

    int start = 0;
    int end = string.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 string.substring(start, end);
}

public String missingChar(String str, int n) {
  String front = str.substring(0, n);

// Start this substring at n+1 to omit the char.
// Can also be shortened to just str.substring(n+1)
// which goes through the end of the string.

String back = str.substring(n+1, str.length());
  return front + back;
}

Pour supprimer un caractère unique de la chaîne donnée, veuillez trouver ma méthode en espérant qu'elle sera utile. J'ai utilisé str.replaceAll pour supprimer la chaîne, mais il existe de nombreuses façons de supprimer un caractère d'une chaîne donnée, mais je préfère la méthode replaceall.

Code pour supprimer le caractère:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;


public class Removecharacter 
{

    public static void main(String[] args) 
    {
        String result = removeChar("Java", 'a');
        String result1 = removeChar("Edition", 'i');

         System.out.println(result + " " + result1);

    }


    public static String removeChar(String str, char c) {
        if (str == null)
        {
            return null;
        }
        else
        {   
        return str.replaceAll(Character.toString(c), "");
        }
    }


}

Image de la console:

veuillez trouver l'image ci-jointe de la console,

Merci d'avoir posé la question. :)

Je viens d'implémenter cette classe utilitaire qui supprime un caractère ou un groupe de caractères d'une chaîne . Je pense que c'est rapide car il n'utilise pas Regexp. J'espère que ça aide quelqu'un!

package your.package.name;

/**
 * Utility class that removes chars from a String.
 * 
 */
public class RemoveChars {

    public static String remove(String string, String remove) {
        return new String(remove(string.toCharArray(), remove.toCharArray()));
    }

    public static char[] remove(final char[] chars, char[] remove) {

        int count = 0;
        char[] buffer = new char[chars.length];

        for (int i = 0; i < chars.length; i++) {

            boolean include = true;
            for (int j = 0; j < remove.length; j++) {
                if ((chars[i] == remove[j])) {
                    include = false;
                    break;
                }
            }

            if (include) {
                buffer[count++] = chars[i];
            }
        }

        char[] output = new char[count];
        System.arraycopy(buffer, 0, output, 0, count);

        return output;
    }

    /**
     * For tests!
     */
    public static void main(String[] args) {

        String string = "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG";
        String remove = "AEIOU";

        System.out.println();
        System.out.println("Remove AEIOU: " + string);
        System.out.println("Result:       " + RemoveChars.remove(string, remove));
    }
}

Voici la sortie:

Remove AEIOU: THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
Result:       TH QCK BRWN FX JMPS VR TH LZY DG

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

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