Come rimuovere un singolo carattere da una stringa

Per accedere ai singoli caratteri di una stringa in Java, abbiamo String.charAt(2). Esiste una funzione integrata per rimuovere un singolo carattere di una stringa in Java?

Qualcosa come questo:

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

Puoi anche usare la StringBuilderclasse che è mutabile.

StringBuilder sb = new StringBuilder(inputString);

Ha il metodo deleteCharAt(), insieme a molti altri metodi mutatori.

Basta eliminare i caratteri che è necessario eliminare e quindi ottenere il risultato come segue:

String resultString = sb.toString();

Ciò evita la creazione di oggetti stringa non necessari.

Una possibilità:

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

Si noti che il risultato è una nuova stringa (oltre a due oggetti String intermedi), poiché le stringhe in Java sono immutabili.

È possibile utilizzare il metodo String Java chiamato sostituisci, che sostituirà tutti i caratteri corrispondenti al primo parametro con il secondo parametro:

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

No, perché le stringhe in Java sono immutabili. Dovrai creare una nuova stringa rimuovendo il carattere che non desideri.

Per sostituire un singolo carattere cnella posizione di indice idxnella stringa str, fai qualcosa del genere e ricorda che verrà creata una nuova stringa:

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

sostituire()

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

char []

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

Considera il seguente codice:

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

Puoi anche usare la (enorme) macchina regexp.

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

• "(?s)" - dice a regexp di gestire le nuove righe come caratteri normali (per ogni evenienza).
• "(.{2})" - gruppo $ 1 che raccoglie esattamente 2 caratteri
• "." - qualsiasi carattere all'indice 2 (da eliminare).
• "(.*)" - gruppo $ 2 che raccoglie il resto di inputString.
• "$1$2" - mettendo insieme il gruppo $ 1 e il gruppo $ 2.

Per modificare le stringhe, leggi StringBuilder perché è modificabile ad eccezione di String immutabile. Diverse operazioni sono disponibili qui https://docs.oracle.com/javase/tutorial/java/data/buffers.html . Lo snippet di codice seguente crea StringBuilder, quindi aggiunge la stringa specificata, quindi elimina il primo carattere dalla stringa e lo converte da StringBuilder a String.

StringBuilder sb = new StringBuilder();

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

Utilizzare la funzione di sostituzione della classe String. Ci sono così tante varianti della funzione di sostituzione che puoi usare.

Se hai bisogno di un controllo logico sulla rimozione del personaggio, usa questo

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

Se non hai bisogno di tale controllo, puoi usare ciò di cui parla Oscar o Besh. Sono perfetti.

Usando il metodo di sostituzione possiamo cambiare il singolo carattere della stringa.

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

Il modo più semplice per rimuovere un carattere dalla stringa

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

    }
}

Nella maggior parte dei casi d'uso usare StringBuildero substringè un buon approccio (come già risposto). Tuttavia, per il codice critico per le prestazioni, questa potrebbe essere una buona alternativa.

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

* È possibile eliminare il valore di stringa utilizzando StringBuilder e 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+""));   
  }
}

Sì. Abbiamo una funzione integrata per rimuovere un singolo carattere di una stringa in Java, ovvero deleteCharAt

Per esempio,

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

Produzione

Before : helloworld
After : heloworld

Se si desidera rimuovere un carattere da una stringa Str in un indice int specifico :

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


            }

Quando ho questo tipo di domande, chiedo sempre: "cosa farebbero i Guru di Java?" :)

E risponderei che, in questo caso, esaminando l'implementazione di String.trim().

Ecco un'estrapolazione di tale implementazione che consente di utilizzare più caratteri di ritaglio.

Tuttavia, tieni presente che il rivestimento originale rimuove effettivamente tutti i caratteri presenti <= ' ', quindi potresti doverlo combinare con l'originale per ottenere il risultato desiderato.

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

Per rimuovere un singolo carattere dalla stringa indicata, trova il mio metodo spero che sia utile. ho usato str.replaceAll per rimuovere la stringa ma i loro sono molti modi per rimuovere un carattere da una determinata stringa ma preferisco il metodo di sostituzione.

Codice per rimuovere Char:

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


}

Immagine console:

si prega di trovare l'immagine allegata della console,

Grazie per averlo chiesto. :)

Ho appena implementato questa classe di utilità che rimuove un carattere o un gruppo di caratteri da una stringa . Penso che sia veloce perché non usa Regexp. Spero che aiuti qualcuno!

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

Questo è l'output:

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

Ad esempio, se vuoi calcolare quante a ci sono nella stringa, puoi farlo in questo modo:

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