Como remover um único caractere de uma string

Para acessar caracteres individuais de uma String em Java, temos String.charAt(2) . Existe alguma function inerente para remover um caractere individual de uma String em java?

Algo assim:

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

Você também pode usar a class StringBuilder que é mutável.

 StringBuilder sb = new StringBuilder(inputString); 

Tem o método deleteCharAt() , junto com muitos outros methods mutadores.

Basta excluir os caracteres que você precisa excluir e, em seguida, obter o resultado da seguinte maneira:

 String resultString = sb.toString(); 

Isso evita a criação de objects de string desnecessários.

Uma possibilidade:

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

Observe que o resultado é uma nova String (assim como dois objects String intermediários), porque as Strings em Java são imutáveis.

Você pode usar o método Java String chamado replace, que replaceá todos os caracteres correspondentes ao primeiro parâmetro pelo segundo parâmetro:

 String a = "Cool"; a = a.replace("o",""); //variable 'a' contains the string "Cl" 

Não, porque Strings em Java são imutáveis. Você terá que criar uma nova string removendo o caractere que você não deseja.

Para replace um único char c na posição de índice idx em string str , faça algo assim e lembre-se de que uma nova string será criada:

 String newstr = str.substring(0, idx) + str.substring(idx + 1); 
 String str = "M1y java8 Progr5am"; 

deleteCharAt ()

 StringBuilder bulid = new StringBuilder(str); bulid.deleteCharAt(1); // Shift the positions front. bulid.deleteCharAt(8-1); bulid.deleteCharAt(15-2); System.out.println("Builder : "+bulid); 

replace()

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

Caracteres[]

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

Considere o seguinte código:

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

Você também pode usar o (enorme) máquina regexp.

 inputString = inputString.replaceFirst("(?s)(.{2}).(.*)", "$1$2"); 
  • "(?s)" - diz ao regexp para manipular novas linhas como caracteres normais (apenas no caso).
  • "(.{2})" - grupo $ 1 coletando exatamente 2 caracteres
  • "." - "." - qualquer caractere no índice 2 (para ser espremido).
  • "(.*)" - group $ 2, que coleta o resto do inputString.
  • "$1$2" - colocando o grupo $ 1 e o grupo $ 2 juntos.

Use a function replaceFirst da class String. Existem tantas variantes de function de substituição que você pode usar.

Se você precisar de algum controle lógico sobre remoção de caracteres, use este

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

Se você não precisa desse tipo de controle, pode usar o que Oscar orbhesh mencionou. Eles estão no local.

Pelo método using replace, podemos alterar um único caractere de string.

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

A maneira mais fácil de remover um char da string

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

Na maioria dos casos de uso usando StringBuilder ou substring é uma boa abordagem (como já foi respondida). No entanto, para código crítico de desempenho, isso pode ser uma boa 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); } 

* Você pode excluir o valor da string usando o StringBuilder e deletecharAt.

 String s1 = "aabc"; StringBuilder sb = new StringBuilder(s1); for(int i=0;i 

Quando tenho esses tipos de perguntas, sempre pergunto: “o que os gurus de Java farão?” 🙂

E eu responderia, neste caso, olhando a implementação de String.trim() .

Aqui está uma extrapolação dessa implementação que permite que mais caracteres de apara sejam usados.

No entanto, observe que o ajuste original realmente remove todos os caracteres < = ' ' , portanto, talvez seja necessário combinar isso com o original para obter o resultado desejado.

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

Sim. Temos function embutida para remover um caractere individual de uma string em java, isto é, deleteCharAt

Por exemplo,

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

Saída

 Before : helloworld After : heloworld 
 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; } 

Por exemplo, se você quiser calcular quantos a’s existem na String, você pode fazer assim:

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