The groupingBy operation (or something similar) is unavoidable, the Map created by the operation is also used during the operation for looking up the grouping keys and finding the duplicates. But you can combine it with the reduction of the group elements:

Map<String, Friend> uniqueFriendMap = friends.stream()
    .collect(Collectors.groupingBy(Friend::uniqueFunction,
        Collectors.collectingAndThen(
            Collectors.reducing((a,b) -> friendMergeFunction(a,b)), Optional::get)));

The values of the map are already the resulting distinct friends. If you really need a List, you can create it with a plain Collection operation:

List<Friend> mergedFriends = new ArrayList<>(uniqueFriendMap.values());

If this second operation still annoys you, you can hide it within the collect operation:

List<Friend> mergedFriends = friends.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.groupingBy(Friend::uniqueFunction, Collectors.collectingAndThen(
            Collectors.reducing((a,b) -> friendMergeFunction(a,b)), Optional::get)),
        m -> new ArrayList<>(m.values())));

Since the nested collector represents a Reduction (see also this answer), we can use toMap instead:

List<Friend> mergedFriends = friends.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.toMap(Friend::uniqueFunction, Function.identity(),
            (a,b) -> friendMergeFunction(a,b)),
        m -> new ArrayList<>(m.values())));

Depending on whether friendMergeFunction is a static method or instance method, you may replace (a,b) -> friendMergeFunction(a,b) with DeclaringClass::friendMergeFunction or this::friendMergeFunction.

But note that even within your original approach, several simplifications are possible. When you only process the values of a Map, you don’t need to use the entrySet(), which requires you to call getValue() on each entry. You can process the values() in the first place. Then, you don’t need the verbose input -> { return expression; } syntax, as input -> expression is sufficient. Since the groups of the preceding grouping operation can not be empty, the filter step is obsolete. So your original approach would look like:

Map<String, List<Friend>> uniqueFriendMap
    = friends.stream().collect(Collectors.groupingBy(Friend::uniqueFunction));
List<Friend> mergedFriends = uniqueFriendMap.values().stream()
    .map(group -> group.stream().reduce((a,b) -> friendMergeFunction(a,b)).get())
    .collect(Collectors.toList());

which is not so bad. As said, the fused operation doesn’t skip the Map creation as that’s unavoidable. It only skips the creations of the Lists representing each group, as it will reduce them to a single Friend in-place.

If you are OK returning a Collection it would look like this:

Collection<Invoice>  invoices = list.collect(Collectors.toMap(Invoice::getMonth, Function.identity(), (left, right) -> {
                left.setAmount(left.getAmount().add(right.getAmount()));
                return left;
            })).values();

If you really need a List:

 list.stream().collect(Collectors.collectingAndThen(Collectors.toMap(Invoice::getMonth, Function.identity(), (left, right) -> {
                left.setAmount(left.getAmount().add(right.getAmount()));
                return left;
            }), m -> new ArrayList<>(m.values())));

Both obviously assume that Invoice is mutable...

To determine the result you're after, it is necessary to group by the id and hold a temporary map of the grouping operation.

You can make it a bit simpler, and not have a second Stream pipeline, by using the collectingAndThen built-in collector, which gives the ability to pass a finisher operation to the result of another collector.

Collection<Foo> result = 
    matchedFoos.stream()
               .collect(groupingBy(Foo::getId, collectingAndThen(toList(), this::mergeFoos)))
               .values();

This code still collects all the foos having the same id into a list, but the use of collectingAndThen enables us to directly pass that list to mergeFoos and return the wanted Foo. Then, it is possible to retrieve the values by invoking values().

This will return a Collection<Foo> as values() is defined to return that. If you really want a List, you can convert it easily to an ArrayList for example, with:

List<Foo> mergedAndMatchedFoos = new ArrayList<>(result);

Note that the current code stores every foo having the same id in a list. This is a bit inefficient since, for the end result, we're interested in a single Foo where the inputs are all input of the foos in the list. So, instead, we can use the toMap(keyMapper, valueMapper, mergeFunction) collector and directly build the intermediate Map<String, Foo> instead a Map<String, List<Foo>>.

The key mapper returns the id of the foo; the value mapper returns a new Foo from a given one, and the merge function adds all inputs from one foo to the other.

Map<String, Foo> result =
    matchedFoos.stream()
       .collect(Collectors.toMap(
          Foo::getId,
          Foo::new,
          (foo1, foo2) -> { foo1.getInputs().addAll(foo2.getInputs()); return foo1; }
       ));

List<Foo> mergedAndMatchedFoos = new ArrayList<>(result.values());

This assumes that we have a copy-constructor Foo(Foo foo) constructing a Foo from another Foo (which is what the Foo::new method-reference refers to). The mutation of foo1 inside the merge function is safe to do since we're working on the new instance, constructed with the copy constructor.

Assuming class A has a copy constructor that effectively copies the List<B> list attribute and a method that merges two instances of A:

public A(A another) {
    this.id = another.id;
    this.name = another.name;
    this.list = new ArrayList<>(another.list);
}

public A merge(A another) {
    list.addAll(another.list):
    return this;
}

You could achieve what you want as follows:

Map<Integer, A> result = listOfA.stream()
    .collect(Collectors.toMap(A::getId, A::new, A::merge));

Collection<A> result = map.values();

This uses Collectors.toMap, which expects a function that extracts the key of the map from the elements of the stream (here this would be A::getId, which extracts the id of A), a function that transforms each element of the stream to the values of the map (here it would be A::new, which references the copy constructor) and a merge function that combines two values of the map that have the same key (here this would be A::merge, which is only called when the map already contains an entry for the same key).

If you need a List<A> instead of a Collection<A>, simply do:

List<A> result = new ArrayList<>(map.values());

@Jigar Joshi has answered the first part of your question which is "how to merge two IntStream's into one".

Your other question of "how to merge two Stream<T> without overwriting the equals() and hashCode() method?" can be done using the toMap collector, i.e. assuming you don't want the result as a Stream<T>. Example:

Stream.concat(stream1, stream2)
      .collect(Collectors.toMap(Student::getNo, 
               Function.identity(), 
               (l, r) -> l, 
               LinkedHashMap::new)
      ).values();

if you want the result as a Stream<T> then one could do:

 Stream.concat(stream1, stream2)
       .collect(Collectors.collectingAndThen(
               Collectors.toMap(Student::getNo,
                    Function.identity(),
                    (l, r) -> l,
                    LinkedHashMap::new), 
                    f -> f.values().stream()));

This is possibly not as efficient as it can be but it's another way to return a Stream<T> where the T items are all distinct but without using overriding equals and hashcode as you've mentioned.

Finite sequence

Supposed you want to create a finite sequence of characters containing Y or R, randomly, just create some next() method and call it repeatedly:

public final class SequenceGenerator {
    private final String[] elements;
    private final Random rnd;

    public SequenceGenerator(Collection<String> elements) {
        this.elements = elements.toArray(new String[elements.size()]);
        rnd = new Random();
    }

    public String next() {
        return elements[rnd.nextInt(elements.length)];
    }

    public String generate(int amountOfElements) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < amountOfElements; i++) {
            sb.append(next());
        }
        return sb.toString();
    }
}

The class takes the collection of possible elements to draw from and its next methods chooses one randomly. The generate method calls it repeatedly and appends the drawn elements.

Usage is simple:

SequenceGenerator gen = new SequenceGenerator(List.of("Y", "R"));
System.out.println(gen.generate(11));

May print something like:

YYRYYRYYRYY

Endless stream

You can also nicely use the Stream API here to create an endless stream:

SequenceGenerator gen = new SequenceGenerator(List.of("Y", "R"));
Stream<String> sequence = Stream.generate(gen::next);

Edit: YY and R

As you said you want the stream to start and end with YY, as well as have a R at every third position, we need to modify next() a bit. First of all we add a field int amount to keep track of calls. Then next() is modified to account for YY at the start and R. Likewise generate must be modified to account for YY at the end. The Stream-variant can remain unchanged since it uses the modified next() and doesn't need to account for YY at the end since it is endless.

public final class SequenceGenerator {
    // ...
    private int amount;

    public SequenceGenerator(Collection<String> elements) {
        // ...
        amount = 0;
    }

    public String next() {
        // Start must be 'YY'
        if (amount == 0 || amount == 1) {
            amount++;
            return "Y";
        }

        // Every third must be 'R'
        if (amount % 3 == 0) {
            amount++;
            return "R";
        }

        // Pick a random element
        amount++;
        return elements[rnd.nextInt(elements.length)];
    }

    public String generate(int amountOfElements) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < amountOfElements - 2; i++) {
            sb.append(next());
        }

        // End must be 'YY'
        sb.append("YY");

        return sb.toString();
    }
}

Actually there is another requirement we need to account for. The concatenation of YY at the end must be valid in regards to the rule that forces a R at each third position. So for generate the amountOfElements must be two bigger than a value which is dividable by 3, else the resulting value is invalid.

And we need to account for edge cases, amountOfElements must be at least 5, every smaller sequence is not valid. YYRYY is the first valid sequence. The modified method:

public String generate(int amountOfElements) {
    if (amountOfElements < 5 || (amountOfElements - 2) % 3 != 0) {
        throw new IllegalArgumentException("Invalid sequence length");
    }
    // ...
}

If they don't follow the same order, you'll need to create an ID map first:

Map<Integer, User> usersById = users.stream()
        .collect(Collectors.toMap(User::getUserId, u -> u));

Now you can stream the other list and map each element to its matching User by ID:

List<UserCompanyView> views = userCompanies.stream()
        .map(uc -> new UserCompanyView(usersById.get(uc.getUserId()), uc))
        .collect(Collectors.toList())

If there are UserCompanys without matching Users, you can filter them out by adding this before map():

.filter(uc -> usersById.containsKey(uc.getUserId()))