문자열에서 단일 문자를 제거하는 방법

자바의 String의 개별 문자를 액세스하기 위해, 우리는있다 String.charAt(2). Java에서 String의 개별 문자를 제거하는 내장 함수가 있습니까?

이 같은:

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

StringBuilder변경 가능한 클래스를 사용할 수도 있습니다 .

StringBuilder sb = new StringBuilder(inputString);

이 메소드 deleteCharAt()에는 다른 많은 mutator 메소드와 함께 메소드가 있습니다.

삭제해야 할 문자를 삭제 한 후 다음과 같이 결과를 얻으십시오.

String resultString = sb.toString();

이렇게하면 불필요한 문자열 객체가 생성되지 않습니다.

하나의 가능성 :

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

Java의 문자열은 변경할 수 없으므로 결과는 새로운 문자열 (두 개의 중간 문자열 오브젝트)입니다.

replace라는 Java String 메소드를 사용할 수 있습니다. 그러면 첫 번째 매개 변수와 일치하는 모든 문자가 두 번째 매개 변수로 대체됩니다.

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

Java의 문자열은 변경할 수 없으므로 아니요. 원하지 않는 문자를 제거하여 새 문자열을 만들어야합니다.

string의 c색인 위치 idx에서 단일 문자를 바꾸려면 str다음과 같이하고 새 문자열이 작성됩니다.

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

바꾸다()

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

다음 코드를 고려하십시오.

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

(거대한) 정규식 기계를 사용할 수도 있습니다.

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

• "(?s)" - 정규 문자처럼 줄 바꿈을 처리하도록 regexp에 지시합니다 (경우에 따라).
• "(.{2})" - 정확히 2 자 수집하는 $ 1 그룹
• "." - 인덱스 2의 모든 문자 (압착)
• "(.*)" - 나머지 inputString을 수집하는 $ 2 그룹.
• "$1$2" - 그룹 $ 1과 그룹 $ 2를 하나로 묶습니다.

문자열을 수정하려면 변경 불가능한 문자열을 제외하고 변경 가능하므로 StringBuilder에 대해 읽으십시오. https://docs.oracle.com/javase/tutorial/java/data/buffers.html 에서 다른 작업을 찾을 수 있습니다 . 아래 코드 스 니펫은 StringBuilder를 생성 한 다음 주어진 String을 추가 한 다음 String에서 첫 번째 문자를 삭제 한 다음 StringBuilder에서 String으로 다시 변환합니다.

StringBuilder sb = new StringBuilder();

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

String 클래스의 replaceFirst 함수를 사용하십시오. 사용할 수있는 대체 기능에는 너무 많은 변형이 있습니다.

문자 제거에 대한 논리적 제어가 필요한 경우 다음을 사용하십시오.

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

그러한 제어가 필요하지 않은 경우 Oscar 또는 Bhesh가 언급 한 것을 사용할 수 있습니다. 그들은 자리에 있습니다.

using replace 메소드를 사용하면 문자열의 단일 문자를 변경할 수 있습니다.

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

문자열에서 문자를 제거하는 가장 쉬운 방법

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

    }
}

대부분의 사용 사례에 사용 StringBuilder하거나 substring(이미 대답으로) 좋은 방법이다. 그러나 성능이 중요한 코드의 경우 이는 좋은 대안이 될 수 있습니다.

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

* StringBuilder 및 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+""));   
  }
}

예. 우리는 자바에서 문자열의 개별 문자를 제거하는 함수, 즉 deleteCharAt를 내장했습니다.

예를 들어

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

산출

Before : helloworld
After : heloworld

특정 int 색인 의 문자열 str 에서 문자를 제거하려면 다음을 수행하십시오 .

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


            }

이런 종류의 질문이있을 때는 항상 "Java Gurus는 어떻게합니까?" :)

이 경우에는의 구현을 살펴봄으로써 대답합니다 String.trim().

다음은 더 많은 트림 문자를 사용할 수 있도록하는 구현에 대한 외삽입니다.

그러나 원본 다듬기는 실제로 모든 문자를 제거 <= ' '하므로 원하는 결과를 얻기 위해 원본과 조합해야 할 수도 있습니다.

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

주어진 문자열에서 단일 문자를 제거하려면 내 방법이 도움이되기를 바랍니다. str.replaceAll을 사용하여 문자열을 제거했지만 주어진 문자열에서 문자를 제거하는 많은 방법이 있지만 replaceall 메서드를 선호합니다.

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


}

콘솔 이미지 :

콘솔의 첨부 이미지를 찾으십시오.

질문 주셔서 감사합니다. :)

방금 String에서 char 또는 chars 그룹 을 제거하는 이 유틸리티 클래스를 구현했습니다 . Regexp를 사용하지 않기 때문에 빠르다고 생각합니다. 나는 그것이 누군가를 돕기를 바랍니다!

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

이것은 출력입니다.

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

예를 들어 문자열에 몇 개의 a가 있는지 계산하려면 다음과 같이하십시오.

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