0

我有一个字符串数组列表，其大小可能会有所不同。

List<String> strList1 = new ArrayList<String>();

对于每个字符串，我调用了一个方法updateDetails(strList1)，该方法对其进行处理并根据某些逻辑打印一个操作。

我想为第一个字符串调用上述方法 updateDetails(strList1)，然后以固定间隔调用 5（包括第一个 1）等，如下所示

间隔为 1、5、10、50、100、200、1000

o/p（如果 strList1 大小为 25）应该类似于：

Result for first 1:
Result for first 5:..
Result for first 10:..
Result for total 25 :

o/p（如果 strList1 大小为 9）应该类似于：

Result for first 1:..
Result for first 5:..
Result for total 9:..

怎么办？

4

4 回答 4

3

You can avoid duplicates with

int len = strList1.size();
NavigableSet<Integer> sizes = new TreeSet<>();
sizes.addAll(Arrays.asList(1, 5, 10, 50, 100, 200, 1000, len));
for(int size: sizes.lower(len+1)) {
    List<String> list2 = strList1.subList(0, size);
    // process list2
}

If duplicates are not a problem.

int len = strList1.size();
for(int size: new int[] { 1, 5, 10, 50, 100, 200, 1000, len }) {
    if(size > len) continue;
    List<String> list2 = strList1.subList(0, size);
    // process list2
}
于 2012-08-09T10:22:02.453 回答
1

我认为 - 稍微猜测一下updateDetails()- 你应该将其签名更改为：

Results updateDetails(Results accumulatedResults, List<String> items);

适当地定义您自己的 Results 类并为其编写一个toString()。updateDetails根据之前的结果和新列表计算结果。例如，如果它应该计算字符串长度的总和：

Results updateDetails(Results accumulatedResults, List<String> items) {
     int sum = accumulatedResults.getSum();
     for(String item : items) {
        sum += item.length();
     }
     return new Results(sum);
}

这意味着您不会重复可能昂贵的计算。

然后你的代码需要重复调​​用它：

Results results = new Results(); // start with an empty one
results = updateDetails(results,strings.subList(0,1));
System.out.println(results);
results = updateDetails(results,strings.subList(1,5));
System.out.println(results);
results = updateDetails(results,strings.subList(5,10));
System.out.println(results);

... 等等。请注意，我认为让函数返回一个可以打印的值要比让函数自己进行打印要好得多。它更可重用，更可测试。

当然，您可以循环执行此操作：

Results results = new Results(); // start with an empty one
int[] sizes = new int[] { 1, 5, 10, 25, 50, 100, 200, 1000 };
int last=0;
for(int i = 0; i<size.length; i++) {
    int size = sizes[i];
    results = updateDetails(results,strings.subList(last,size));
    System.out.println(results);
    last = size;
}

这就是基础。正如所写的那样，对于小于 1000 的输入列表，它将失败。我将把它作为练习留给你：

  • 检查 size > strings.size() + 1
  • 如果是这样，将大小调整为 strings.size() + 1 并使其成为循环的最后一次迭代

（+1 因为 List.subList() 的工作方式）

您还需要考虑超过 1000 的输入列表会发生什么。也许最好有一个sizeForIteration(int iteration)方法来处理 的任意大值iteration，而不是简单的数组查找。

一个更简单的算法是将“报告点”的知识放入您的 updateDetails 逻辑中。

for(int i=0; i<list.size; i++) {
    // do something with list.get(i)
    if( sizes.contains(i) {
        System.out.println(something);
    }
}
System.out.println(something);

我的主要答案虽然更复杂，但我认为更灵活。

于 2012-08-09T10:43:16.053 回答
1

这些方面的东西会满足您的要求吗？

int[] intervals = new int[] {1, 5, 10, 50, ...}
for (int interval : intervals)
{
    for (int i = 0; i < interval && i < strList1.size(); i++)
    {
        // Do stuff.
    }
}
于 2012-08-09T10:22:36.963 回答
0

如果你想处理 0 到 1、2 到 9、9 到 15 等，你可以这样做（这是 c#，但在 Java 中非常相似）

        List<String> strList1 = new List<String>{"alfa","beta","gamma"};
        List<int> intervals= new List<int>{1,5,10,25,30};
        int index = 0, j=0;
        while (index<strList1.Count)
        {
            int from = index, to = index + intervals[j];
            doStuff(strList1, from, to);
            index +=intervals[j];
            j++;
        }
于 2012-08-09T10:27:23.650 回答