You can use filter on the streamed list, then simply update the count

public void updateCount(String bookName, int updateBy) {
  books.stream().filter(book -> book.getName().equals(bookName)).forEach(
      book -> book.setCount(book.getCount() + updateBy)
  );
}

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"))

I would use streams for that job.

Assuming your class MyObject has getters and setters methods defined (getKey(), getValue(), setKey(), setValue()), you can do:

l1.forEach(myObject1 -> l2.stream()
            .filter(myObject2 -> myObject1.getKey().equals(myObject2.getKey()))
            .findAny().ifPresent(myObject2 -> myObject1.setValue(myObject2.getValue())));

If you can have duplicate keys then you should modify ifPresent() to forEach():

l1.forEach(myObject1 -> l2.stream()
            .filter(myObject2 -> myObject1.getKey().equals(myObject2.getKey()))
            .forEach(myObject2 -> myObject1.setValue(myObject2.getValue())));

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.

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;
}

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 should not assume the list returned by Collectors.toList() to be mutable. Hence, you must not call sort on it. In your specific case, you can just sort before collecting:

List<Item> items = Stream.of("z", "y", "x")
  .map(Item::new)
  .sorted(Comparator.comparing(o -> o.name))
  .collect(Collectors.toList());

or, since name is identical to the incoming string:

List<Item> items = Stream.of("z", "y", "x")
  .sorted()
  .map(Item::new)
  .collect(Collectors.toList());

Then, you can update the list items using

IntStream.range(0, items.size()).forEach(i -> items.get(i).index = i);

For java 8 you can use the stream API and lambdas

List<User> users;
users.forEach((u) -> u.setActive(false));

You can use peek

empList.stream().peek(e->{e.orders++;}).collect(Collectors.toList());

Also as correctly pointed by "Vasanth Senthamarai Kannan " you don't need second list as you are not modifying structure of list,

empList.forEach(e->e.orders++);

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"));