Question

我有一个字符串的ArrayList，其大小可能会有所不同。

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:..

如何去做？

Answer 1

您可以使用

避免重复

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
}

如果重复不是问题。

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
}

Answer 2

这些方面的某些内容是否符合您的要求？

int[] intervals = new int[] {1, 5, 10, 50, ...}
for (int interval : intervals)
{
    for (int i = 0; i < interval && i < strList1.size(); i++)
    {
        // Do stuff.
    }
}

Answer 3

我认为 - 对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的输入列表，它将失败。我将把它作为练习留给你：

检查尺寸＆gt; strings.size（）+ 1
如果是这样，调整size.size（）+ 1的大小并使其成为循环的最后一次迭代

（由于List.subList（）如何工作，因此+ 1）

您还需要考虑长于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);

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

Answer 4

如果你想处理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++;
        }

按间隔处理Arraylist

4 个答案: