0

我有一个由换行符分隔的大字符串。该字符串包含 100 行。我想将这些行分成小块，比如 20 块也基于换行符。

假设字符串变量是这样的，

Line1
这是 line2
Line3 在这里
我是 Line4

现在我想把这个大字符串变量分成2个小块。结果应该是2个字符串，

线路 1
这是线路 2

Line3 来了
我是 Line4

使用拆分功能，我没有得到预期的结果。请帮助我实现这一目标。

在此先感谢，
维杰

4

6 回答 6

3

简单的方法（在 Environment.NewLine 上拆分，然后循环并附加）：

public static List<string> GetStringSegments(string originalString, int linesPerSegment)
{

    List<string> segments = new List<string>();
    string[] allLines = originalString.Split(new string[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); 
    StringBuilder sb = new StringBuilder();

    int linesProcessed = 0;
    for (int i = 0; i < allLines.Length; i++)
    {
        sb.AppendLine(allLines[i]);
        linesProcessed++;

        if (linesProcessed == linesPerSegment
            || i == allLines.Length-1)
        {
            segments.Add(sb.ToString());
            sb.Clear();
            inesProcessed = 0;
        }
    }

    return segments;
}

上述方法效率稍低，因为它需要首先将字符串拆分为单独的行，这会创建不必要的字符串。一个 1000 行的字符串将创建一个包含 1000 个字符串的数组。如果我们只扫描字符串并搜索，我们可以改进这一点\n：

public static List<string> GetStringSegments(string original, int linesPerSegment)
{
    List<string> segments = new List<string>();

    int startIndex = 0;
    int newLinesEncountered = 0;

    for (int i = 0; i < original.Length; i++)
    {
        if (original[i] == '\n')
        {
            newLinesEncountered++;
        }

        if (newLinesEncountered == linesPerSegment
            || i == original.Length - 1)
        {
            segments.Add(original.Substring(startIndex, (i - startIndex + 1)));
            startIndex = i + 1;
            newLinesEncountered = 0;
        }
    }

    return segments;
}
于 2012-04-16T06:08:12.457 回答
2

您可以使用http://www.make-awesome.com/2010/08/batch-or-partition-a-collection-with-linq中的批处理运算符之类的东西

string s = "[YOUR DATA]";
var lines = s.Split(new[]{Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
foreach(var batch in lines.Batch(20))
{
  foreach(batchLine in batch)
  {
    Console.Writeline(batchLine);
  }
}

static class LinqEx
{
  // from http://www.make-awesome.com/2010/08/batch-or-partition-a-collection-with-linq
  public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> collection,
                int batchSize)
  {
    List<T> nextbatch = new List<T>(batchSize);
    foreach (T item in collection)
    {
      nextbatch.Add(item);
      if (nextbatch.Count == batchSize)
      {
        yield return nextbatch;
        nextbatch = new List<T>(batchSize);
      }
    }
    if (nextbatch.Count > 0)
      yield return nextbatch;
  }
}
于 2012-04-16T05:51:34.867 回答
1

正如一些人提到的， usingstring.Split会将整个字符串拆分到内存中，这可能是一个分配繁重的操作。这就是为什么我们有这个TextReader类及其后代，它们应该提供更好的内存性能，并且在逻辑上也可能更清晰：

using (var reader = new StringReader(myString))
{
    do
    {
        StringBuilder newString = null;
        StringWriter newStringWriter = null;
        if (lineCounter % 20 == 0)
        {
             newString = new StringBuilder();
             newStringWriter = new StringWriter(newString);
             newStringCollection.Add(newString);
        } 
        string line = reader.ReadLine();
        if (!string.isNullOrEmpty(line))
        {
             newStringWriter.WriteLine(line);
             lineCounter++;
        }
    }
    while (line != null)
}

我们使用StringReader来读取我们的大字符串，一次一行。相应的StringWriter将这些行写入新字符串，一次一行。每 20 行之后，我们开始一个新的StringBuilder（和适当的StringWriter包装器）。

于 2012-04-16T06:30:48.433 回答
0

用换行符分割字符串。然后在使用字符串时将字符串的数量合并/获取。

于 2012-04-16T05:44:14.760 回答
0 
string s = "Line1\nThis is line2 \nLine3 is here\nI am Line4";

string [] str = s.split('\n');

List<String> str1 = new List<String>();

for(int i=0; i<str.Length; i+=2)
{
    string ss = str[i];

    if(i+1 <str.Length)
        ss += '\n' + str[i+1];

    str1.Add(ss);
}

str = str1.ToArray();

如果在循环内检查了条件，因为 str 的长度可能是奇数

于 2012-04-16T05:58:20.863 回答
0 
var strAray = myLongString.Split('\n').ToList();
var skip=0;
var take=20;

var chunk = strAray.Skip(skip).Take(take).ToList();

While(chunk.Count >0)
{
foreach(var line in chunk)
{
// use line string
}
skip++;
chunk = strAray.Skip(skip).Take(take).ToList()
}
于 2012-04-16T06:05:20.790 回答