Here is my code, it will work for you.

Function Reference version

public class AppLauncher {

public static void main(String a[]){
    Map<Integer,Integer> map = IntStream.range(1,10)
        .boxed().collect(Collectors.toMap(
             Function.identity(),
             AppLauncher::computeSmth
        ));
    System.out.println(map);
}
  public static Integer computeSmth(Integer i){
    return i*i;
  }
}

Lambda expression version

public class AppLauncher {

    public static void main(String a[]){
        Map<Integer,Integer> map = IntStream.range(1,10)
            .boxed().collect(Collectors.toMap(
                Function.identity(),
                i->i*i
            ));
        System.out.println(map);
    }
}

Not very certain about how intelliJ's suggestion would work there, it seems inconsistent. Just put a

System.out.print(map);

statement between the declaration and loop and then it won't suggest you Replace with collect any further.

While using the IntStream#collect, the compilation fails for the reason that implementation of collect method expects three specified arguments as visible in the error as well while the

Collectors.toMap(i -> "X" + i, i -> values[i])

would result in only a single argument of type Collector.

Better way to convert the expression would be though to

• either use forEach

  Map<String, Object> map;
  IntStream.range(0, values.length).forEach(i -> map.put("X" + i, values[i]));
  

• Or use boxed() to convert the IntStream to Stream<Integer> as:-

  Map<String, Object> map = IntStream.range(0, values.length).boxed()
             .collect(Collectors.toMap(i -> "X" + i, i -> values[i], (a, b) -> b));
  

• Or as suggested by @Holger, you can avoid using forEach and boxing overhead and modify the construct to make use of the IntStream.collect three-arg variant as:-

  Map<String, Object> map = IntStream.range(0, values.length)
             .collect(HashMap::new, (m,i) -> m.put("X"+i,values[i]), Map::putAll);
  

IntStream::boxed

IntStream::boxed turns an IntStream into a Stream<Integer>, which you can then collect into a List:

theIntStream.boxed().collect(Collectors.toList())

The boxed method converts the int primitive values of an IntStream into a stream of Integer objects. The word "boxing" names the int ⬌ Integer conversion process. See Oracle Tutorial.

Java 16 and later

Java 16 brought the shorter toList method. Produces an unmodifiable list. Discussed here.

theIntStream.boxed().toList() 

IntStream only has one collect method, which takes 3 parameters. I suspect you are looking for the 1-parameter overload in Stream.

Understand that IntStream produces a stream of primitive int numbers, not Integer objects.

Calling .boxed() invokes auto-boxing (see tutorial) to wrap each primitive int as an Integer object. This makes a Stream<Integer> rather than IntStream.

Map < Integer, UUID > map =
    ThreadLocalRandom
            .current()
            .ints( initialCapacity )
            .boxed()                                // Add this call
            .collect(
                    Collectors.toMap(
                            Function.identity() ,
                            x -> UUID.randomUUID()
                    )
            );