Como remover um único caractere de uma String

Para acessar caracteres individuais de uma String em Java, temos String.charAt(2). Existe alguma função embutida 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 StringBuilderclasse que é mutável.

StringBuilder sb = new StringBuilder(inputString);

Ele tem o método deleteCharAt(), junto com muitos outros métodos de mutação.

Apenas exclua os caracteres que você precisa excluir e obtenha o resultado da seguinte maneira:

String resultString = sb.toString();

Isso evita a criação de objetos de cadeia desnecessários.

Uma possibilidade:

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

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

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

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

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

Para substituir um único caractere cna posição de índice idxna 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 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);

substituir()

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 a (enorme) máquina regexp.

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

• "(?s)" - diz ao regexp para lidar com novas linhas como caracteres normais (apenas no caso).
• "(.{2})" - grupo $ 1 coletando exatamente 2 caracteres
• "." - qualquer caractere no índice 2 (a ser espremido).
• "(.*)" - grupo $ 2, que coleta o restante da inputString.
• "$1$2" - colocando o grupo $ 1 e o grupo $ 2 juntos.

Para modificar Strings, leia sobre StringBuilder porque é mutável, exceto String imutável. Operações diferentes podem ser encontradas aqui https://docs.oracle.com/javase/tutorial/java/data/buffers.html . O trecho de código abaixo cria um StringBuilder e, em seguida, anexa a String especificada e exclui o primeiro caractere da String e depois o converte novamente de StringBuilder em uma String.

StringBuilder sb = new StringBuilder();

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

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

Se você precisar de algum controle lógico sobre a 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 precisar desse controle, poderá usar o que Oscar ou Bhesh mencionaram. Eles estão no local.

Pelo método de substituição usando, podemos alterar um único caractere da string.

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

A maneira mais fácil de remover um caractere 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);

    }
}

Na maioria dos casos de uso, usar StringBuilderou substringé uma boa abordagem (como já respondido). No entanto, para código crítico de desempenho, essa 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<sb.length();i++)
{
  char temp = sb.charAt(0);
  if(sb.indexOf(temp+"")!=1)
  {                             
    sb.deleteCharAt(sb.indexOf(temp+""));   
  }
}

Sim. Temos a função integrada para remover um caractere individual de uma string em java, ou seja, 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);
   }
}

Resultado

Before : helloworld
After : heloworld

Se você deseja remover um caractere de um String str em um índice int específico :

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


            }

Quando tenho esse tipo de pergunta, sempre pergunto: "o que os Java Gurus fazem?" :)

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

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

No entanto, observe que o corte original remove todos os caracteres que são <= ' ', portanto, você pode 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);
}

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

Para remover um único caractere da seqüência especificada, encontre meu método, espero que seja útil. Eu usei str.replaceAll para remover a string, mas há muitas maneiras de remover um caractere de uma determinada string, mas eu prefiro o método replaceeall.

Código para remover char:

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


}

Imagem do console:

encontre a imagem anexada do console,

Obrigado por perguntar. :)

Acabei de implementar essa classe de utilitário que remove um caractere ou um grupo de caracteres de uma String . Eu acho que é rápido porque não usa Regexp. Espero que ajude alguém!

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

Esta é a saída:

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

Por exemplo, se você deseja calcular quantos a existem na String, é possível fazer o seguinte:

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