Java，嵌套循环，提高性能

我需要根据图片填写迭代列表（任务）

要执行任务，从

hi

到

lo

，差异生成操作阶乘顺序

n

现在，我像图片一样划分任务。优化是非常重要的

例如：
（80-43）=37->37！包含多项式和数学变换列表的复杂运算集。


现在，有没有另一种算法来生成类似于图片的列表
 只是滑动它

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SlidingTest {

    /* public static final class Sliding<T> extends AbstractList<List<T>> {

        private final List<T> list;
        private final int chunkSize;
        private final int overlap;

        public Sliding(List<T> list, int chunkSize, int overlap) {
            this.list = new ArrayList<>(list);
            this.chunkSize = chunkSize;
            this.overlap = overlap;
        }

        @Override
        public List<T> get(int index) {         
            int start = index * (chunkSize - overlap);
            int end = Math.min(start + chunkSize, list.size());

            if (start > end) {
                throw new IndexOutOfBoundsException("Index " + index + " is out of the list range <0," + (size() - 1) + ">");
            }

            return list.subList(start, end);
        }

        @Override
        public int size() {
            return (int) Math.ceil((double) (list.size() + chunkSize * (chunkSize - overlap)) / (double) chunkSize);
        }
    } */

    public static void main(String[] args) {
        try {
            int hi = 80;
            int lo = 43;
            int expanse = 12;
            int overlap = 8;
            int remmant = expanse - overlap;
            int iterations = (int) Math.ceil((hi - lo - expanse) / (double) remmant) + 1;
            /* List<Integer> numbers = IntStream.rangeClosed(lo, hi).boxed().map(j -> lo + (hi - j)).collect(Collectors.toList());
            Sliding<Integer> listFinishedTask = new Sliding<Integer>(numbers, expanse, overlap); */

            List<List<Integer>> listFinishedTask = IntStream.range(0, iterations).parallel().mapToObj(i -> {
                int start = Math.max(hi - i * (remmant) - expanse + 1, lo);
                int end = hi - i * (remmant);
                return IntStream.rangeClosed(start, end).boxed()
                    .map(j -> start + (end - j))
                    .collect(Collectors.toList());
            }).collect(Collectors.toList());

            listFinishedTask.forEach(System.out::println);  
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }

}

import java.util.AbstractList；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
公共类幻灯片测试{
/*公共静态最终类扩展了抽象列表{
私人最终名单；
私有最终整数块大小；
私有最终整数重叠；
公共滑动（列表、整块大小、整块重叠）{
this.list=新的ArrayList（列表）；
this.chunkSize=chunkSize；
这个重叠=重叠；
}
@凌驾
公共列表获取（int索引）{
int start=索引*（chunkSize-重叠）；
int end=Math.min（start+chunkSize，list.size（））；
如果（开始>结束）{
抛出新IndexOutOfBoundsException（“索引”+索引+”超出列表范围”）；
}
返回列表。子列表（开始、结束）；
}
@凌驾
公共整数大小（）{
return（int）Math.ceil（（double）（list.size（）+chunkSize*（chunkSize-overlap））/（double）chunkSize）；
}
} */
公共静态void main（字符串[]args）{
试一试{
inthi=80；
int-lo=43；
int-expanse=12；
int重叠=8；
int remmant=扩展-重叠；
int迭代=（int）Math.ceil（（hi-lo-expanse）/（double）remmant）+1；
/*List number=IntStream.rangeClosed（lo，hi）.boxed（）.map（j->lo+（hi-j））.collect（Collectors.toList（））；
滑动列表FinishedTask=新滑动（数字、范围、重叠）*/
List listFinishedTask=IntStream.range（0，迭代次数）.parallel（）.mapToObj（i->{
int start=Math.max（hi-i*（remmant）-expanse+1，lo）；
int end=hi-i*（remmant）；
return IntStream.rangeClosed（start，end）.boxed（）
.map（j->start+（end-j））
.collect（Collectors.toList（））；
}).collect（Collectors.toList（））；
listFinishedTask.forEach（System.out:：println）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
}
只需滑动它

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SlidingTest {

    /* public static final class Sliding<T> extends AbstractList<List<T>> {

        private final List<T> list;
        private final int chunkSize;
        private final int overlap;

        public Sliding(List<T> list, int chunkSize, int overlap) {
            this.list = new ArrayList<>(list);
            this.chunkSize = chunkSize;
            this.overlap = overlap;
        }

        @Override
        public List<T> get(int index) {         
            int start = index * (chunkSize - overlap);
            int end = Math.min(start + chunkSize, list.size());

            if (start > end) {
                throw new IndexOutOfBoundsException("Index " + index + " is out of the list range <0," + (size() - 1) + ">");
            }

            return list.subList(start, end);
        }

        @Override
        public int size() {
            return (int) Math.ceil((double) (list.size() + chunkSize * (chunkSize - overlap)) / (double) chunkSize);
        }
    } */

    public static void main(String[] args) {
        try {
            int hi = 80;
            int lo = 43;
            int expanse = 12;
            int overlap = 8;
            int remmant = expanse - overlap;
            int iterations = (int) Math.ceil((hi - lo - expanse) / (double) remmant) + 1;
            /* List<Integer> numbers = IntStream.rangeClosed(lo, hi).boxed().map(j -> lo + (hi - j)).collect(Collectors.toList());
            Sliding<Integer> listFinishedTask = new Sliding<Integer>(numbers, expanse, overlap); */

            List<List<Integer>> listFinishedTask = IntStream.range(0, iterations).parallel().mapToObj(i -> {
                int start = Math.max(hi - i * (remmant) - expanse + 1, lo);
                int end = hi - i * (remmant);
                return IntStream.rangeClosed(start, end).boxed()
                    .map(j -> start + (end - j))
                    .collect(Collectors.toList());
            }).collect(Collectors.toList());

            listFinishedTask.forEach(System.out::println);  
        } catch(Exception ex) {
            ex.printStackTrace();
        }
    }

}

import java.util.AbstractList；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
公共类幻灯片测试{
/*公共静态最终类扩展了抽象列表{
私人最终名单；
私有最终整数块大小；
私有最终整数重叠；
公共滑动（列表、整块大小、整块重叠）{
this.list=新的ArrayList（列表）；
this.chunkSize=chunkSize；
这个重叠=重叠；
}
@凌驾
公共列表获取（int索引）{
int start=索引*（chunkSize-重叠）；
int end=Math.min（start+chunkSize，list.size（））；
如果（开始>结束）{
抛出新IndexOutOfBoundsException（“索引”+索引+”超出列表范围”）；
}
返回列表。子列表（开始、结束）；
}
@凌驾
公共整数大小（）{
return（int）Math.ceil（（double）（list.size（）+chunkSize*（chunkSize-overlap））/（double）chunkSize）；
}
} */
公共静态void main（字符串[]args）{
试一试{
inthi=80；
int-lo=43；
int-expanse=12；
int重叠=8；
int remmant=扩展-重叠；
int迭代=（int）Math.ceil（（hi-lo-expanse）/（double）remmant）+1；
/*List number=IntStream.rangeClosed（lo，hi）.boxed（）.map（j->lo+（hi-j））.collect（Collectors.toList（））；
滑动列表FinishedTask=新滑动（数字、范围、重叠）*/
List listFinishedTask=IntStream.range（0，迭代次数）.parallel（）.mapToObj（i->{
int start=Math.max（hi-i*（remmant）-expanse+1，lo）；
int end=hi-i*（remmant）；
return IntStream.rangeClosed（start，end）.boxed（）
.map（j->start+（end-j））
.collect（Collectors.toList（））；
}).collect（Collectors.toList（））；
listFinishedTask.forEach（System.out:：println）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
}
使用
列表.子列表如何？这将避免大量不必要的复制：

// Create an ArrayList [80, 79, 78, ... , 44, 43]
List<Integer> list = new ArrayList<>();
for (int i = hi; i >= lo; i--) {
    list.add(i);
}

// Create an ArrayList of sublists
List<List<Integer>> subLists = new ArrayList<>();
for (int i = 0; i < list.size(); i += remmant) {
    subLists.add(list.subList(i, Math.min(list.size(), i + expanse)));
}

// Print each sublist
subLists.forEach(System.out::println);

使用
List.subList
怎么样？这将避免大量不必要的复制：

// Create an ArrayList [80, 79, 78, ... , 44, 43]
List<Integer> list = new ArrayList<>();
for (int i = hi; i >= lo; i--) {
    list.add(i);
}

// Create an ArrayList of sublists
List<List<Integer>> subLists = new ArrayList<>();
for (int i = 0; i < list.size(); i += remmant) {
    subLists.add(list.subList(i, Math.min(list.size(), i + expanse)));
}

// Print each sublist
subLists.forEach(System.out::println);

我认为称之为滑动窗口比分区更好。我认为称之为滑动窗口比分区更好。这可能与问题无关，但您甚至需要生成列表吗？你可以计算一下。迭代
i
位置
p
处的元素类似于
high-i*rements-p
（添加了一些绑定检查）。
列表的目的是什么？如果生成一个阶乘数量的任务（即a），为什么优化N²循环很重要？无需执行新的整数（j）
，只需使用
j
。此外，在
Arrays.toString（listIterations.toArray（））
中没有任何意义，您可以使用
listIterations.toString（）
，甚至更简单<
[80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69]
[76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65]
[72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61]
[68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57]
[64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53]
[60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49]
[56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45]
[52, 51, 50, 49, 48, 47, 46, 45, 44, 43]
[48, 47, 46, 45, 44, 43]
[44, 43]