A return in a lambda equals a continue in a for-each, but there is no equivalent to a break. You can just do a return to continue:

someObjects.forEach(obj -> {
   if (some_condition_met) {
      return;
   }
})

The forEach method in a Collection expects a Consumer which means a function that takes a value, but doesn't return anything. That's why you can't use return true; but a return; works fine.

I you want to break out of the loop when your condition is met, it's better to use a simple for(...) loop. I assumed that the type of obj is Object:

for (Object obj : someObjects) {
  if (some_condition_met) {
    return true;
  }
}

return false;

Though for loop is enough, you can rewrite using Guava if you like lambdas:

public boolean checkNameStartsWith(List<Foo> foos){
    return Iterables.all(foos, new Predicate<Foo>() {
        public boolean apply(Foo foo) {
            return foo.getName().startsWith("bar");
        }
    });
}

I suggest you to first try to understand Java 8 in the whole picture, most importantly in your case it will be streams, lambdas and method references.

You should never convert existing code to Java 8 code on a line-by-line basis, you should extract features and convert those.

What I identified in your first case is the following:

• You want to add elements of an input structure to an output list if they match some predicate.

Let's see how we do that, we can do it with the following:

List<Player> playersOfTeam = players.stream()
    .filter(player -> player.getTeam().equals(teamName))
    .collect(Collectors.toList());

What you do here is:

1. Turn your input structure into a stream (I am assuming here that it is of type Collection<Player>, now you have a Stream<Player>.
2. Filter out all unwanted elements with a Predicate<Player>, mapping every player to the boolean true if it is wished to be kept.
3. Collect the resulting elements in a list, via a Collector, here we can use one of the standard library collectors, which is Collectors.toList().

This also incorporates two other points:

1. Code against interfaces, so code against List<E> over ArrayList<E>.
2. Use diamond inference for the type parameter in new ArrayList<>(), you are using Java 8 after all.

Now onto your second point:

You again want to convert something of legacy Java to Java 8 without looking at the bigger picture. This part has already been answered by @IanRoberts, though I think that you need to do players.stream().filter(...)... over what he suggested.

It looks like helpFunction(item) returns some instance of some class that has a boolean status() method, and you want your method to return true if helpFunction(item).status() is true for any element of your Stream.

You can implement this logic with anyMatch:

public boolean status(List<String> myArray) {
    return myArray.stream()
                  .anyMatch(item -> helpFunction(item).status());
}

• you iterate a List of Integer. So use Collection.stream()

• you compare numeric value. So use Stream.mapToInt() to work with int rather than Integer that is more efficient. Here it doesn't change many things but if you change the stream to do some other numerical operations, you already use the correct way.

• you value a boolean (result) as soon as a condition is met. Otherwise false I assume. So use Stream.anyMatch(Predicate).

So this corresponds :

boolean result =
intList.stream()
       .mapToInt(i-> i)
       .anyMatch(i-> i > 10);

What you need here is filtering operation with combination of findFirst() which returns Optional.

If you sure that there is such item in your set, then you may safely call get() after findFirst(), but in general I advice you to provide a default value using orElse or throw exception using orElseThrow on that Optional or use one of other useful methods. Choose wisely what fits your case :)

set.stream()
   .filter(character -> character.getName().equals("Darth Veider"))
   .findFirst()