Cómo eliminar un solo carácter de una cadena

Para acceder a caracteres individuales de una cadena en Java, tenemos String.charAt(2). ¿Hay alguna función incorporada para eliminar un carácter individual de una cadena en Java?

Algo como esto:

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

También puede usar la StringBuilderclase que es mutable.

StringBuilder sb = new StringBuilder(inputString);

Tiene el método deleteCharAt(), junto con muchos otros métodos mutantes.

Simplemente elimine los caracteres que necesita eliminar y luego obtenga el resultado de la siguiente manera:

String resultString = sb.toString();

Esto evita la creación de objetos de cadena innecesarios.

Una posibilidad:

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

Tenga en cuenta que el resultado es una nueva cadena (así como dos objetos de cadena intermedios), porque las cadenas en Java son inmutables.

Puede usar el método Java String llamado replace, que reemplazará todos los caracteres que coincidan con el primer parámetro con el segundo parámetro:

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

No, porque las cadenas en Java son inmutables. Tendrá que crear una nueva cadena que elimine el carácter que no desea.

Para reemplazar un único carácter cen la posición de índice idxen la cadena str, haga algo como esto y recuerde que se creará una nueva cadena:

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

reemplazar()

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

carbonizarse[]

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

También puede usar la máquina de expresiones regulares (enorme).

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

• "(?s)" - le dice a regexp que maneje nuevas líneas como caracteres normales (por si acaso).
• "(.{2})" - grupo $ 1 que recoge exactamente 2 personajes
• "." - cualquier carácter en el índice 2 (para ser exprimido).
• "(.*)" - grupo $ 2 que recolecta el resto de inputString.
• "$1$2" - poniendo el grupo $ 1 y el grupo $ 2 juntos.

Para modificar cadenas, lea sobre StringBuilder porque es mutable a excepción de una cadena inmutable. Se pueden encontrar diferentes operaciones aquí https://docs.oracle.com/javase/tutorial/java/data/buffers.html . El fragmento de código a continuación crea un StringBuilder y luego agrega la Cadena dada y luego elimina el primer carácter de la Cadena y luego la convierte de nuevo en una Cadena.

StringBuilder sb = new StringBuilder();

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

Utilice la función replaceFirst de la clase String. Hay tantas variantes de la función de reemplazo que puede usar.

Si necesita algún control lógico sobre la eliminación de caracteres, use esto

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

Si no necesita ningún control, puede usar lo que Oscar o Bhesh mencionaron. Ellos son acertados.

Mediante el uso del método de reemplazo, podemos cambiar un solo carácter de cadena.

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

La forma más fácil de eliminar un char de la cadena

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

    }
}

En la mayoría de los casos de uso, usar StringBuildero substringes un buen enfoque (como ya se respondió). Sin embargo, para el código crítico de rendimiento, esta podría ser una buena 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);
}

* Puede eliminar el valor de la cadena usando StringBuilder y 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+""));   
  }
}

Si. Tenemos una función incorporada para eliminar un carácter individual de una cadena en Java, es decir, deleteCharAt

Por ejemplo,

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

Salida

Before : helloworld
After : heloworld

Si desea eliminar un carácter de un String str en un í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;   
               }


            }

Cuando tengo este tipo de preguntas siempre pregunto: "¿qué harían los Java Gurus?" :)

Y respondería eso, en este caso, mirando la implementación de String.trim() .

Aquí hay una extrapolación de esa implementación que permite utilizar más caracteres de recorte.

Sin embargo, tenga en cuenta que el recorte original en realidad elimina todos los caracteres que están <= ' ', por lo que es posible que deba combinar esto con el original para obtener el resultado deseado.

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 eliminar un solo carácter de la cadena dada, encuentre mi método, espero que sea útil. He usado str.replaceAll para eliminar la cadena, pero hay muchas formas de eliminar un carácter de una cadena determinada, pero prefiero el método replaceall.

Código para eliminar 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), "");
        }
    }


}

Imagen de la consola:

encuentra la imagen adjunta de la consola,

Gracias por preguntar. :)

Acabo de implementar esta clase de utilidad que elimina un carácter o un grupo de caracteres de una Cadena . Creo que es rápido porque no usa Regexp. ¡Espero que ayude a alguien!

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 es la salida:

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

Por ejemplo, si desea calcular cuántos a hay en la Cadena, puede hacerlo así:

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