为了在 Java 中访问字符串的单个字符，我们有 String.charAt(2)。是否有任何内置函数可以删除java中字符串的单个字符？
类似这样的：
if(String.charAt(1) == String.charAt(2){
//I want to remove the individual character at index 2.
}
【问题讨论】：
couple 或substring 和indexOf 来实现。但这会创建一个新的字符串对象。
您也可以使用可变的StringBuilder 类。
StringBuilder sb = new StringBuilder(inputString);
它有 deleteCharAt() 方法，以及许多其他的 mutator 方法。
只需删除需要删除的字符，然后得到如下结果：
String resultString = sb.toString();
这样可以避免创建不必要的字符串对象。
【讨论】：
String numbers = "0123456789"; char c = '2'; numbers = numbers.replace(c, Character.MIN_VALUE); 我想替换' '字符（空）
您可以使用Java String 方法replace，它将所有匹配第一个参数的字符替换为第二个参数：
String a = "Cool";
a = a.replace("o","");
【讨论】：
一种可能性：
String result = str.substring(0, index) + str.substring(index+1);
请注意，结果是一个新的字符串（以及两个中间字符串对象），因为 Java 中的字符串是不可变的。
【讨论】：
index是最后一个字符时，那么index+1等于字符串的长度，str.substring(str.length)返回一个空字符串。
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);
【讨论】：
不，因为 Java 中的字符串是不可变的。您必须创建一个新字符串来删除您不想要的字符。
要替换字符串str 中索引位置idx 的单个字符c，请执行以下操作，并记住将创建一个新字符串：
String newstr = str.substring(0, idx) + str.substring(idx + 1);
【讨论】：
考虑以下代码：
public String removeChar(String str, Integer n) {
String front = str.substring(0, n);
String back = str.substring(n+1, str.length());
return front + back;
}
【讨论】：
要修改字符串，请阅读 StringBuilder，因为它是可变的，除了不可变的字符串。不同的操作可以在这里找到https://docs.oracle.com/javase/tutorial/java/data/buffers.html。下面的代码 sn-p 创建一个 StringBuilder，然后附加给定的 String，然后从 String 中删除第一个字符，然后将其从 StringBuilder 转换回 String。
StringBuilder sb = new StringBuilder();
sb.append(str);
sb.deleteCharAt(0);
str = sb.toString();
【讨论】：
您也可以使用（巨大的）正则表达式机器。
inputString = inputString.replaceFirst("(?s)(.{2}).(.*)", "$1$2");
"(?s)" - 告诉正则表达式像普通字符一样处理换行符（以防万一）。"(.{2})" - group $1 正好收集 2 个字符"." - 索引 2 处的任何字符（将被挤出）。"(.*)" - group $2 收集其余的 inputString。"$1$2" - 将 $1 组和 $2 组放在一起。【讨论】：
通过使用replace方法我们可以改变字符串的单个字符。
string= string.replace("*", "");
【讨论】：
如果您想从 String str 中特定 int index 处删除一个字符：： p>
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;
}
【讨论】：
使用 String 类的 replaceFirst 函数。替换功能有很多变种可供您使用。
【讨论】：
如果您需要对字符删除进行逻辑控制，请使用此
String string = "sdsdsd";
char[] arr = string.toCharArray();
// Run loop or whatever you need
String ss = new String(arr);
如果您不需要任何此类控制，您可以使用 Oscar orBhesh 提到的。他们在现场。
【讨论】：
从字符串中删除字符的最简单方法
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+""));
}
}
【讨论】：
是的。我们在java中内置了删除字符串的单个字符的函数，即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
【讨论】：
要从给定字符串中删除单个字符，请找到我的方法，希望它有用。我已经使用 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), "");
}
}
}
控制台图片：
请找到控制台的附件图片，
感谢您的提问。 :)
【讨论】：
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 大师会做什么？” :)
在这种情况下，我会通过查看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;
}
【讨论】：
我刚刚实现了这个实用程序类，它从字符串中删除一个字符或一组字符。我认为它很快，因为不使用正则表达式。我希望它可以帮助某人！
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", "");
}
【讨论】：