java - Een enkel teken uit een tekenreeks verwijderen

Voor toegang tot individuele karakters van een String in Java hebben we String.charAt(2). Is er een ingebouwde functie om een individueel teken van een string in java te verwijderen?

Zoiets:

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

Antwoord 1, autoriteit 100%

U kunt ook de klasse StringBuildergebruiken, die kan worden gewijzigd.

StringBuilder sb = new StringBuilder(inputString);

Het heeft de methode deleteCharAt(), samen met vele andere mutatormethoden.

Verwijder gewoon de tekens die u moet verwijderen en verkrijg het resultaat als volgt:

String resultString = sb.toString();

Dit voorkomt het maken van onnodige string-objecten.

Antwoord 2, autoriteit 32%

U kunt de Java String-methode genaamd vervangen gebruiken, waarmee alle tekens die overeenkomen met de eerste parameter worden vervangen door de tweede parameter:

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

Antwoord 3, autoriteit 31%

Eén mogelijkheid:

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

Merk op dat het resultaat een nieuwe String is (evenals twee tussenliggende String-objecten), omdat Strings in Java onveranderlijk zijn.

Antwoord 4, autoriteit 6%

Nee, omdat strings in Java onveranderlijk zijn. U moet een nieuwe tekenreeks maken en het teken verwijderen dat u niet wilt.

Voor het vervangen van een enkele char cop indexpositie idxin string str, doe zoiets als dit, en onthoud dat een nieuwe string zal worden gemaakt:

String newstr = str.substring(0, idx) + str.substring(idx + 1);

Antwoord 5, autoriteit 6%

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

vervang()

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

Antwoord 6, autoriteit 3%

Beschouw de volgende 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;
}

Antwoord 7, autoriteit 2%

Je mag ook de (enorme) regexp-machine gebruiken.

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

"(?s)" -vertelt regexp om nieuwe regels als normale tekens te behandelen (voor het geval dat).
"(.{2})" -groep $1 die precies 2 tekens verzamelt
"." -een willekeurig teken op index 2 (uit te knijpen).
"(.*)" -groep $2 die de rest van de inputString verzamelt.
"$1$2" -groep $1 en groep $2 samenvoegen.

Antwoord 8

Om Strings te wijzigen, lees over StringBuilder omdat het veranderlijk is, behalve voor onveranderlijke String. Verschillende bewerkingen zijn hier te vinden https://docs.oracle.com/ javase/tutorial/java/data/buffers.html. Het onderstaande codefragment maakt een StringBuilder en voegt vervolgens de gegeven String toe en verwijdert vervolgens het eerste teken uit de String en converteert het vervolgens terug van StringBuilder naar een String.

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

Antwoord 9

Door de vervangmethode te gebruiken, kunnen we één teken van een tekenreeks wijzigen.

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

Antwoord 10

Gebruik de functie ReplaceFirst van de klasse String. Er zijn zoveel varianten van de vervangfunctie die je kunt gebruiken.

Antwoord 11

Als je wat logische controle nodig hebt over het verwijderen van tekens, gebruik dan dit

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

Als je zo’n controle niet nodig hebt, kun je gebruiken wat Oscar orBhesh noemde. Ze zijn perfect.

Antwoord 12

Gemakkelijkste manier om een char uit een string te verwijderen

String str="welcome";
str=str.replaceFirst(String.valueOf(str.charAt(2)),"");//'l' will replace with "" 
System.out.println(str);//output: wecome

Antwoord 13

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

Antwoord 14

In de meeste gevallen is het gebruik van StringBuilderof substringeen goede benadering (zoals al beantwoord). Voor prestatiekritieke code kan dit echter een goed alternatief zijn.

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

Antwoord 15

* U kunt stringwaarde verwijderen Gebruik de stringbuilder en de 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+""));   
  }
}

Antwoord 16

Ja. We hebben een ingebouwde functie om een individueel karakter van een tekenreeks in Java te verwijderen, dat wil zeggen, Deletecharat

Bijvoorbeeld,

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

output

Before : helloworld
After : heloworld

Antwoord 17

Als u een CHAR wilt verwijderen van een String STR op een specifiek 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;
    }

Antwoord 18

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

Antwoord 19

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

Antwoord 20

Als ik dit soort vragen heb, stel ik altijd: “wat zouden de Java-goeroes doen?” 🙂

En dat zou ik in dit geval beantwoorden door te kijken naar de implementatie van String.trim().

Hier is een extrapolatie van die implementatie waarmee meer bijgesneden tekens kunnen worden gebruikt.

Houd er echter rekening mee dat originele trim eigenlijk alle tekens verwijdert die <= ' 'zijn, dus het kan zijn dat u dit moet combineren met het origineel om het gewenste resultaat te krijgen.

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

Antwoord 21

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

Antwoord 22

Om een enkel karakter uit de gegeven string te verwijderen, zoek mijn methode, hoop dat deze nuttig zal zijn. ik heb str.replaceAll gebruikt om de tekenreeks te verwijderen, maar er zijn veel manieren om een teken uit een bepaalde tekenreeks te verwijderen, maar ik geef de voorkeur aan de methode Replaceall.

Code voor het verwijderen van 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), "");
        }
    }
}

Console-afbeelding:

vind de bijgevoegde afbeelding van de console,

Bedankt voor het vragen. 🙂

Antwoord 23

Ik heb zojuist deze utility-klasse geïmplementeerd die een teken of een groep tekens uit een tekenreeks verwijdert. Ik denk dat het snel is omdat het geen Regexp gebruikt. Ik hoop dat het iemand helpt!

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

Dit is de uitvoer:

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

Antwoord 24

Als je bijvoorbeeld wilt berekenen hoeveel a’s er in de String zitten, kun je dat als volgt doen:

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

Een enkel teken uit een tekenreeks verwijderen