wake-up-neo.com

So entfernen Sie ein einzelnes 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 zum Entfernen eines einzelnen Zeichens eines Strings in Java? 

Etwas wie das:

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

Sie können auch die StringBuilder-Klasse verwenden, die veränderlich ist.

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

Dies vermeidet die Erstellung von unnötigen String-Objekten.

187
Bhesh Gurung

Eine Möglichkeit:

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

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

60
atkretsch

Sie können die Java-String-Methode namens "replace" verwenden, bei der alle Zeichen, die dem ersten Parameter entsprechen, durch den zweiten Parameter ersetzt werden:

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

//variable 'a' contains the string "Cl"
41
Thuy

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

Um ein einzelnes Zeichen c an der Indexposition idx in Zeichenfolge str zu ersetzen, führen Sie Folgendes aus und denken Sie daran, dass eine neue Zeichenfolge erstellt wird:

String newstr = str.substring(0, idx) + str.substring(idx + 1);
12
Óscar López
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);

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

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;
}
8
आनंद

Sie können auch die (riesige) Regex-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})" - group $ 1 sammelt genau 2 Zeichen
  • "." - ein beliebiges Zeichen an Index 2 (auszuquetschen).
  • "(.*)" - group $ 2, die den Rest des inputString sammelt.
  • "$1$2" - setzt Gruppe $ 1 und Gruppe $ 2 zusammen.
4
Bob Genom

Lesen Sie zum Ändern von Strings über StringBuilder, da es mit Ausnahme von unveränderlichen Strings veränderlich ist. Verschiedene Operationen finden Sie hier https://docs.Oracle.com/javase/tutorial/Java/data/buffers.html . Das folgende Code-Snippet erstellt einen StringBuilder, hängt den angegebenen String an und löscht dann das erste Zeichen aus dem String und konvertiert ihn wieder von StringBuilder in einen String.

StringBuilder sb = new StringBuilder();

sb.append(str);
sb.deleteCharAt(0);
str = sb.toString();
2
BlizzaN
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);

    }
}
1
SanA

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

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, was Oscar oder Bhesh erwähnt, verwenden. Sie sind genau richtig.

1
Farhan Syed

In den meisten Anwendungsfällen ist die Verwendung von StringBuilder oder substring ein 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);
}
1
rmuller

Der einfachste Weg, ein Zeichen aus einer Zeichenfolge zu entfernen  

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

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

1
Pankaj

Ja. Wir haben eine eingebaute Funktion zum Entfernen eines einzelnen Zeichens einer Zeichenfolge in Java, dh deleteCharAt

Zum Beispiel,

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
1
Shiva

Mit der using-Ersatzmethode können wir einzelne Zeichen der Zeichenkette ändern.

string= string.replace("*", "");
1
Anupam Jain
           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;   
               }


            }
0
natwar kumar

Wenn Sie ein Zeichen aus einem String stran einem bestimmten int indexentfernen 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;

    }
0
Nadav

* Sie können den String-Wert löschen, indem Sie den StringBuilder und den Befehl deletecharAt verwenden.

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

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 wir uns die Implementierung von String.trim() ansehen.

Hier ist eine Extrapolation dieser Implementierung, die die Verwendung weiterer Beschnittzeichen ermöglicht.

Beachten Sie jedoch, dass der ursprüngliche Beschnitt tatsächlich alle Zeichen entfernt, die <= ' ' sind. Daher müssen Sie dies möglicherweise mit dem Original kombinieren, um das gewünschte Ergebnis zu erhalten.

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);
}
0
Erk
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;
}
0
Maulik Sakhida

Um ein einzelnes Zeichen aus der angegebenen Zeichenfolge zu entfernen, suchen Sie nach meiner Methode und hoffen, dass sie 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 replaceceall.

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:

bitte finden Sie das angehängte Bild der Konsole,

enter image description here

Danke für die Frage. :)

0
koushick
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;
}
0
ceph3us