Seems that this is what you are after:

 customers.stream() 
          .filter(c -> c.getTrack() != null)
          .map(c -> c.getTrack().getId())
          .flatMap(id -> tracks.stream().filter(track -> Long.valueOf(track.getId()).equals(id)))
          .collect(Collectors.toSet());

Just note that for each id you are iterating the entire list of tracks; this has O(n*m) complexity. This is generally see as bad and you can improve it.

To make it better you would first create a HashSet of ids from Customer; having that HashSet you can now call contains on it with the ids you are interested in, since contains has a time complexity of O(1) (it's really called amortized complexity of O(1)). So now your complexity becomes O(n) + O(1), but since O(1) is a constant, it's really O(n) - much better that what you had before. In code:

Set<Long> set = customers.stream()
            .filter(c -> c.getTrack() != null)
            .map(c -> c.getTrack().getId())
            .collect(Collectors.toSet());

Set<CusomerTrack> tracksToSave = tracks.stream()
            .filter(track -> set.contains(track.getId())
            .collect(Collectors.toSet()));

You could do something like:

List<MyObject> list = IntStream.range(0, list1.size())
    .filter(i->list2.get(i))
    .map(i->list1.get(i))
    .collect(Collectors.toList())

It could be better if Java had build-in zip for streams. For example with Guava you can use:

 Streams.zip(list2.stream(), list1.stream(), (a,b) -> a ? b : null)
    .filter(Objects::nonNull)
    .collect(Collectors.toList())

Can we collect two lists from Java 8 streams?

You cannot but if you have a way to group elements of the Lists according to a condition. In this case you could for example use Collectors.groupingBy() that will return Map<Foo, List<Bar>> where the values of the Map are the two List.

Note that in your case you don't need stream to do only filter.

Filter the invalid list with removeIf() and add all element of that in the first list :

invalidList.removeIf(o -> conditionToRemove);
goodList.addAll(invalidList);      

If you don't want to change the state of goodList you can do a shallow copy of that :

invalidList.removeIf(o -> conditionToRemove);
List<Foo> terminalList = new ArrayList<>(goodList);
terminalList.addAll(invalidList);

There are still some things unclear. Like why you are insisting on creating that SimpleDateFormat instance that you are not using anywhere. Or whether there is a significance in calling getCreatedBy() multiple times. Assuming that it is not necessary, the following code is equivalent

baseManager.findObjectsByNamedQuery(Class1.class, "Class1.findAll", new Object[]{})
    .stream()
    .map(item -> item.getCreatedBy())
    .map(createdBy -> Json.createObjectBuilder()
        .add("createdBy", createdBy)
        .add("phone", baseManager.findObjectsByNamedQuery(
            Class2.class, "Class2.findByCreatedBy", new Object[] {createdBy})
            .get(0).getPhone())
    )
    .forEach(jpb -> groupsBuilder.add(jpb));

It’s still unclear to me whether (or why) findObjectsByNamedQuery is not a varargs method. It would be quite natural to be a varargs method, not requiring these explicit new Object[] { … } allocations.

The easiest way is to create an IntStream to generate the indices, and then map each index to the String you want to create.

IntStream.range(0, Math.min(names.size(), ages.size()))
         .mapToObj(i -> names.get(i)+":"+ages.get(i))
         .forEach(System.out::println);

Also you might be interested in this SO question Zipping streams using JDK8 with lambda (java.util.stream.Streams.zip), because this is the kind of functionality you're asking for.

You need to work on both lists in parallel so I don't think you can stream the lists themselves. However you can stream the indices and work on that:

IntStream.range(0, aList.size())
    .parallel()
    .forEach(i -> {
        if (i < bList.size()) aList.get(i).doSomethingWith(bList.get(i));
        else aList.get(i).doSomething();
    });