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 permettant de 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 classe StringBuilder qui est mutable.
StringBuilder sb = new StringBuilder(inputString);
Il a la méthode deleteCharAt() , avec beaucoup d'autres méthodes de mutateur.
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 chaîne 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 second:
String a = "Cool";
a = a.replace("o","");
//variable 'a' contains the string "Cl"
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'indexation idx dans la chaîne str, procédez comme suit 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);
remplace ()
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);
Considérons 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 à expression rationnelle.
inputString = inputString.replaceFirst("(?s)(.{2}).(.*)", "$1$2");
"(?s)" -indique à regexp de gérer les nouvelles lignes comme des caractères normaux (au cas où)."(.{2})" -group $ 1 rassemblant exactement 2 caractères"." -n'importe quel caractère à l'index 2 (à supprimer)."(.*)" -groupe $ 2 qui collecte le reste de la chaîne inputString."$1$2" -réunissant le groupe 1 et le groupe 2.
Pour modifier les chaînes, lisez à propos de StringBuilder car il peut être modifié à l'exception de la chaîne immuable. Vous pouvez trouver différentes opérations ici https://docs.Oracle.com/javase/tutorial/Java/data/buffers.html . L'extrait de code ci-dessous crée un StringBuilder, puis ajoute la chaîne donnée, puis supprime le premier caractère de la chaîne, puis la reconvertit à partir de StringBuilder en chaîne.
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);
}
}
Si vous avez besoin d’un contrôle logique sur la suppression des caractères, utilisez cette option.
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 que Oscar ou Bhesh ont mentionné. Ils sont sur place.
Dans la plupart des cas d'utilisation, utiliser StringBuilder ou substring est une bonne approche (comme déjà répondu). Toutefois, pour le code critique en termes de performances, cela pourrait ê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);
}
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
Utilisez la fonction replaceFirst de la classe String. Il y a tellement de variantes de la fonction de remplacement que vous pouvez utiliser.
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);
}
}
Sortie
Before : helloworld
After : heloworld
Avec la méthode using, nous pouvons changer un seul caractère de chaîne.
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;
}
}
Si vous souhaitez supprimer un caractère d'un String strsur un 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;
}
* Vous pouvez supprimer une 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+""));
}
}
Quand j'ai ce genre de questions, je demande toujours: "que feraient les gourous de Java?" :)
Et je répondrais à cela, dans ce cas, en regardant la mise en œuvre de String.trim().
Voici une extrapolation de cette implémentation qui permet d'utiliser davantage de caractères de sélection.
Toutefois, notez que le rognage d'origine supprime en réalité tous les caractères <= ' '; vous devrez 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 seul caractère de The Given String, veuillez trouver ma méthode en espérant qu'elle vous 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:
s'il vous plaît trouver l'image ci-jointe de la console,
Merci d'avoir posé la question. :)
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;
}