每隔第N个字符/数字拆分一个字符串/数字？-Java 学习之路

我需要将一个数字拆分成偶数部分，例如：
32427237需要成为324 272 37
103092501需要成为103 092 501

我相信我可以接下来的数字，但我确信有一种更有效的方式，因为我不想错过这些数字中的字符 - 数字本身可以是任意长度所以如果数字是1234567890我希望它分成这些部分123 456 789 0

我已经看过其他语言的例子，比如Python等，但我不太了解它们将它们转换为C＃ - 循环通过字符然后在第三个获取前一个然后该索引来获取字符串的部分可能做好这份工作，但我愿意接受如何更好地完成这项工作的建议 .

13 回答

如果您必须在代码中的许多地方执行此操作，您可以创建一个花哨的扩展方法：

static class StringExtensions {

  public static IEnumerable<String> SplitInParts(this String s, Int32 partLength) {
    if (s == null)
      throw new ArgumentNullException("s");
    if (partLength <= 0)
      throw new ArgumentException("Part length has to be positive.", "partLength");

    for (var i = 0; i < s.Length; i += partLength)
      yield return s.Substring(i, Math.Min(partLength, s.Length - i));
  }

}

然后你可以像这样使用它：

var parts = "32427237".SplitInParts(3);
Console.WriteLine(String.Join(" ", parts));

根据需要输出为 324 272 37 .

回复于 2024-04-19T07:29:31+08:00

你可以使用一个简单的for循环在每个第n个位置插入空格：

string input = "12345678";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
    if (i % 3 == 0)
        sb.Append(' ');
    sb.Append(input[i]);
}
string formatted = sb.ToString();

回复于 2024-04-19T07:29:31+08:00

LINQ规则：

var input = "1234567890";
var partSize = 3;

var output = input.ToCharArray()
    .BufferWithCount(partSize)
    .Select(c => new String(c.ToArray()));

UPDATED:

string input = "1234567890";
double partSize = 3;
int k = 0;
var output = input
    .ToLookup(c => Math.Floor(k++ / partSize))
    .Select(e => new String(e.ToArray()));

回复于 2024-04-19T07:29:31+08:00

一种非常简单的方法（不是最有效的，但不是最有效的数量级） .

public static List<string> GetChunks(string value, int chunkSize)
    {
        List<string> triplets = new List<string>();
        while (value.Length > chunkSize)
        {
            triplets.Add(value.Substring(0, chunkSize));
            value = value.Substring(chunkSize);
        }
        if (value != "")
            triplets.Add(value);
        return triplets;
    }

继承人

public static List<string> GetChunkss(string value, int chunkSize)
    {
        List<string> triplets = new List<string>();
        for(int i = 0; i < value.Length; i += chunkSize)
            if(i + chunkSize > value.Length)
                triplets.Add(value.Substring(i));
            else
                triplets.Add(value.Substring(i, chunkSize));

        return triplets;
    }

回复于 2024-04-19T07:29:31+08:00

分裂方法：

public static IEnumerable<string> SplitInGroups(this string original, int size) {
  var p = 0;
  var l = original.Length;
  while (l - p > size) {
    yield return original.Substring(p, size);
    p += size;
  }
  yield return original.Substring(p);
}

要以字符串形式连接，以空格分隔：

var joined = String.Join(" ", myNumber.SplitInGroups(3).ToArray());

编辑：我更喜欢Martin Liversage解决方案:)

编辑2：修正了一个错误 .

编辑3：添加了加入字符串的代码 .

回复于 2024-04-19T07:29:31+08:00

这已经晚了半年但是：

int n = 3;
string originalString = "32427237";
string splitString = string.Join(string.Empty,originalString.Select((x, i) => i > 0 && i % n == 0 ? string.Format(" {0}", x) : x.ToString()));

回复于 2024-04-19T07:29:31+08:00

我会做这样的事情，虽然我确定还有其他方法 . 应该表现得很好 .

public static string Format(string number, int batchSize, string separator)
{      
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i <= number.Length / batchSize; i++)
  {
    if (i > 0) sb.Append(separator);
    int currentIndex = i * batchSize;
    sb.Append(number.Substring(currentIndex, 
              Math.Min(batchSize, number.Length - currentIndex)));
  }
  return sb.ToString();
}

回复于 2024-04-19T07:29:31+08:00

我喜欢这个因为它很酷，虽然效率不高：

var n = 3;
var split = "12345678900"
            .Select((c, i) => new { letter = c, group = i / n })
            .GroupBy(l => l.group, l => l.letter)
            .Select(g => string.Join("", g))
            .ToList();

回复于 2024-04-19T07:29:31+08:00

7
试试这个：
```
Regex.Split(num.toString(), "(?<=^(.{8})+)");
```
回复于 2024-04-19T07:29:31+08:00

如果您知道整个字符串的长度可以被部件大小完全整除，那么使用：

var whole = "32427237!";
var partSize = 3;
var parts = Enumerable.Range(0, whole.Length / partSize)
    .Select(i => whole.Substring(i * partSize, partSize));

但是如果整个字符串有可能在最后有一个小块，你需要更复杂一点：

var whole = "32427237";
var partSize = 3;
var parts = Enumerable.Range(0, (whole.Length + partSize - 1) / partSize)
    .Select(i => whole.Substring(i * partSize, Math.Min(whole.Length - i * partSize, partSize)));

在这些示例中，部件将是IEnumerable，但您可以在末尾添加.ToArray（）或.ToList（），以防您需要string []或List <string>值 .

回复于 2024-04-19T07:29:31+08:00

1
使用其他StackOverflow问题的答案的一个很好的实现：
```
"32427237"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" ");  // "324 272 37"

"103092501"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" "); // "103 092 501"
```
AsChunks（）：https://stackoverflow.com/a/22452051/538763

ToCsv（）：https://stackoverflow.com/a/45891332/538763
回复于 2024-04-19T07:29:31+08:00
0

这可能是偏离主题的，因为我不知道你为什么希望以这种方式格式化数字，所以如果它不相关，请忽略这篇文章...

整数的显示方式因不同文化而异 . 您应该以本地独立方式执行此操作，以便稍后本地化您的更改 .

int.ToString采用不同的参数，可用于格式化不同的文化 . "N"参数为您提供了特定于文化的分组的标准格式 .

steve x string formatting也是一个很好的资源 .

回复于 2024-04-19T07:29:31+08:00

103

对于分割字符串并返回每个地方具有特定字符数的字符串列表，这是我的功能：

public List<string> SplitStringEveryNth(string input, int chunkSize)
    {
        var output = new List<string>();
        var flag = chunkSize;
        var tempString = string.Empty;
        var lenght = input.Length;
        for (var i = 0; i < lenght; i++)
        {
            if (Int32.Equals(flag, 0))
            {
                output.Add(tempString);
                tempString = string.Empty;
                flag = chunkSize;
            }
            else
            {
                tempString += input[i];
                flag--;
            }

            if ((input.Length - 1) == i && flag != 0)
            {
                tempString += input[i];
                output.Add(tempString);
            }
        }
        return output;
    }

回复于 2024-04-19T07:29:31+08:00

每隔第N个字符/数字拆分一个字符串/数字？

13 回答

相关问题