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.
}
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.
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.
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"
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);
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);
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) 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.
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();
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);
}
}
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.
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);
}
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
Verwenden Sie die replaceFirst-Funktion der String-Klasse. Es gibt so viele Varianten der Ersetzungsfunktion, die Sie verwenden können.
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
Mit der using-Ersatzmethode können wir einzelne Zeichen der Zeichenkette ändern.
string= string.replace("*", "");
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 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;
}
* 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+""));
}
}
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);
}
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, 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,
Danke für die Frage. :)
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;
}