Cara menghapus satu karakter dari sebuah String

Untuk mengakses karakter individu dari suatu String di Java, kami punya String.charAt(2). Apakah ada fungsi inbuilt untuk menghapus karakter individu dari suatu String di java?

Sesuatu seperti ini:

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

Anda juga bisa menggunakan StringBuilderkelas yang bisa diubah.

StringBuilder sb = new StringBuilder(inputString);

Ini memiliki metode deleteCharAt(), bersama dengan banyak metode mutator lainnya.

Hapus saja karakter yang perlu Anda hapus dan kemudian dapatkan hasilnya sebagai berikut:

String resultString = sb.toString();

Ini menghindari pembuatan objek string yang tidak perlu.

Satu kemungkinan:

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

Perhatikan bahwa hasilnya adalah String baru (dan juga dua objek String menengah), karena String di Java tidak dapat diubah.

Anda dapat menggunakan metode Java String yang disebut ganti, yang akan mengganti semua karakter yang cocok dengan parameter pertama dengan parameter kedua:

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

Tidak, karena String di Jawa tidak dapat diubah. Anda harus membuat string baru menghapus karakter yang tidak Anda inginkan.

Untuk mengganti satu karakter cpada posisi indeks idxdalam string str, lakukan sesuatu seperti ini, dan ingat bahwa string baru akan dibuat:

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

menggantikan()

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

arang[]

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

Pertimbangkan kode berikut:

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

Anda juga dapat menggunakan mesin regexp (besar).

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

• "(?s)" - memberitahu regexp untuk menangani baris baru seperti karakter normal (untuk berjaga-jaga).
• "(.{2})" - grup $ 1 mengumpulkan tepat 2 karakter
• "." - karakter apa saja di indeks 2 (akan diperas).
• "(.*)" - grup $ 2 yang mengumpulkan sisa inputString.
• "$1$2" - menempatkan grup $ 1 dan grup $ 2 bersama-sama.

Untuk memodifikasi Strings, baca tentang StringBuilder karena itu bisa berubah kecuali untuk String yang tidak dapat diubah. Berbagai operasi dapat ditemukan di sini https://docs.oracle.com/javase/tutorial/java/data/buffers.html . Cuplikan kode di bawah ini membuat StringBuilder dan kemudian menambahkan String yang diberikan dan kemudian menghapus karakter pertama dari String dan kemudian mengubahnya kembali dari StringBuilder ke String.

StringBuilder sb = new StringBuilder();

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

Gunakan fungsi replaceFirst dari kelas String. Ada begitu banyak varian fungsi ganti yang bisa Anda gunakan.

Jika Anda memerlukan kontrol logis atas penghapusan karakter, gunakan ini

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

Jika Anda tidak memerlukan kontrol semacam itu, Anda dapat menggunakan apa yang disebutkan Oscar atau Bhesh. Mereka tepat.

Dengan menggunakan metode replace, kita dapat mengubah karakter string tunggal.

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

Cara termudah untuk menghapus arang dari 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);

    }
}

Dalam kebanyakan kasus penggunaan menggunakan StringBuilderatau substringmerupakan pendekatan yang baik (seperti yang sudah dijawab). Namun, untuk kode kritis kinerja, ini mungkin merupakan alternatif yang baik.

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

* Anda dapat menghapus nilai string menggunakan StringBuilder dan 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+""));   
  }
}

Iya. Kami memiliki fungsi inbuilt untuk menghapus karakter individual dari string di java, yaitu deleteCharAt

Sebagai contoh,

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

Keluaran

Before : helloworld
After : heloworld

Jika Anda ingin menghapus char dari String str pada indeks int tertentu :

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


            }

Ketika saya memiliki pertanyaan-pertanyaan semacam ini saya selalu bertanya: "apa yang akan dilakukan para Guru Jawa?" :)

Dan saya akan menjawab itu, dalam hal ini, dengan melihat implementasi String.trim().

Berikut adalah ekstrapolasi dari implementasi yang memungkinkan lebih banyak karakter trim untuk digunakan.

Namun, perhatikan bahwa trim asli sebenarnya menghapus semua karakter yang ada <= ' ', jadi Anda mungkin harus menggabungkan ini dengan yang asli untuk mendapatkan hasil yang diinginkan.

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

Untuk menghapus satu karakter dari String yang Diberikan, harap temukan metode saya yang berguna. Saya telah menggunakan str.replaceAll untuk menghapus string tetapi mereka banyak cara untuk menghapus karakter dari string yang diberikan tetapi saya lebih suka metode replaceall.

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


}

Gambar konsol:

temukan gambar Terlampir pada konsol,

Terima kasih untuk bertanya. :)

Saya baru saja mengimplementasikan kelas utilitas ini yang menghilangkan char atau sekelompok karakter dari sebuah String . Saya pikir ini cepat karena tidak menggunakan Regexp. Saya harap ini membantu seseorang!

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

Ini hasilnya:

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

Misalnya jika Anda ingin menghitung berapa banyak yang ada di dalam String, Anda dapat melakukannya seperti ini:

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