If you wanna create new list, use Stream.map method:

List<Fruit> newList = fruits.stream()
    .map(f -> new Fruit(f.getId(), f.getName() + "s", f.getCountry()))
    .collect(Collectors.toList())

If you wanna modify current list, use Collection.forEach:

fruits.forEach(f -> f.setName(f.getName() + "s"))

Use findFirst so after finding the first matching element in the list remaining elements will not be processed

Optional<MyObject> result = list.stream()
                                .filter(obj->obj.getId()==1)
                                .peek(o->o.setName("Yahoo"))
                                .findFirst();

Or

  //will not return anything but will update the first matching object name

                              list.stream()
                              .filter(obj->obj.getId()==1)
                              .findFirst()
                              .ifPresent(o->o.setName("Yahoo"));

Yes, you can modify state of objects inside your stream, but most often you should avoid modifying state of source of stream. From non-interference section of stream package documentation we can read that:

For most data sources, preventing interference means ensuring that the data source is not modified at all during the execution of the stream pipeline. The notable exception to this are streams whose sources are concurrent collections, which are specifically designed to handle concurrent modification. Concurrent stream sources are those whose Spliterator reports the CONCURRENT characteristic.

So this is OK

  List<User> users = getUsers();
  users.stream().forEach(u -> u.setProperty(value));
//                       ^    ^^^^^^^^^^^^^
//                        \__/

but this in most cases is not

  users.stream().forEach(u -> users.remove(u));
//^^^^^                       ^^^^^^^^^^^^
//     \_____________________/

and may throw ConcurrentModificationException or even other unexpected exceptions like NPE:

List<Integer> list = IntStream.range(0, 10).boxed().collect(Collectors.toList());

list.stream()
    .filter(i -> i > 5)
    .forEach(i -> list.remove(i));  //throws NullPointerException

When you create a Stream from the List, you are not allowed to modify the source List from the Stream as specified in the “Non-interference” section of the package documentation. Not obeying this constraint can result in a ConcurrentModificationException or, even worse, a corrupted data structure without getting an exception.

The only solution to directly manipulate the list using a Java Stream, is to create a Stream not iterating over the list itself, i.e. a stream iterating over the indices like

IntStream.range(0, list1.size()).forEach(ix -> list1.set(ix, list1.get(ix)+1));

^{like in Eran’s answer}

But it’s not necessary to use a Stream here. The goal can be achieved as simple as

list1.replaceAll(i -> i + 1);

This is a new List method introduced in Java 8, also allowing to smoothly use a lambda expression. Besides that, there are also the probably well-known Iterable.forEach, the nice Collection.removeIf, and the in-place List.sort method, to name other new Collection operations not involving the Stream API. Also, the Map interface got several new methods worth knowing.

See also “New and Enhanced APIs That Take Advantage of Lambda Expressions and Streams in Java SE 8” from the official documentation.

You should not use Stream APIs to change the state of an Object.

If you still want to modify it then, You can iterate each element from the list of A, filter if dob is null, find dob against the respective name in the list of B.

List<A> aList = new ArrayList<>();
List<B> bList = new ArrayList<>();

aList.stream()
        .filter( a  -> a.dob == null)
        .forEach( a -> {
            Predicate<B> nameFilter = b -> b.name.equals(a.name);
            a.dob = findDob(nameFilter, bList);
        });

static String findDob(Predicate<B> nameFilter, List<B> bList) {
    B b = bList.stream()
            .filter(nameFilter)
            .findFirst()
            .orElse(new B());

    return b.dob;
}

Alternate efficient solution: Considering you have a unique name for each object B, you can prepare lookup and find age using that map, this way you do not need to iterate bList for every iteration of aList

List<A> aList = new ArrayList<>();
List<B> bList = new ArrayList<>();

Map<String, String> nameDobLookup = bList.stream()
                        .collect(Collectors.toMap(b -> b.name, b -> b.dob));

aList.stream()
        .filter(a -> a.dob == null)
        .forEach(a -> a.dob = nameDobLookup.get(a.name));

Feature Envy

The LoanAccountService needs to know all fields from LoanAccount that gets updated:

account.get().setCreationDate(loanAccount.getCreationDate());
account.get().setLoanAmount(loanAccount.getLoanAmount());
account.get().setNumberOfInstallments(loanAccount.getNumberOfInstallments());
account.get().setType(loanAccount.getType());

Now imagine LoanAccount would get a few more fields and they are updateable too but you forgot to change LoanAccountService.. This means LoanAccountService depends on LoanAccount..

A solution would be to add a new method to LoanAccount:

public LoanAccount updateBy(LoanAccount other) {
  this.creationDate = other.creationDate();
  this.loanAmount = other.loanAmount();
  this.numberOfInstallments = other.numberOfInstallments();
  this.type = other.type();
  return this;
}

Optional#map

The if-statement

if (account.isPresent()) {

can be replaced by the method map on Optional. With adding the new updateBy method:

public LoanAccount updateBy(LoanAccount other) {
  bank.getLoanAccounts()
      .stream()
      .filter(la -> la.getId().equals(other.getId()))
      .findAny()
      .map(loanAccount -> loanAccount.updateBy(other))
      .orElseThrow(() -> new IllegalArgumentException("The object does not exist."));
  return other;
}

Further Improvement

A second Feature Envy is in the following snipped:

bank.getLoanAccounts()
   .stream()
   .filter(la -> la.getId().equals(loanAccount.getId()))

Not the LoanAccountService should filter the data but the Bank itself should filter it:

// in Bank.java

public Optinal<List<LoanAccount> findBy(int id) {
   return loanAccounts.stream()
                      .filter(la -> la.getId().equals(id))
                      .collect(Collectors.toList())
}

All together

// LoanAccountService.java

public LoanAccount updateBy(LoanAccount other) {
  bank.findBy(other.getId())
      .findAny()
      .map(loanAccount -> loanAccount.updateBy(other))
      .orElseThrow(() -> new IllegalArgumentException("The object does not exist."));
  return other;
}

I'd first create a mapping from TimeDiscount::getIdOfBook to TimeDiscount:

Map<Long, TimeDiscount> accumulator = 
      actualPromotions.stream()
                     .collect(toMap(TimeDiscount::getIdOfBook, Function.identity()));

Then I'd do:

booksToReturn.forEach(e -> {
       TimeDiscount timeDiscount = accumulator.get(e.getIdOfBook());
       if (timeDiscount != null) e.setDiscountRate(e.getDiscountRate() + timeDiscount.getDiscountRate());
});

or if you want to stay with the use of Optional for some reason.

booksToReturn.forEach(e -> 
       Optional.ofNullable(accumulator.get(e.getIdOfBook()))
          .ifPresent(p -> e.setDiscountRate(e.getDiscountRate() + p.getDiscountRate()))
);

This improves upon the inefficient lookup in actualPromotions.stream() for each element of booksToReturn.

If the currentList is always a subset of the updatedList - means that all the currentList will appear in the updatedList, you can do the following:

Set<String> setOfId = currentList.stream()
                                 .map(person -> person.getId()) // exctract the IDs only
                                 .collect(Collectors.toSet());  // to Set, since they are unique

List<Person> newList = updatedList.stream()                     // filter out those who don't match
                                  .filter(person -> setOfId.contains(person.getId()))  
                                  .collect(Collectors.toList());

If the updatedList and currentList differ significantly - both can have unique persons, you have to do the double iteration and use Stream::map to replace the Person. If not found, replace with self:

List<Person> newList = currentList.stream()
    .map(person -> updatedList.stream()                                       // map Person to
                              .filter(i -> i.getId().equals(person.getId()))  // .. the found Id
                              .findFirst().orElse(person))                    // .. or else to self
    .collect(Collectors.toList());                                            // result to List

It's simple actually. You can do something like this:

list.stream()
                .filter(d-> d.getAvailableTodayInPerson() == true && d.getDistance() > dis)
                .foreach(d -> {
                    d.setAvailableTodayInPerson(false);
                    d.setAvailableTodayOutPerson(true);
                });

You must have some method/constructor that generates a copy of an existing SampleDTO instance, such as a copy constructor.

Then you can map each original SampleDTO instance to a new SampleDTO instance, and collect them into a new List :

List<SampleDTO> output = 
    list.stream()
        .map(s-> {
                     SampleDTO n = new SampleDTO(s); // create new instance
                     n.setText(n.getText()+"xxx"); // mutate its state
                     return n; // return mutated instance
                 })
       .collect(Collectors.toList());

1. Use Builder for getter and setter

   public class LoanAccount {
       private String id;
       private Integer numberOfInstallments;
   
   // add other properties
   
   public String getId() {
       return id;
   }
   
   public LoanAccount setId(String id) {
       this.id = id;
       return this;
   }
   
   public Integer getNumberOfInstallments() {
       return numberOfInstallments;
   }
   
   public LoanAccount setNumberOfInstallments(Integer numberOfInstallments) {
       this.numberOfInstallments = numberOfInstallments;
       return this;
   }
   

2. Use this one for update method

   public LoanAccount update(LoanAccount loanAccount) {
       return bank.getLoanAccounts()
               .stream()
               .filter(la -> la.getId().equals(loanAccount.getId()))
               .findFirst().orElseThrow(IllegalArgumentException::new)
               .setCreationDate(loanAccount.getCreationDate())
               .setLoanAmount(loanAccount.getLoanAmount())
               .setNumberOfInstallments(loanAccount.getNumberOfInstallments())
               .setType(loanAccount.getType());
   }