java将字符串转义的方法 java将字符转换为字符串

我有一个char，我需要一个String。如何从一个转换到另一个？

否决了？为什么我要问这么简单的问题？因为谷歌对这个问题缺乏一个非常明显的搜索结果。把这个放在这里，我们会改变的。

我完全同意你的意见。我投了赞成票，以摆脱反对票。我坚信要让像这样的谷歌话题对每个人都更容易。=)

你的立场值得商榷(元问题？)我想我们可以假设投票结果是"缺乏研究"。

我做过研究。我不得不点击一些搜索结果，查看冗长的博客文章和广告。

你的研究是否包括阅读字符串类的文档？

@djclayworth大多数这样的问题可以用rtfm回答，但这不是很有帮助。为什么不让那些发现问题的人投反对票，让事情顺其自然呢？

@宝贝洛拉只有斯塔克溢出已经成为研究的第一站。如果在前10个谷歌搜索结果中有stackoverfow链接，我会在这里登陆。

您可以使用Character.toString(char)。注意，这个方法只返回一个对String.valueOf(char)的调用，它也可以工作。

正如其他人所指出的，字符串连接也可以作为快捷方式：

String s ="" + 's';

但这可以归结为：

String s = new StringBuilder().append("").append('s').toString();

由于StringBuilder由char[]支持(由StringBuilder()过度分配给16)，因此效率较低，因为该数组只能由生成的String进行防御复制。

String.valueOf(char)通过将char包装在单个元素数组中并传递给包私有构造函数String(char[], boolean)来"进入后门"，从而避免了数组复制。

我认为：new StringBuilder("").append('s').toString();compiles的快捷方式到

"binkansalaryman用javac 1.8.0 javap _ 51到小鼠黑色素瘤B16细胞，然后反编译，我看到我有一个方法调用的构造函数中/答案。你是做什么用的？

好问题。我有以下几种方法可以做到。

1. String stringValueOf = String.valueOf('c'); // most efficient
2. String stringValueOfCharArray = String.valueOf(new char[]{x});
3. String characterToString = Character.toString('c');
4. String characterObjectToString = new Character('c').toString();
// Although this method seems very simple,
// this is less efficient because the concatenation
// expands to new StringBuilder().append(x).append("").toString();
5. String concatBlankString = 'c' +"";
6. String fromCharArray = new String(new char[]{x});
Note: Character.toString(char) returns String.valueOf(char). So effectively both are same.
String.valueOf(char[] value)调用new String(char[] value)来设置valuechar数组。
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}

另一方面，String.valueOf(char value)调用以下包私有构造函数。

String(char[] value, boolean share) {
// assert share :"unshared not supported";
this.value = value;
}

源代码源于Java 8源代码中的EDOCX1 17

Hence String.valueOf(char) seems to be most efficient method, in terms of both memory and speed, for converting char to String.

Java中如何将原始字符转换为字符串

如何用Java将字符转换为字符串

以下是将字符C转换为字符串S的各种方法(按速度和效率的降序排列)

char c = 'a';
String s = String.valueOf(c);             // fastest + memory efficient
String s = Character.toString(c);
String s = new String(new char[]{c});
String s = String.valueOf(new char[]{c});
String s = new Character(c).toString();
String s ="" + c;                        // slowest + memory inefficient

使用以下任何一种：

String str = String.valueOf('c');
String str = Character.toString('c');
String str = 'c' +"";

使用Character.toString()方法，如下：

char mChar = 'l';
String s = Character.toString(mChar);

试试这个：Character.toString(aChar)，或者只是这个：aChar +""。

为什么不的toString()方法在字符本身吗？

因为你不能调用Java方法的基本类型char在线等…………………

如@warfox所述-有6种方法可以将char转换为字符串。然而，最快的将是通过串联，尽管上面的答案表明它是String.valueOf。以下是基准，证明：

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, batchSize = 1000, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, batchSize = 1000, timeUnit = TimeUnit.SECONDS)
public class CharToStringConversion {
private char c = 'c';
@Benchmark
public String stringValueOf() {
return String.valueOf(c);
}
@Benchmark
public String stringValueOfCharArray() {
return String.valueOf(new char[]{c});
}
@Benchmark
public String characterToString() {
return Character.toString(c);
}
@Benchmark
public String characterObjectToString() {
return new Character(c).toString();
}
@Benchmark
public String concatBlankStringPre() {
return c +"";
}
@Benchmark
public String concatBlankStringPost() {
return"" + c;
}
@Benchmark
public String fromCharArray() {
return new String(new char[]{c});
}
}

结果：

Benchmark                                        Mode  Cnt       Score      Error  Units
CharToStringConversion.characterObjectToString  thrpt   10   82132.021 ± 6841.497  ops/s
CharToStringConversion.characterToString        thrpt   10  118232.069 ± 8242.847  ops/s
CharToStringConversion.concatBlankStringPost    thrpt   10  136960.733 ± 9779.938  ops/s
CharToStringConversion.concatBlankStringPre     thrpt   10  137244.446 ± 9113.373  ops/s
CharToStringConversion.fromCharArray            thrpt   10   85464.842 ± 3127.211  ops/s
CharToStringConversion.stringValueOf            thrpt   10  119281.976 ± 7053.832  ops/s
CharToStringConversion.stringValueOfCharArray   thrpt   10   86563.837 ± 6436.527  ops/s

如你所见，最快的是c +""或"" + c；

VM version: JDK 1.8.0_131, VM 25.131-b11

这种性能差异是由于-XX:+OptimizeStringConcat优化造成的。你可以在这里读到。

以下是一些方法，没有特别的顺序：

char c = 'c';
String s = Character.toString(c); // Most efficient way
s = new Character(c).toString(); // Same as above except new Character objects needs to be garbage-collected
s = c +""; // Least efficient and most memory-inefficient, but common amongst beginners because of its simplicity
s = String.valueOf(c); // Also quite common
s = String.format("%c", c); // Not common
Formatter formatter = new Formatter();
s = formatter.format("%c", c).toString(); // Same as above
formatter.close();

我们有多种方法可以将char转换为String。一种方法是利用Character类中的静态方法toString()：

char ch = 'I';
String str1 = Character.toString(ch);

实际上，这个toString方法内部使用了String类的valueOf方法，它使用char数组：

public static String toString(char c) {
return String.valueOf(c);
}

所以第二种方法是直接使用它：

String str2 = String.valueOf(ch);

该String类中的valueOf方法使用char数组：

public static String valueOf(char c) {
char data[] = {c};
return new String(data, true);
}

因此，第三种方法是使用匿名数组包装单个字符，然后将其传递给String构造函数：

String str4 = new String(new char[]{ch});

第四种方法是使用串联：

String str3 ="" + ch;

这实际上将使用来自StringBuilder类的append方法，当我们在循环中进行连接时，这实际上是首选的方法。

我正在将char数组转换为字符串

Char[] CharArray={ 'A', 'B', 'C'};
String text = String.copyValueOf(CharArray);

这并没有提供一个答案的问题。一对从作者的批评或要求澄清他们的评论，下面的后离开。从评论

我是"pczeus转换到字符串数组

我已经尝试过这些建议，但最终实现如下

editView.setFilters(new InputFilter[]{new InputFilter()
{
@Override
public CharSequence filter(CharSequence source, int start, int end,
Spanned dest, int dstart, int dend)
{
String prefix ="http://";
//make sure our prefix is visible
String destination = dest.toString();
//Check If we already have our prefix - make sure it doesn't
//get deleted
if (destination.startsWith(prefix) && (dstart <= prefix.length() - 1))
{
//Yep - our prefix gets modified - try preventing it.
int newEnd = (dend >= prefix.length()) ? dend : prefix.length();
SpannableStringBuilder builder = new SpannableStringBuilder(
destination.substring(dstart, newEnd));
builder.append(source);
if (source instanceof Spanned)
{
TextUtils.copySpansFrom(
(Spanned) source, 0, source.length(), null, builder, newEnd);
}
return builder;
}
else
{
//Accept original replacement (by returning null)
return null;
}
}
}});