You could use the map() feature of the stream to convert each User instance in your list to a UserWithAge instance.

List<User> userList = ... // your list

List<UserWithAge> usersWithAgeList = userList.stream()
        .map(user -> {
                // create UserWithAge instance and copy user name
                UserWithAge userWithAge = new UserWithAge();
                userWithAge.setName(user.getName());
                userWithAge.setAge(27);
                return userWithAge;
         })
         .collect(Collectors.toList()); // return the UserWithAge's as a list

You can use anyMatch to find the first element matching one of your conditions and terminate. Use side effects for calling the processing methods :

boolean found =
  names.stream()
       .anyMatch (name -> {
                  if (name.equals(a)) {
                    doSomething();
                    return true;
                  } else if (name.equals(b)) {
                    doSomethingElse ();
                    return true;
                  } else if (name.equals(c)) {
                    doSomethingElseElse ();
                    return true;
                  } else {
                    return false;
                  }
                }
              );

Pretty ugly, but does what you asked in a single iteration.

Got it folks, it was easy one. I was not looking at the API closely. One of the solution is

multiList .stream().forEach((x) -> x.stream().forEach(System.out::println));

public static void main(String... args) {
    List<String> list1 = Arrays.asList("Hello", "World!");
    List<String> list2 = Arrays.asList("Hi", "there");
    List<String> list3 = Arrays.asList("Help Me");

    List<String> list4 = concat(list1, list2, list3); //you can add as many lists as you like here
    System.out.println(list4);
}

private static List<String> concat(List<String>... lists) {
    return Stream.of(lists)
            .flatMap(List::stream)
            .collect(Collectors.toList());
}

Output

[Hello, World!, Hi, there, Help Me]

boolean noMatch = allNumList.stream()
    .flatMapToInt(Arrays::stream)
    .noneMatch(i -> i == numb);

Use flatMap to combine all the players’ positions into a single Stream:

public boolean testAllPositionsAreCovered(Team team,
                                          String[] positions) {

    Set<String> positionsOfTeams = team.getPlayers().stream()
        .flatMap(p -> p.getPositions().stream())
        .map(Position::getPosition)
        .collect(Collectors.toSet());
    return positionsOfTeams.containsAll(Arrays.asList(positions));
}

Instead of using a forEach just use streams from the beginning:

List<PersonWrapper> wrapperList = jrList.stream()
    .flatMap(jr -> seniorList.stream()
         .filter(sr -> jr.getName().equals(sr.getName()))
         .map(sr -> new PersonWrapper(jr, sr))
    )
    .collect(Collectors.toList());

By using flatMap you can flatten a stream of streams (Stream<Stream<PersonWrapper>>) into a single stream (Stream<PersonWrapper>)

If you can't instantiate wrapperList by yourself or really need to append to it. You can alter above snippet to following:

List<PersonWrapper> wrapperList = new ArrayList<>();

jrList.stream()
    .flatMap(jr -> seniorList.stream()
         .filter(sr -> jr.getName().equals(sr.getName()))
         .map(sr -> new PersonWrapper(jr, sr))
    )
    .forEach(wrapperList::add);

There are multiple ways you could change your snippet here to use Java-8 Streams. Here an overview of a few straight out of my head.

List<IDWrapper> list = IntStream.range( 0, 20 ).mapToObj( IDWrapper::new ).collect( Collectors.toList() );
    List<String> details = list.stream().map( IDWrapper::getId ).map( this::getDetails ).collect( Collectors.toList() );
    List<String> details2 = list.stream().map( item -> item.getId() ).map( id -> getDetails( id ) ).collect( Collectors.toList() );
    List<String> details3 = list.stream().map( item -> getDetails( item.getId() ) ).collect( Collectors.toList() );

Let's break them down and explain their differences a bite more.

1.

List<String> details = list.stream().map( IDWrapper::getId ).map( this::getDetails ).collect( Collectors.toList() );

This one uses MethodReferences to pass the desired functions down the Stream#map(Function) method. It can be read as 'map the items, which are IDWrapper-Objects and do it by calling IDWrapper#getId() on every object and put the resulting items (integer values in this case) back into the stream'. Afterwards another call to Stream#map(Function) is done but this time the object to operate on is 'this' (my dummy class i created for the example) and call the #getDetails(int) method on this class.

2.

List<String> details2 = list.stream().map( item -> item.getId() ).map( id -> getDetails( id ) ).collect( Collectors.toList() );

This one is quite simply equal to 1. but using usual lambda expression to achieve the same.

3.

List<String> details3 = list.stream().map( item -> getDetails( item.getId() ) ).collect( Collectors.toList() );

In this case we're defining the function as a lamda and simply chaining the method class.

As mentioned before there are lots of other possibilities, but here are an education few. Hope I could help you understanding streams a little bit better.

If you don't mind modifying the instances in the list directly, you can use forEach combined with replaceAll (I assumed I could access the accountNumberName for simplicity but you can easily change it also via a setter).

list.forEach(d -> d.accountNumberName.replaceAll(acc -> acc + " - " + accountNumberNameMap.getOrDefault(acc, "")));

If you don't want to modify the existing instances, it can be done this way (assuming a copy constructor exists):

list.replaceAll(d -> new DataA(d.name, d.email, d.accountNumberName.stream().map(name -> name + " - " + accountNumberNameMap.getOrDefault(name, "")).collect(toList())));

(and then if you don't want to modify the original list, just stream/collect over it instead of using replaceAll)