So entfernen Sie einzelne Zeichen aus einem String

Für den Zugriff auf einzelne Zeichen eines Strings in Java haben wir String.charAt(2). Gibt es eine eingebaute Funktion, um ein einzelnes Zeichen eines Strings in Java zu entfernen?

Etwas wie das:

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

Sie können auch die veränderbare StringBuilderKlasse verwenden.

StringBuilder sb = new StringBuilder(inputString);

Es hat die Methode deleteCharAt(), zusammen mit vielen anderen Mutator-Methoden.

Löschen Sie einfach die Zeichen, die Sie löschen müssen, und erhalten Sie das Ergebnis wie folgt:

String resultString = sb.toString();

Dadurch wird vermieden, dass unnötige Zeichenfolgenobjekte erstellt werden.

Eine Möglichkeit:

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

Beachten Sie, dass das Ergebnis ein neuer String ist (sowie zwei zwischengeschaltete String-Objekte), da Strings in Java unveränderlich sind.

Sie können die Java-String-Methode "replace" verwenden, die alle Zeichen, die mit dem ersten Parameter übereinstimmen, durch den zweiten Parameter ersetzt:

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

Nein, da Strings in Java unveränderlich sind. Sie müssen eine neue Zeichenfolge erstellen, um das nicht gewünschte Zeichen zu entfernen.

Gehen Sie wie folgt vor, um ein einzelnes Zeichen can der Indexposition idxin der Zeichenfolge zu ersetzen str, und denken Sie daran, dass eine neue Zeichenfolge erstellt wird:

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

ersetzen()

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

verkohlen[]

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

Betrachten Sie den folgenden Code:

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

Sie können auch die (riesige) Regexp-Maschine verwenden.

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

• "(?s)" - weist regexp an, Zeilenumbrüche wie normale Zeichen zu behandeln (nur für den Fall).
• "(.{2})" - Gruppe $ 1 sammelt genau 2 Zeichen
• "." - ein beliebiges Zeichen bei Index 2 (herausgedrückt werden).
• "(.*)" - Gruppe $ 2, die den Rest des inputString sammelt.
• "$1$2" - Gruppe $ 1 und Gruppe $ 2 zusammenfügen.

Lesen Sie zum Ändern von Strings Informationen zu StringBuilder, da dieser mit Ausnahme des unveränderlichen Strings veränderbar ist. Verschiedene Vorgänge finden Sie hier https://docs.oracle.com/javase/tutorial/java/data/buffers.html . Das folgende Codefragment erstellt einen StringBuilder, hängt den angegebenen String an und löscht dann das erste Zeichen aus dem String und konvertiert es dann wieder aus dem StringBuilder in einen String.

StringBuilder sb = new StringBuilder();

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

Verwenden Sie die replaceFirst-Funktion der String-Klasse. Es gibt so viele Varianten der Ersetzungsfunktion, die Sie verwenden können.

Wenn Sie eine logische Kontrolle über das Entfernen von Zeichen benötigen, verwenden Sie diese

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

Wenn Sie keine solche Kontrolle benötigen, können Sie das verwenden, was Oscar oder Bhesh erwähnt haben. Sie sind genau richtig.

Mit der Methode replace können wir ein einzelnes Zeichen der Zeichenfolge ändern.

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

Der einfachste Weg, ein Zeichen aus einem String zu entfernen

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

    }
}

In den meisten Anwendungsfällen ist die Verwendung von StringBuilderoder substringein guter Ansatz (wie bereits beantwortet). Für leistungskritischen Code kann dies jedoch eine gute Alternative sein.

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

* Sie können den Zeichenfolgenwert mit dem StringBuilder und deletecharAt löschen.

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

Ja. Wir haben eine eingebaute Funktion, um ein einzelnes Zeichen einer Zeichenfolge in Java zu entfernen, dh deleteCharAt

Beispielsweise,

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

Ausgabe

Before : helloworld
After : heloworld

Wenn Sie ein Zeichen aus einem String str an einem bestimmten int- Index entfernen möchten :

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


            }

Wenn ich solche Fragen habe, frage ich immer: "Was würden die Java-Gurus tun?" :) :)

Und ich würde das in diesem Fall beantworten, indem ich mir die Implementierung von anschaue String.trim().

Hier ist eine Extrapolation dieser Implementierung, mit der mehr Trimmzeichen verwendet werden können.

Beachten Sie jedoch, dass beim ursprünglichen Zuschneiden tatsächlich alle Zeichen entfernt <= ' 'werden. Daher müssen Sie dies möglicherweise mit dem Original kombinieren, um das gewünschte Ergebnis zu erzielen.

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

Um ein einzelnes Zeichen aus der angegebenen Zeichenfolge zu entfernen, finden Sie bitte meine Methode, die hoffentlich nützlich ist. Ich habe str.replaceAll verwendet, um die Zeichenfolge zu entfernen, aber es gibt viele Möglichkeiten, ein Zeichen aus einer bestimmten Zeichenfolge zu entfernen, aber ich bevorzuge die Methode "Ersetzen".

Code zum Entfernen von Zeichen:

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


}

Konsolenbild:

finden Sie das beigefügte Bild der Konsole,

Danke für die Frage. :) :)

Ich habe gerade diese Dienstprogrammklasse implementiert, die ein Zeichen oder eine Gruppe von Zeichen aus einem String entfernt . Ich denke, es ist schnell, weil Regexp nicht verwendet wird. Ich hoffe, dass es jemandem hilft!

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

Dies ist die Ausgabe:

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

Wenn Sie beispielsweise berechnen möchten, wie viele A in der Zeichenfolge vorhanden sind, können Sie dies folgendermaßen tun:

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