Java 优化FOR循环以将数组元素添加到集合

我有一个大小为N的数组

Ar

（

Ar[N]

）。我必须将

Ar[N]

划分为大小为

K

的子数组，然后将它们添加到集合S中。 例如，如果

Ar[5]={1,2,3,4,5}

和

K=3

那么， 子数组将是

{1,2,3}、{2,3,4}、{3,4,5}

现在我必须将这些子数组添加到集合中，并继续我的计算

这是我的密码：

int max = 0;
for(int j=0;j<=N-k;j++){
            Set<Integer> set = new HashSet<>();
            for(int l=j;l<j+K;l++){
                set.add(Ar[l]);
            }
if(set.size >= max) max = set.size;
        }
System.out.println(max);

int max=0；
对于（int j=0；j在遍历数组时，在集合的
i-k-1
到
i
之间保持一个窗口。您可以使用
HashMap
计算值的频率，并在频率为零时将其删除。更新集合的最大值，然后您将获得每个子数组集合的最大集合大小

int[] arr = {1,2,1,4,1};
int k = 3;
int max = 0;
Map<Integer, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();
for (int i = 0; i < arr.length; i++) {
  set.add(arr[i]);
  map.merge(arr[i], 1, Integer::sum);
  if(i >= k) {
    map.merge(arr[i-k], -1, Integer::sum);
    if(map.get(arr[i-k]) == 0) {
      set.remove(arr[i-k]);
    }
  }
  if(set.size() >= max) {
    max = set.size();
  }
}

int[]arr={1,2,1,4,1}；
int k=3；
int max=0；
Map Map=newhashmap（）；
Set=newhashset（）；
对于（int i=0；i=k）{
合并（arr[i-k]，-1，整数：：和）；
if（map.get（arr[i-k]）==0{
设置。移除（arr[i-k]）；
}
}
如果（set.size（）>=max）{
max=set.size（）；
}
}
在遍历数组时，维护集合的
i-k-1
到
i
的窗口。您可以使用
HashMap
计算值的频率，并在频率为零时将其删除。更新集合的最大值，然后您将获得每个子数组集合的最大集合大小

int[] arr = {1,2,1,4,1};
int k = 3;
int max = 0;
Map<Integer, Integer> map = new HashMap<>();
Set<Integer> set = new HashSet<>();
for (int i = 0; i < arr.length; i++) {
  set.add(arr[i]);
  map.merge(arr[i], 1, Integer::sum);
  if(i >= k) {
    map.merge(arr[i-k], -1, Integer::sum);
    if(map.get(arr[i-k]) == 0) {
      set.remove(arr[i-k]);
    }
  }
  if(set.size() >= max) {
    max = set.size();
  }
}

int[]arr={1,2,1,4,1}；
int k=3；
int max=0；
Map Map=newhashmap（）；
Set=newhashset（）；
对于（int i=0；i=k）{
合并（arr[i-k]，-1，整数：：和）；
if（map.get（arr[i-k]）==0{
设置。移除（arr[i-k]）；
}
}
如果（set.size（）>=max）{
max=set.size（）；
}
}
如果实际任务是定义划分为K个元素后子集的最大大小，则可以通过以下方式实现：

public static long findMaxSize(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToLong(i -> 
                        Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                              .distinct().count())
                    .max().getAsLong();
}

public static Set<Set<Integer>> splitIntoSubsetsByK(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToObj(i -> Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                        .boxed().collect(Collectors.toSet()))
                    .collect(Collectors.toCollection(LinkedHashSet::new));
    }

此外，可通过以下方式将输入数组按K个元素拆分为子集：

public static long findMaxSize(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToLong(i -> 
                        Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                              .distinct().count())
                    .max().getAsLong();
}

public static Set<Set<Integer>> splitIntoSubsetsByK(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToObj(i -> Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                        .boxed().collect(Collectors.toSet()))
                    .collect(Collectors.toCollection(LinkedHashSet::new));
    }

公共静态集拆分为subsetsbyk（int[]arr，int k）{
返回IntStream.rangeClosed（0，arr.length-k）
.mapToObj（i->Arrays.stream（Arrays.copyOfRange（arr，i，i+k））
.boxed（）.collect（收集器.toSet（）））
.collect（Collectors.toCollection（LinkedHashSet:：new））；
}

测试和输出：

int[] arr = {1, 2, 2, 2, 1};
int k = 3;

Set<Set<Integer>> result = splitIntoSubsetsByK(arr, k);
result.forEach(System.out::println);

System.out.println(findMaxSize(arr, k));

[1, 2]
[2]
2

int[]arr={1,2,2,2,1}；
int k=3；
设置结果=splitIntoSubsetsByK（arr，k）；
result.forEach（System.out:：println）；
System.out.println（findMaxSize（arr，k））；
[1, 2]
[2]
2.
如果实际任务是定义划分为K个元素后子集的最大大小，则可以通过以下方式实现：

public static long findMaxSize(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToLong(i -> 
                        Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                              .distinct().count())
                    .max().getAsLong();
}

public static Set<Set<Integer>> splitIntoSubsetsByK(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToObj(i -> Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                        .boxed().collect(Collectors.toSet()))
                    .collect(Collectors.toCollection(LinkedHashSet::new));
    }

此外，可通过以下方式将输入数组按K个元素拆分为子集：

public static long findMaxSize(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToLong(i -> 
                        Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                              .distinct().count())
                    .max().getAsLong();
}

public static Set<Set<Integer>> splitIntoSubsetsByK(int[] arr, int k) {
    return IntStream.rangeClosed(0, arr.length - k)
                    .mapToObj(i -> Arrays.stream(Arrays.copyOfRange(arr, i, i + k))
                        .boxed().collect(Collectors.toSet()))
                    .collect(Collectors.toCollection(LinkedHashSet::new));
    }

公共静态集拆分为subsetsbyk（int[]arr，int k）{
返回IntStream.rangeClosed（0，arr.length-k）
.mapToObj（i->Arrays.stream（Arrays.copyOfRange（arr，i，i+k））
.boxed（）.collect（收集器.toSet（）））
.collect（Collectors.toCollection（LinkedHashSet:：new））；
}

测试和输出：

int[] arr = {1, 2, 2, 2, 1};
int k = 3;

Set<Set<Integer>> result = splitIntoSubsetsByK(arr, k);
result.forEach(System.out::println);

System.out.println(findMaxSize(arr, k));

[1, 2]
[2]
2

int[]arr={1,2,2,2,1}；
int k=3；
设置结果=splitIntoSubsetsByK（arr，k）；
result.forEach（System.out:：println）；
System.out.println（findMaxSize（arr，k））；
[1, 2]
[2]
2.
替代解决方案。请尝试使用中所述的“subList（）”：

见下例：

public static void main(String[] args) {
    int startNumber = 1;
    int endNumber = 5;
    List<Integer> mainList = new ArrayList<>();
    for (int i = startNumber; i <= endNumber; i++) {
        mainList.add(i);
    }

    // See mainList:
    System.out.println(mainList); // output: [1, 2, 3, 4, 5]

    int sizeOfEachSubList = 3;
    int loopStopPoint = mainList.size() - sizeOfEachSubList;
    List<List<Integer>> listOfLists = new ArrayList<>();
    for (int i = 0; i <= loopStopPoint; i++) {
        List<Integer> subList = mainList.subList(i, sizeOfEachSubList + i);
        listOfLists.add(subList);
    }

    //See all lists:
    System.out.println(listOfLists); // output: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
}

publicstaticvoidmain（字符串[]args）{
int startNumber=1；
int-endNumber=5；
List mainList=new ArrayList（）；
对于（int i=startNumber；i替代解决方案。请尝试使用中所述的“subList（）”：

见下例：

public static void main(String[] args) {
    int startNumber = 1;
    int endNumber = 5;
    List<Integer> mainList = new ArrayList<>();
    for (int i = startNumber; i <= endNumber; i++) {
        mainList.add(i);
    }

    // See mainList:
    System.out.println(mainList); // output: [1, 2, 3, 4, 5]

    int sizeOfEachSubList = 3;
    int loopStopPoint = mainList.size() - sizeOfEachSubList;
    List<List<Integer>> listOfLists = new ArrayList<>();
    for (int i = 0; i <= loopStopPoint; i++) {
        List<Integer> subList = mainList.subList(i, sizeOfEachSubList + i);
        listOfLists.add(subList);
    }

    //See all lists:
    System.out.println(listOfLists); // output: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
}

publicstaticvoidmain（字符串[]args）{
int startNumber=1；
int-endNumber=5；
List mainList=new ArrayList（）；
对于（int i=startNumber；i），考虑到您所说的问题，实际上没有一种方法可以提高效率。您所做的任何事情最终都需要做O（NK）工作。你能给出完整的问题陈述吗？因为在这个级别上，我同意LouisCan，你可以展示你如何使用子数组集吗？也许可以更改程序，这样就不必完整地构造这个集合Hi@Joni，我计算集合的最大大小。我将它添加到我的代码中。请看一看。但是在我们的代码中，我看到了一组整数不是整数数组的集合。我遗漏了什么？考虑到你所说的问题，实际上没有办法提高效率。你所做的任何事情最终都需要做O（NK）工作。你能给出完整的问题陈述吗？因为在这个级别上，我同意LouisCan，你可以展示你如何使用子数组集吗？也许可以更改程序，这样就不必完整地构造这个集合Hi@Joni，我计算集合的最大大小。我将它添加到我的代码中。请看一看。但是在我们的代码中，我看到了一组整数不是整数数组的集合。我遗漏了什么？你检查了这个解决方案吗？你检查了这个解决方案吗？