Optimize FOR loop for adding array elements to set

I have an array Ar of size N(Ar[N]). I have to divide the Ar[N] into sub arrays of size K and then add them to a Set S.
For example if Ar[5] = {1,2,3,4,5} and K = 3
then,
Sub arrays will be {1,2,3},{2,3,4},{3,4,5}
Now I have to add these sub arrays to the Set and continue my computations.

Here is my code :

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);

Is there any way that I can get rid of the nested for loop as in worst case N can be 1000000.
NOTE : The set should only contain unique values.
Hope I am clear.

Maintain a window of i-k-1 to i of set when traversing the array. You can use HashMap to count the frequency of value and remove it when the frequency is zero. And update max value of set then you will get max set size of each subarray's set.

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();
  }
}

If actual task is to define the maximum size of a subset after dividing into K elements, it can be implemented this way:

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();
}

Also, splitting of the input array by K elements into subsets may be implemented this way:

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));
    }

Test and output:

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

Alternative solution. Try to use "subList()" described in: https://stackoverflow.com/questions/12099721/how-to-use-sublist

See example below:

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]]
}