Bir dizeden tek karakter nasıl kaldırılır

Java'da bir String'in bireysel karakterlerine erişmek için, elimizde String.charAt(2). Java'da bir String'in tek bir karakterini kaldırmak için herhangi bir dahili işlev var mı?

Bunun gibi bir şey:

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

Aynı zamanda StringBuilderdeğiştirilebilir olan sınıfı da kullanabilirsiniz .

StringBuilder sb = new StringBuilder(inputString);

deleteCharAt()Diğer birçok mutatör yöntemle birlikte bu yönteme sahiptir .

Silmeniz gereken karakterleri silin ve ardından aşağıdaki gibi sonucu alın:

String resultString = sb.toString();

Bu, gereksiz dizi nesnelerinin oluşturulmasını önler.

Bir olasılık:

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

Java'daki Dizeler değişmez olduğundan, sonucun yeni bir String (ve ayrıca iki ara String nesnesi) olduğuna dikkat edin.

İlk parametreyle eşleşen tüm karakterleri ikinci parametre ile değiştirecek olan replace adlı Java String yöntemini kullanabilirsiniz:

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

Hayır, çünkü Java'daki Dizeler değişmezdir. İstemediğiniz karakteri kaldırarak yeni bir dize oluşturmanız gerekecek.

Bir tek karakter değiştirmek için cdizin konumundaki idxdizesinde str, böyle bir şey yapmak ve yeni bir dize oluşturulur unutmayın:

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

() Yerine

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

Aşağıdaki kodu göz önünde bulundurun:

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

Ayrıca (devasa) regexp makinesini de kullanabilirsiniz.

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

• "(?s)" - regexp'e yeni satırları normal karakterler gibi işlemesini söyler (her ihtimale karşı).
• "(.{2})" - tam olarak 2 karakter toplayan $ 1 grubu
• "." - dizin 2'deki herhangi bir karakter (sıkıştırılacak).
• "(.*)" - inputString'in geri kalanını toplayan $ 2 grubu.
• "$1$2" - Grup $ 1 ve grup $ 2'yi bir araya getirmek

Strings'i değiştirmek için, immutable String haricinde değiştirilebilir olduğundan StringBuilder hakkında okuyun. Farklı işlemler burada https://docs.oracle.com/javase/tutorial/java/data/buffers.html bulunabilir . Aşağıdaki kod parçacığı bir StringBuilder oluşturur ve ardından verilen String'i ekler ve ardından ilk karakteri StringBuilder'dan bir String'e geri dönüştürür.

StringBuilder sb = new StringBuilder();

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

String sınıfının replaceFirst işlevini kullanın. Kullanabileceğiniz çok sayıda değiştirme işlevi çeşidi vardır.

Karakter kaldırma üzerinde biraz mantıksal kontrole ihtiyacınız varsa, bunu kullanın

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

Böyle bir kontrole ihtiyacınız yoksa, Oscar veya Bhesh'in bahsettiği şeyleri kullanabilirsiniz. Yerdeler.

Değiştir yöntemini kullanarak dizenin tek karakterini değiştirebiliriz.

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

Dizeden bir karakter çıkarmanın en kolay yolu

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

    }
}

Çoğu kullanım durumunda StringBuilderveya kullanmak substringiyi bir yaklaşımdır (daha önce yanıtlandığı gibi). Ancak performans açısından kritik kod için bu iyi bir alternatif olabilir.

/**
 * 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 ve deletecharAt kullanarak dize değerini silebilirsiniz.

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

Evet. Java'da bir dizenin tek bir karakterini, yani deleteCharAt'ı kaldırmak için dahili fonksiyonumuz var.

Örneğin,

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

Çıktı

Before : helloworld
After : heloworld

Belirli bir int dizinindeki bir String str'den bir char kaldırmak istiyorsanız :

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


            }

Bu tür sorularım olduğunda her zaman sorarım: "Java Ustaları ne yapardı?" :)

Ve buna, bu durumda, uygulamasına bakarak cevap verirdim String.trim().

İşte daha fazla kırpma karakterinin kullanılmasına izin veren bu uygulamanın bir tahmini.

Bununla birlikte, orijinal kırpmanın aslında tüm karakterleri kaldırdığını unutmayın <= ' ', bu nedenle istenen sonucu elde etmek için bunu orijinalle birleştirmeniz gerekebilir.

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

Verilen Dizeden Tek Bir Karakteri Kaldırmak için lütfen yöntemimi bulun ve yararlı olacağını umun. dizeyi kaldırmak için str.replaceAll kullandım, ancak belirli bir dizeden bir karakteri kaldırmanın birçok yolu var, ancak replaceall yöntemini tercih ediyorum.

Karakter Kaldırma Kodu:

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


}

Konsol resmi:

lütfen Ekli konsol görüntüsünü bulun,

Sorduğunuz için teşekkürler. :)

Bir String'den bir karakter veya karakter grubunu kaldıran bu yardımcı program sınıfını henüz uyguladım . Hızlı olduğunu düşünüyorum çünkü Regexp kullanmıyor. Umarım birine yardımcı olur!

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

Çıktı şu:

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

Örneğin, String'de kaç tane a olduğunu hesaplamak istiyorsanız, bunu şu şekilde yapabilirsiniz:

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