How is opWrapSink() method called?

The implemenation of map() method in java looks like this:

`public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
            return new Sink.ChainedReference<P_OUT, R>(sink) {
                @Override
                public void accept(P_OUT u) {
                    downstream.accept(mapper.apply(u));
                }
            };
        }
    };
}`

The method returns a new StatelessOp object which is basically a new stream (extends ReferencePipeline and implements Stream). We have an overrriden opWrapSink() method that returns a new Sink.ChainedReference object. And insdide accept method we finally use mapper object that is responsible for invoking logic we pass in the parameter.

What I dont get is at what point and how opWrapSink() method is called. Cause map() just returns a new object, thats it. Does JVM call the method in the background. What am I missing here?

A stream object is a pipeline concept. It's a description of a series of operations to perform.

Imagine the piping that brings water to your faucet.

I could install a filter in your pipes. I could also install a heater element in one of the pipe segments.

None of that is going to have any effect whatsoever until I turn on the faucet - until then I've just installed things that will perform operations once water starts flowing, but they do not themselves cause water to flow.

Streams are the same way. For example, try this:

var example = new ArrayList<String>();
example.add("Hello");
example.add("World!");
example.stream().map(x -> { System.out.println(x); return x; });

and run it. "Weirdly", this prints nothing - clearly that map operation seems to do nothing! But that's because it's like that filter in your faucet pipe: That filter isn't going to do anything until you turn on the faucet, and nobody turned on that faucet yet. You need to actually ask a stream to provide data, and once you do so, that stream will provide them, and presumably, it will do so via reading from the origin stream (here, what the example ArrayList made), through the map operation. Thus, this:

example.stream().map(x -> { System.out.println(x); return x; }).max(Comparator.naturalOrder());

WOULD in fact print Hello and World, because the max() method of streams turns on the faucet. These are generally called the 'terminal' operations, and you recognize them, generally, by the fact that they do not themselves return a stream, but return something else. collect, .max, forEach (that's usually not what you want), findFirst, etc - those are terminal operations.

A stream encapsulates both the source of the data as well as any intermediate operations you want done on that data (filtering, mapping, flatmapping, etcetera). It does not as a rule encapsulate the data itself (i.e. a stream holds a reference to a list, it doesn't hold a reference to all the data inside it, for example - note that streams are abstract, how they actually give you that data is up to the implementation. I'm just telling you about the usual way it goes). It represents the piping in your house. It does not represent either the water company, or the faucet, or the person opening it.

NB: If you actually want to do a side-show inspection job such as print every element as it is streamed along, you'd use peek - I'm abusing the .map() call here merely to show you how it works.