See the javadoc

of List

list.get(0);

or Set

set.iterator().next();

and check the size before using the above methods by invoking isEmpty()

!list_or_set.isEmpty()

playersList.get(0)

Java has limited operator polymorphism. So you use the get() method on List objects, not the array index operator ([])

You can do it with a combination of map, mapToInt, filter and findFirst, but it won't be so pretty :

int a =
    sample.getSomeDTO()
          .stream()
          .map(SomeDTO::getSomeElement)
          .mapToInt(e -> {
               if (e.equals("Condition1"))
                   return 1;
               else if (e.equals("Condition2"))
                   return 2;
               else if (e.equals("Condition3"))
                   return 3;
               else
                   return 0;
           })
          .filter(a -> a > 0)
          .findFirst()
          .orElse(0);

As Holger suggested, you can make it less ugly by replacing the if statements with ternary conditional expressions :

int a =
    sample.getSomeDTO()
          .stream()
          .map(SomeDTO::getSomeElement)
          .mapToInt(e -> e.equals("Condition1") ? 1 : e.equals("Condition2") ? 2 : e.equals("Condition3") ? 3 : 0)
          .filter(a -> a > 0)
          .findFirst()
          .orElse(0);

Assuming the List inside your Optional can be empty, then you should account for this case as well. The easiest would thus be:

return persons.flatMap(list -> list.stream().findFirst()).map(Person::getAge).orElse(null);

This unfortunately does not handle a null first list entry as findFirst() throws a NullPointerException when the first element of a Stream is null (as Holger noted in the comments).

So if you want to skip null list entries and take the first non-null one, do as follows:

return persons.flatMap(list -> list.stream().filter(Objects::nonNull).findFirst())
              .map(Person::getAge)
              .orElse(null);

Otherwise, if instead you always want the first entry even when it is null, you could adapt it like this:

return persons.flatMap(list -> list.stream().limit(1).filter(Objects::nonNull).findFirst())
              .map(Person::getAge)
              .orElse(null);

however this really becomes quite convoluted, so it is simpler to just get back to testing whether the list is empty:

return persons.filter(list -> !list.isEmpty())
              .map(list -> list.get(0))
              .map(Person::getAge)
              .orElse(null);

This means that the element at index 2 (which is the 3rd element) is null. Iterating collections is usually done with the for-each loop:

for (Hotel hotel : hotels) {
   // do something with each hotel
}

You can use the following by using Optional and Streams.

StudentCollection sc = ...;
final Optional<Student> student = Optional.ofNullable(sc)
    .map(StudentCollection::getStudents)
    .map(Collection::stream) 
    .flatMap(Stream::findFirst);

The optional is used to safely handle the StudentCollection or the List<Student> which might by null.

As mentioned in the comment by @GhostCat the overhead created by above snippet is horribly big. Because you're using quite expensive API-methods for such a simple task.

As @Holger suggested, you can reduce the overhead by not using the Stream-API:

StudentCollection sc = ...;
final Optional<Student> student = Optional.ofNullable(sc)
    .map(StudentCollection::getStudents)
    .filter(list -> !list.isEmpty()) 
    .map(list -> list.get(0));

Which still yields the same result as the prior snippet.

When you don't want any overhead you can use the following "old" (pre Java8) way:

StudentCollection sc = ...;
Student student = null;
if(sc != null){
    List<Student> students = sc.getStudents();
    if(students != null && !students.isEmpty()){
        student = students.get(0);
    }
}

import java.util.List;
import java.util.stream.Collectors;

public class Application {

    public static void main(String[] args) {

        List<List<String>>  list = List.of(List.of("A1","B1"),List.of("A2","B2"));

       List<String> listOnlyFirstOne  =  list
                            .stream() // create a stream
                            .map(subList -> subList.get(0)) // collect only first one of each list
                            .collect(Collectors.toList()); // collect result from map into new list
     
       listOnlyFirstOne.forEach(System.out::println); // print new list
       
    }

}

An easy way is the use of the stream api:

List firstElements = list.stream().map(o -> o[0]).collect(Collectors.toList());