如何通过索引从字符串中删除单个字符

为了在 Java 中访问字符串的各个字符，我们使用 String.charAt(2)。是否有任何内置函数来删除 Java 中字符串的单个字符？

就像这样:

if(String.charAt(1) == String.charAt(2){
//I want to remove the individual character at index 2.
}
867179 次浏览
小开

不，因为 Java 中的字符串是不可变的。您必须创建一个新的字符串来删除您不需要的字符。

要替换字符串 str中位于索引位置 idx的单个字符 c，请执行下面的操作，并记住将创建一个新字符串:

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

使用 String 类的 replaceFirst 函数。

小开

一种可能性是:

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

注意，结果是一个新的 String (以及两个中间的 String 对象) ，因为 Java 中的 String 是不可变的。

小开
最佳答案

您还可以使用可变的 StringBuilder类。

StringBuilder sb = new StringBuilder(inputString);

它具有 deleteCharAt()方法，以及许多其他的 mutator 方法。

只需删除需要删除的字符，然后得到如下结果:

String resultString = sb.toString();

这样可以避免创建不必要的字符串对象。

小开

如果您需要对字符删除进行一些逻辑控制，请使用

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

如果你不需要任何这样的控制，你可以使用奥斯卡或 Bhesh 提到的。他们是准确的。

小开

例如，如果你想计算字符串中有多少个 a，你可以这样做:

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

您可以使用 Java 字符串方法(称为 change) ，它将用第二个参数替换与第一个参数匹配的所有字符:

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

您还可以使用(巨大的) regexp 计算机。

inputString = inputString.replaceFirst("(?s)(.{2}).(.*)", "$1$2");
  • "(?s)" -告诉 regexp 像处理普通字符一样处理换行符(以防万一)。
  • "(.{2})" -组 $1正好收集2个字符
  • "." -索引2处的任何字符(将被挤出)。
  • "(.*)" -组 $2，它收集 inputString 的其余部分。
  • "$1$2" -将组 $1和组 $2放在一起。
小开

通过使用替换方法，我们可以改变字符串的单个字符。

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

从 string 中删除字符的最简单方法

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

考虑以下代码:

public String removeChar(String str, Integer n) {
String front = str.substring(0, n);
String back = str.substring(n+1, str.length());
return front + back;
}
小开 
String str = "M1y java8 Progr5am";

()

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

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


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




}
小开

在大多数用例中，使用 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+""));
}
}
小开

当我有这样的问题时，我总是问: “ Java 大师会怎么做?”:)

在本例中，我将通过研究 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;
}
小开

如果您想在特定的 Int < em > index 上从 字符串 < em > 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;


}
小开

要从给定字符串中删除一个字符，请找到我的方法，希望它会有用。我已经使用 str.replaceAll 来删除字符串，但是他们有很多方法来从给定的字符串中删除字符，但是我更喜欢 replaceall 方法。

移除字符代码:

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




}

控制台图片:

请找到所附的控制台图像,

enter image description here

谢谢关心:)

小开

要修改 String，请阅读 StringBuilder，因为除了不可变的 String 之外，StringBuilder 是可变的。在这里可以找到不同的操作。下面的代码片段创建一个 StringBuilder，然后附加给定的 String，然后从 String 中删除第一个字符，然后将其从 StringBuilder 转换回 String。

StringBuilder sb = new StringBuilder();


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

我刚刚实现了这个实用程序类 从 String 中移除一个字符或一组字符。我认为它之所以快是因为它不使用 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

提交答案