我不得不将一个 int "123456" 的每个值拆分为一个 Int[] 并且我已经有了一个解决方案，但我不知道有没有更好的方法： 我的解决方案是：
public static int[] intToArray(int num){
String holder = num.ToString();
int[] numbers = new int[Holder.ToString().Length];
for(int i=0;i<numbers.length;i++){
numbers[i] = Convert.toInt32(holder.CharAt(i));
}
return numbers;
}
【问题讨论】：
使用LINQ的简单解决方案
int[] result = yourInt.ToString().Select(o=> Convert.ToInt32(o) - 48 ).ToArray()
【讨论】：
-12）——即使它只是对函数域的记录限制。原帖本身并没有这个限制。
我相信这会比来回转换要好。与 JBSnorro 的回答相反，我在转换为数组后反转，因此避免使用 IEnumerable，我认为这将有助于加快代码速度。此方法适用于非负数，因此0 将返回new int[1] { 0 }。
如果它适用于负数，您可以使用n = Math.Abs(n)，但我认为这没有意义。
此外，如果它应该具有更高的性能，我可以创建最终的数组，首先进行类似于二分搜索的 if 语句组合以确定位数。
public static int[] digitArr(int n)
{
if (n == 0) return new int[1] { 0 };
var digits = new List<int>();
for (; n != 0; n /= 10)
digits.Add(n % 10);
var arr = digits.ToArray();
Array.Reverse(arr);
return arr;
}
2018 年更新：
public static int numDigits(int n) {
if (n < 0) {
n = (n == Int32.MinValue) ? Int32.MaxValue : -n;
}
if (n < 10) return 1;
if (n < 100) return 2;
if (n < 1000) return 3;
if (n < 10000) return 4;
if (n < 100000) return 5;
if (n < 1000000) return 6;
if (n < 10000000) return 7;
if (n < 100000000) return 8;
if (n < 1000000000) return 9;
return 10;
}
public static int[] digitArr2(int n)
{
var result = new int[numDigits(n)];
for (int i = result.Length - 1; i >= 0; i--) {
result[i] = n % 10;
n /= 10;
}
return result;
}
【讨论】：
List 和Reverse。
int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x);
但如果你想将其转换为 1,2,3,4,5:
int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x - 48);
【讨论】：
OPs 样本中得到它。
我会这样做：
var result = new List<int>();
while (num != 0) {
result.Insert(0, num % 10);
num = num / 10;
}
return result.ToArray();
性能稍差但可能更优雅的是：
return num.ToString().Select(c => Convert.ToInt32(c.ToString())).ToArray();
请注意，它们都返回 1,2,3,4,5,6 而不是 49,50,51,52,53,54（即字符 '1','2','3 的字节码','4','5','6') 就像您的代码一样。我认为这是实际意图？
【讨论】：
使用从 int 到 string 并返回的转换可能不是那么快。我会使用以下
public static int[] ToDigitArray(int i)
{
List<int> result = new List<int>();
while (i != 0)
{
result.Add(i % 10);
i /= 10;
}
return result.Reverse().ToArray();
}
我必须注意，这只适用于严格的正整数。
编辑：
我想出了一个替代方案。如果性能确实是个问题，这可能会更快，尽管您只能通过自己检查您的特定用途和应用程序来确定。
public static int[] ToDigitArray(int n)
{
int[] result = new int[GetDigitArrayLength(n)];
for (int i = 0; i < result.Length; i++)
{
result[result.Length - i - 1] = n % 10;
n /= 10;
}
return result;
}
private static int GetDigitArrayLength(int n)
{
if (n == 0)
return 1;
return 1 + (int)Math.Log10(n);
}
这在 n 为非负数时有效。
【讨论】：
感谢ASCII character table。使用 LINQ above 的简单答案产生答案 + 48。
要么
int[] result = youtInt.ToString().Select(o => Convert.ToInt32(o) - 48).ToArray();
或
int[] result = youtInt.ToString().Select(o => int.Parse(o.ToString())).ToArray();
可以使用
【讨论】：
你可以做到这一点，而无需将其转换为字符串并返回：
public static int[] intToArray(int num) {
List<int> numbers = new List<int>();
do {
numbers.Insert(0, num % 10);
num /= 10;
} while (num > 0);
return numbers.ToArray();
}
当然，它只适用于正值，但您的原始代码也有这个限制。
【讨论】：
string DecimalToBase(int iDec, int numbase)
{
string strBin = "";
int[] result = new int[32];
int MaxBit = 32;
for(; iDec > 0; iDec/=numbase)
{
int rem = iDec % numbase;
result[--MaxBit] = rem;
}
for (int i=0;i<result.Length;i++)
if ((int)result.GetValue(i) >= base10)
strBin += cHexa[(int)result.GetValue(i)%base10];
else
strBin += result.GetValue(i);
strBin = strBin.TrimStart(new char[] {'0'});
return strBin;
}
int BaseToDecimal(string sBase, int numbase)
{
int dec = 0;
int b;
int iProduct=1;
string sHexa = "";
if (numbase > base10)
for (int i=0;i<cHexa.Length;i++)
sHexa += cHexa.GetValue(i).ToString();
for(int i=sBase.Length-1; i>=0; i--,iProduct *= numbase)
{
string sValue = sBase[i].ToString();
if (sValue.IndexOfAny(cHexa) >=0)
b=iHexaNumeric[sHexa.IndexOf(sBase[i])];
else
b= (int) sBase[i] - asciiDiff;
dec += (b * iProduct);
}
return dec;
}
【讨论】：
我有类似的要求 .. 我从许多好主意中汲取了一些灵感，并添加了一些缺失的部分 .. 许多人没有处理零值或负值。这就是我想出的：
public static int[] DigitsFromInteger(int n)
{
int _n = Math.Abs(n);
int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
int[] digits = new int[length];
for (int i = 0; i < length; i++)
{
digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
_n /= 10;
}
return digits;
}
我认为这很干净..虽然，我们确实在每次迭代中进行条件检查和几个无关的计算..虽然我认为它们在这种情况下是名义上的，但您可以进一步优化方式：
public static int[] DigitsFromInteger(int n)
{
int _n = Math.Abs(n);
int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
int[] digits = new int[length];
for (int i = 0; i < length; i++)
{
//digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
digits[(length - i) - 1] = _n % 10;
_n /= 10;
}
if (n < 0)
digits[0] *= -1;
return digits;
}
【讨论】：
我会按以下方式转换它
if (num == 0) return new int[1] { 0 };
var digits = new List<int>();
while (num > 0)
{
digits.Add(num % 10);
num /= 10;
}
var arr = digits.ToArray().Reverse().ToArray();
【讨论】：
这是将整数转换为数组的好解决方案，即：
int a= 5478 到 int[]
例如，如果您有一个字符串并且想要将字符串转换为整数数组，则没有问题
字符串 str=4561; //转换成
数组[0]=4;
数组[1]=5;
数组[2]=6;
数组[3]=7;
注意：devider 中的零 (0) 的数量等于输入的长度，并根据您的输入长度设置您的数组长度
现在检查编码：
string str=4587;
int value = Convert.ToInt32(str);
int[] arr = new int[4];
int devider = 10000;
for (int i = 0; i < str.Length; i++)
{
int m = 0;
devider /= 10;
arr[i] = value / devider;
m = value / devider;
value -= (m * devider);
}
【讨论】：
private static int[] ConvertIntToArray(int variable)
{
string converter = "" + variable;
int[] convertedArray = new int[converter.Length];
for (int i=0; i < convertedArray.Length;i++) //it can be also converter.Length
{
convertedArray[i] = int.Parse(converter.Substring(i, 1));
}
return convertedArray;
}
我们通过 using 方法得到 int。然后，立即将其转换为string (123456->"123456")。我们有一个名为converter 的字符串并带有int 值。我们的字符串有一个string.Length，尤其是与int 相同的长度，因此，我们创建一个名为convertedArray 的array，我们有长度，即converter(string) 长度。然后，我们进入循环，使用string.Substring(i,1)将字符串一一转换为int，并赋值convertedArray[i]。然后，返回convertedArray。在main 或任何您可以轻松调用该方法的方法。
【讨论】：
public static int[] intToArray(int num)
{
num = Math.Abs(num);
int length = num.ToString().Length;
int[] arr = new int[length];
do
{
arr[--length] = num % 10;
num /= 10;
} while (num != 0);
return arr;
}
除以系统基数（在这种情况下为十进制）删除最右边的数字，我们通过余数运算符得到那个数字。我们不断重复，直到我们最终得到一个零。每次删除一个数字时，它将从数组末尾开始并向后存储在数组中，以避免需要在末尾反转数组。 Math.Abs() 函数用于处理负输入，并且该数组被实例化为与输入长度相同的大小。
【讨论】：
整数或长整型数组 C# 将其转换为 char 数组并减去 48。
public static int[] IntToArray(int value, int length)
{
char[] charArray = new char[length];
charArray = value.ToString().ToCharArray();
int[] intArray = new int[length];
for (int i = 0; i < intArray.Length; i++)
{
intArray[i] = charArray[i] - 48;
}
return intArray;
}
public static int[] LongToIntArray(long value, int length)
{
char[] charArray = new char[length];
charArray = value.ToString().ToCharArray();
int[] intArray = new int[length];
for (int i = 0; i < intArray.Length; i++)
{
intArray[i] = charArray[i] - 48;
}
return intArray;
}
【讨论】：
做 MarkXA 的单行版本的稍微简洁的方法：
int[] result = n.ToString().Select(c => (int)Char.GetNumericValue(c)).ToArray();
GetNumericValue 以双精度形式返回 char 中的可见数字，因此如果您的字符串是“12345”，它将返回双精度值 1、2、3、4、5，每个都可以转换为 int。请注意，在 C# 中对 char 使用 Convert.ToInt32 会返回 ASCII 码，因此您将得到 49、50、51、52、53。这可能会导致错误，这是可以理解的。
【讨论】：