import java.util.function.*;
import java.util.*;

class Truc{
    public int a;
    public Truc(int xx){a=xx;}
    public Truc(String s){a=10;}
    public String toString(){
	return ""+a;
    }
}

class Test{
    public static void main(String[] args){

	/////////////////////////////////////////////////////////////////////////////////
	////// ex basiques
	/////////////////////////////////////////////////////////////////////////////////


	////////////////////
	// interface runnable
	////////////////////

	
	//ex de definition d'une interface fonctionnelle avec une classe anonyme
	//noter syntaxe "étrange" "new Runnable()" alors que c'est une interface
	Runnable r = new Runnable(){
		public void run(){
		    System.out.println("Hello, Lambda!");
		}
	    };
	r.run();

	
	//ex de definition d'une interface fonctionnelle avec une lambda expression
	Runnable r2 = () -> System.out.println("Hello, Lambda!2");
	r2.run();


	
	////////////////////
	// interface predicate
	////////////////////

	//en classes anonyme
	Predicate<Integer> isEvenV0 = new Predicate<Integer>(){ //là c'est ok
		public boolean test(Integer x){
		    return x%2==1;
		    
		}
	    };
	System.out.println(isEvenV0.test(6));

	//avec Lambda expresion
	Predicate<Integer> isEven = num -> num % 2 == 0;
	System.out.println(isEven.test(4)); // true

	//System.out.println((x -> x%2 == 1).test(4)); // pas ok, car java ne peut pas deviner le type du predicate



	////////////////////
	// interface comparator (utile car vous vous en servez souvent)
	////////////////////


	//avec lambda
	TreeSet<Truc> set = new TreeSet<>((t1,t2) -> t2.a - t1.a);
	set.add(new Truc(5));
	set.add(new Truc(2));	
	set.add(new Truc(7));
	for(Truc t :  set){
	    System.out.println(t);
	}


	////////////////////
	// interface consumer (utile car utilisable dans un forEach, forEach qui sera aussi utilisable avec des stream)
	////////////////////
	
	Consumer<String> c = (name -> System.out.println("I accepted : "+name));
	c.accept("bonjour"); //I accepted bonjour

	
	Consumer<String> c2 = new Consumer<>(){
		public void accept(String s){
		    System.out.println("v2 I accepted : "+s);
		}
	    };
	c2.accept("bonjour"); //v2 I accepted bonjour
	
	List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
	names.forEach(c);

	/////////////////////////////////////////////////////////////////////////////////
	////// ex avec utilisation d'une var locale
	/////////////////////////////////////////////////////////////////////////////////

	
	List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
	List<Integer> evens = new ArrayList<>();
	
	numbers.forEach(n -> {
		if (n % 2 == 0) {
		    evens.add(n);
		}
	    });

	System.out.println("les pairs de numbers: " + evens);
	
	//equivalent à :
	numbers.forEach(new Consumer<Integer>() {
		@Override
		public void accept(Integer n) {
		    if (n % 2 == 0) {
			evens.add(n);
		    }
		}
	    });

	//attention les variables locales utilisées sont finales, donc le code suivant ne compile pas
	// int count = 0;
	// numbers.forEach(n -> {
	// 	if (n % 2 == 0) {
	// 	    count++;  // error: Variable used in lambda should be final or effectively final
	// 	}
	//     });

	
    }
}

/// possible d'utiliser un attribut non final
class InstanceVariableExample {
    private int x;  // Instance variable

    public void countEvenNumbers(List<Integer> numbers) {
        numbers.forEach(n -> {  // Lambda expression accessing instance variable
		if (n % 2 == 0) {
		    x++;
		}
	    });
    }
}