//beautiful lambda expression
List<Student> getStudentsByClass(String klass) {
    return filterStudents((Student s) -> s.klass.equals(klass), allStudents());
}

//Formats

(T1 p1, T2 p2, ..., Tn pn) -> {statement}

//types can be ommited
(p1,p2, ..., pn) -> {statement}

//parenthesis can be ommitted for a single parameter
p1 -> {statement}

// curly brackets can be ommitted for a single expression
p1 -> expression

//traditionally searching for something in a list with a foreach loop -> very repetitive
for (Student s : EventoDB.allStudents()){
        if (s.klass.equal(klass) { restult.add(s);}
    }
    return result;
}

//Avoid repetition by abstracting the test as an interface
interface StudentPredicate { 
    boolean test(Student s);
}

//see
List<Student> filterStudents(StudentPredicate p, List<Student> students){
    List<Student> result = new ArrayList<>();
    for (Student s : students) {
        if (p.test(s)) { //testing with the intefarce
            result.add(s);
        } 
    }
    return result;
}

//Implement "class test" as a StudentPredicate
class ClassPredicate implements StudentPredicate { private String klass;
    ClassPredicate(String klass) { this.klass = klass; }
    public boolean test(Student s) {
       return s.klass.equals(klass);
} }

//potential usage
public List<Student> getStudentsByClass(String klass) {
   return filterStudents(
    new ClassPredicate(klass),allStudents());
}

//given a list of students
class Student {
      final String lastName, firstName, email, klass; Student(String l, String f, String e, String k) {
              this.lastName = l;   this.firstName = f;
              this.email = e;      this.klass = k;
    }
}

//filling the list with elements
class EventoDB {
  static List<Student> allStudents() {
    List<Student> students = new ArrayList<>();
        students.add(new Student("Cherek", "Oliver","oliver.cherek@students.fhnw.ch", "1Ibb"));
        students.add(new Student("Andermatt", "Jonathan","jonathan.andermatt@students.fhnw.ch", ”1Ic"));
      return students;
  } 
}

@FunctionalInterface
public interface Fun<I,O> {
O apply(I i); // This is the single abstract method
}

Fun<String, Integer> f = s -> s.length();
Integer i = f.apply("Java");

public static void bla(Fun<String, String> ss){
    sout(ss.apply('Hallo');
}

bla(s -> s.toUpperCase());