Cách xóa ký tự đơn khỏi Chuỗi

Để truy cập các ký tự riêng lẻ của Chuỗi trong Java, chúng tôi có String.charAt(2). Có bất kỳ hàm inbuilt nào để loại bỏ một ký tự riêng lẻ của String trong java không?

Một cái gì đó như thế này:

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

Bạn cũng có thể sử dụng StringBuilderlớp có thể thay đổi.

StringBuilder sb = new StringBuilder(inputString);

Nó có phương thức deleteCharAt(), cùng với nhiều phương thức gây đột biến khác.

Chỉ cần xóa các ký tự mà bạn cần xóa và sau đó nhận được kết quả như sau:

String resultString = sb.toString();

Điều này tránh việc tạo ra các đối tượng chuỗi không cần thiết.

Một khả năng:

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

Lưu ý rằng kết quả là một Chuỗi mới (cũng như hai đối tượng Chuỗi trung gian), vì Chuỗi trong Java là bất biến.

Bạn có thể sử dụng phương thức Chuỗi Java được gọi là thay thế, sẽ thay thế tất cả các ký tự khớp với tham số thứ nhất bằng tham số thứ hai:

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

Không, bởi vì Chuỗi trong Java là bất biến. Bạn sẽ phải tạo một chuỗi mới loại bỏ ký tự bạn không muốn.

Để thay thế một char duy nhất ctại vị trí chỉ mục idxtrong chuỗi str, hãy làm một cái gì đó như thế này và nhớ rằng một chuỗi mới sẽ được tạo:

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

String str = "M1y java8 Progr5am";

xóaCharAt ()

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

thay thế()

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

Hãy xem xét các mã sau đây:

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

Bạn cũng có thể sử dụng máy regrec (rất lớn).

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

• "(?s)" - cho biết regrec để xử lý các dòng mới như các ký tự bình thường (chỉ trong trường hợp).
• "(.{2})" - nhóm $ 1 thu thập chính xác 2 ký tự
• "." - bất kỳ ký tự nào ở chỉ số 2 (sẽ bị loại bỏ).
• "(.*)" - nhóm $ 2 thu thập phần còn lại của inputString.
• "$1$2" - đặt nhóm $ 1 và nhóm $ 2 lại với nhau.

Để sửa đổi Chuỗi, hãy đọc về StringBuilder vì nó có thể thay đổi ngoại trừ Chuỗi không thay đổi. Các hoạt động khác nhau có thể được tìm thấy ở đây https://docs.oracle.com/javase/tutorial/java/data/buffers.html . Đoạn mã dưới đây tạo StringBuilder và sau đó nối thêm Chuỗi đã cho rồi xóa ký tự đầu tiên khỏi Chuỗi và sau đó chuyển đổi lại từ StringBuilder thành Chuỗi.

StringBuilder sb = new StringBuilder();

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

Sử dụng hàm thay thế đầu tiên của lớp String. Có rất nhiều biến thể của chức năng thay thế mà bạn có thể sử dụng.

Nếu bạn cần một số điều khiển logic để loại bỏ ký tự, hãy sử dụng cái này

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

Nếu bạn không cần bất kỳ sự kiểm soát nào như vậy, bạn có thể sử dụng những gì Oscar hoặcBhesh đã đề cập. Họ đang ở trên.

Bằng phương pháp sử dụng thay thế, chúng ta có thể thay đổi một ký tự của chuỗi.

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

Cách dễ nhất để loại bỏ char khỏi chuỗi

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

    }
}

Trong hầu hết các trường hợp sử dụng sử dụng StringBuilderhoặc substringlà một cách tiếp cận tốt (như đã trả lời). Tuy nhiên, đối với mã quan trọng về hiệu năng, đây có thể là một sự thay thế tốt.

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

* Bạn có thể xóa giá trị chuỗi bằng StringBuilder và 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+""));   
  }
}

Đúng. Chúng tôi có chức năng inbuilt để loại bỏ một ký tự riêng lẻ của một chuỗi trong java, nghĩa là xóaCharAt

Ví dụ,

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

Đầu ra

Before : helloworld
After : heloworld

Nếu bạn muốn xóa char khỏi chuỗi str tại một chỉ mục int cụ thể :

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


            }

Khi tôi có những loại câu hỏi này, tôi luôn hỏi: "Java Gurus sẽ làm gì?" :)

Và tôi trả lời rằng, trong trường hợp này, bằng cách xem xét việc thực hiện String.trim() .

Đây là phép ngoại suy của việc thực hiện đó cho phép sử dụng nhiều ký tự cắt hơn.

Tuy nhiên, lưu ý rằng trang trí ban đầu thực sự loại bỏ tất cả các ký tự <= ' ', vì vậy bạn có thể phải kết hợp điều này với bản gốc để có được kết quả mong muốn.

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

Để xóa một ký tự đơn khỏi Chuỗi đã cho, vui lòng tìm phương thức của tôi hy vọng nó sẽ hữu ích. tôi đã sử dụng str.replaceAll để xóa chuỗi nhưng có nhiều cách để loại bỏ một ký tự khỏi một chuỗi đã cho nhưng tôi thích phương thức thay thế hơn.

Mã để loại bỏ 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), "");
        }
    }


}

Hình ảnh bảng điều khiển:

vui lòng tìm Hình ảnh đính kèm của bảng điều khiển,

Cam ơn vi đa hỏi. :)

Tôi vừa triển khai lớp tiện ích này để loại bỏ char hoặc một nhóm ký tự khỏi Chuỗi . Tôi nghĩ rằng nó nhanh vì không sử dụng Regapi. Tôi hy vọng rằng nó sẽ giúp được ai đó!

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

Đây là đầu ra:

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

Ví dụ: nếu bạn muốn tính toán có bao nhiêu a trong Chuỗi, bạn có thể làm như thế này:

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