C# 整型数组到字符串
在C#中，我有一个整数数组，只包含数字。我想把这个数组转换成字符串 阵列示例：C# 整型数组到字符串,c#,arrays,string,C#,Arrays,String,在C#中，我有一个整数数组，只包含数字。我想把这个数组转换成字符串 阵列示例： int[] arr = {0,1,2,3,0,1}; 如何将其转换为以下格式的字符串：“012301”？at.net 3.5使用： String.Join("", new List<int>(array).ConvertAll(i => i.ToString()).ToArray()); （免责声明：如果您有很多数字（至少数百个），并且您关心性能，我建议您避免使用此方法，并使用StringBu
int[] arr = {0,1,2,3,0,1};
“012301” String.Join("", new List<int>(array).ConvertAll(i => i.ToString()).ToArray());
StringBuilder int[] arr = {0,1,2,3,0,1};
string results = string.Join("",arr.Select(i => i.ToString()).ToArray());
这就是你的结果。我把它留给了后代，但不推荐使用，因为它的可读性不太好。尤其是现在，我回来看看是否过了一段时间，想知道我写这篇文章的时候在想什么（我可能在想‘废话，一定要在别人给出答案之前把这篇文章写下来’）
string s=string.Concat（arr.Cast（）.ToArray（））；
var builder = new StringBuilder();
Array.ForEach(arr, x => builder.Append(x));
var res = builder.ToString();
string.JoinIEnumerablestring.Join("", from i in arr select i.ToString())
我喜欢将
StringBuilderAggregate（）一起使用。“技巧”是Append（）
返回StringBuilder
实例本身：
var sb = arr.Aggregate( new StringBuilder(), ( s, i ) => s.Append( i ) );
var result = sb.ToString();
我意识到我的观点可能不受欢迎，但我想我很难加入Linq-y乐队。很漂亮。它是浓缩的。我明白了，我并不反对在合适的地方使用它。也许只是我，但我觉得人们已经不再考虑创建实用函数来实现他们想要的，而是更喜欢（有时）用过长的Linq代码行来填充代码，以创建密集的1行代码
我并不是说人们在这里提供的任何Linq答案都是不好的，但我想我觉得这些代码行可能会变得越来越长，越来越模糊，因为您需要处理各种情况。如果您的数组为空怎么办？如果您想要一个带分隔符的字符串，而不是纯粹的连接字符串，该怎么办？如果数组中的某些整数是两位数，并且希望用前导零填充每个值，以便每个元素的字符串与其余元素的长度相同，该怎么办
以提供的其中一个答案为例：
result = arr.Aggregate(string.Empty, (s, i) => s + i.ToString());
如果我需要担心数组为空，现在它变成了：
result = (arr == null) ? null : arr.Aggregate(string.Empty, (s, i) => s + i.ToString());
result = (arr == null) ? null : arr.Skip(1).Aggregate(arr[0].ToString(), (s, i) => s + "," + i.ToString());
如果我想要一个逗号分隔的字符串，现在它变成：
result = (arr == null) ? null : arr.Aggregate(string.Empty, (s, i) => s + i.ToString());
result = (arr == null) ? null : arr.Skip(1).Aggregate(arr[0].ToString(), (s, i) => s + "," + i.ToString());
这还不算太糟糕，但我认为这行代码的作用并不明显
当然，没有什么可以阻止您将这一行代码扔进自己的实用程序函数中，这样您就不会在应用程序逻辑中混入那么长的混乱，尤其是在多个地方执行时：
public static string ToStringLinqy<T>(this T[] array, string delimiter)
{
// edit: let's replace this with a "better" version using a StringBuilder
//return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(array[0].ToString(), (s, i) => s + "," + i.ToString());
return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(new StringBuilder(array[0].ToString()), (s, i) => s.Append(delimiter).Append(i), s => s.ToString());
}
公共静态字符串ToStringLinqy（此T[]数组，字符串分隔符）
{
//编辑：让我们使用StringBuilder将其替换为“更好”的版本
//return（array==null）？null：（array.Length==0）？string.Empty:array.Skip（1）.Aggregate（数组[0].ToString（），（s，i）=>s+，“+i.ToString（））；
return（array==null）？null：（array.Length==0）？string.Empty:array.Skip（1）.Aggregate（新的StringBuilder（数组[0].ToString（）），（s，i）=>s.Append（分隔符）.Append（i），s=>s.ToString（））；
}
但如果你想把它放到一个实用函数中，你真的需要把它压缩成一行吗？在这种情况下，为清晰起见，为什么不多加几行代码，并利用StringBuilder，这样就不会重复进行连接操作：
public static string ToStringNonLinqy<T>(this T[] array, string delimiter)
{
if (array != null)
{
// edit: replaced my previous implementation to use StringBuilder
if (array.Length > 0)
{
StringBuilder builder = new StringBuilder();
builder.Append(array[0]);
for (int i = 1; i < array.Length; i++)
{
builder.Append(delimiter);
builder.Append(array[i]);
}
return builder.ToString()
}
else
{
return string.Empty;
}
}
else
{
return null;
}
}
公共静态字符串ToStringNonLinqy（此T[]数组，字符串分隔符）
{
if（数组！=null）
{
//编辑：替换我以前的实现以使用StringBuilder
如果（array.Length>0）
{
StringBuilder=新的StringBuilder（）；
Append（数组[0]）；
for（int i=1；i
如果您真的非常关心性能，甚至可以将其转换为一个混合函数，根据数组中的元素数量决定是执行string.Join还是使用StringBuilder（这是一个微观优化，在我看来不值得做，可能弊大于利，但我将其作为这个问题的一个例子）：
公共静态字符串ToString（此T[]数组，字符串分隔符）
{
if（数组！=null）
{
//确定数组的长度是否大于使用stringbuilder的性能阈值
//10只是我选择的任意阈值
如果（数组长度<10）
{
//假设对于少于10个元素的数组
//此代码将比StringBuilder更高效。
//注意：这是一个疯狂/毫无意义的微优化。不要这样做。
字符串[]值=新字符串[array.Length]；
for（int i=0；i public static string ToStringLinqy<T>(this T[] array, string delimiter)
{
// edit: let's replace this with a "better" version using a StringBuilder
//return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(array[0].ToString(), (s, i) => s + "," + i.ToString());
return (array == null) ? null : (array.Length == 0) ? string.Empty : array.Skip(1).Aggregate(new StringBuilder(array[0].ToString()), (s, i) => s.Append(delimiter).Append(i), s => s.ToString());
}
public static string ToStringNonLinqy<T>(this T[] array, string delimiter)
{
if (array != null)
{
// edit: replaced my previous implementation to use StringBuilder
if (array.Length > 0)
{
StringBuilder builder = new StringBuilder();
builder.Append(array[0]);
for (int i = 1; i < array.Length; i++)
{
builder.Append(delimiter);
builder.Append(array[i]);
}
return builder.ToString()
}
else
{
return string.Empty;
}
}
else
{
return null;
}
}
public static string ToString<T>(this T[] array, string delimiter)
{
if (array != null)
{
// determine if the length of the array is greater than the performance threshold for using a stringbuilder
// 10 is just an arbitrary threshold value I've chosen
if (array.Length < 10)
{
// assumption is that for arrays of less than 10 elements
// this code would be more efficient than a StringBuilder.
// Note: this is a crazy/pointless micro-optimization. Don't do this.
string[] values = new string[array.Length];
for (int i = 0; i < values.Length; i++)
values[i] = array[i].ToString();
return string.Join(delimiter, values);
}
else
{
// for arrays of length 10 or longer, use a StringBuilder
StringBuilder sb = new StringBuilder();
sb.Append(array[0]);
for (int i = 1; i < array.Length; i++)
{
sb.Append(delimiter);
sb.Append(array[i]);
}
return sb.ToString();
}
}
else
{
return null;
}
}
// convert an enumeration of one type into an enumeration of another type
public static IEnumerable<TOut> Convert<TIn, TOut>(this IEnumerable<TIn> input, Func<TIn, TOut> conversion)
{
foreach (TIn value in input)
{
yield return conversion(value);
}
}
// concatenate the strings in an enumeration separated by the specified delimiter
public static string Delimit<T>(this IEnumerable<T> input, string delimiter)
{
IEnumerator<T> enumerator = input.GetEnumerator();
if (enumerator.MoveNext())
{
StringBuilder builder = new StringBuilder();
// start off with the first element
builder.Append(enumerator.Current);
// append the remaining elements separated by the delimiter
while (enumerator.MoveNext())
{
builder.Append(delimiter);
builder.Append(enumerator.Current);
}
return builder.ToString();
}
else
{
return string.Empty;
}
}
// concatenate all elements
public static string ToString<T>(this IEnumerable<T> input)
{
return ToString(input, string.Empty);
}
// concatenate all elements separated by a delimiter
public static string ToString<T>(this IEnumerable<T> input, string delimiter)
{
return input.Delimit(delimiter);
}
// concatenate all elements, each one left-padded to a minimum length
public static string ToString<T>(this IEnumerable<T> input, int minLength, char paddingChar)
{
return input.Convert(i => i.ToString().PadLeft(minLength, paddingChar)).Delimit(string.Empty);
}
int[] arr = { 0, 1, 2, 3, 0, 1 };
// 012301
result = arr.ToString<int>();
// comma-separated values
// 0,1,2,3,0,1
result = arr.ToString(",");
// left-padded to 2 digits
// 000102030001
result = arr.ToString(2, '0');
int[] arr = {0,1,2,3,0,1};
string result = new string(Array.ConvertAll<int,char>(arr, x => Convert.ToChar(x + '0')));
string result = string.Join(string.Empty, new []{0,1,2,3,0,1});
string result = string.Join(null, new object[]{0,1,2,3,0,"A",DateTime.Now});
var sb = arr.Aggregate(new StringBuilder(), ( s, i ) => s.Append( i ), s.ToString());