Tutoriel d'introduction à la programmation fonctionnelle avec Guava

Predicate<Chien> malePredicate = new Predicate<Chien>() {
    @Override
    public boolean apply(Chien chien) {
        return chien.getSex() == SexeEnum.MALE;
    }
};

Function<Chien, String> chienNameFunction = new Function<Chien, String>() {
    @Override
    public String apply(Chien from) {
        return from.getName();
    }
};

@Test
public void testFilterMale1() {
    // Arrange
    final List<Chien> chiens = Lists.newArrayList(
            new Chien("Milou", MALE), 
            new Chien("Pluto", MALE), 
            new Chien("Lassie", FEMALE), 
            new Chien("Volt", MALE), 
            new Chien("Rantanplan", MALE),
            new Chien("Idefix", MALE));
    final int nb = 5;

    // Act
    final Predicate<Chien> malePredicate = new Predicate<Chien>() {
        @Override
        public boolean apply(Chien chien) {
            return chien.getSex() == SexeEnum.MALE;
        }
    };
    final List<Chien> res = Lists.newArrayList(Iterables.filter(chiens, malePredicate));


    // Assert
    Assert.assertEquals(nb, res.size());
}

@Test
public void testFilterSurMap() {
    // Arrange
    final Map<String, Integer> ages = new ImmutableMap.Builder<String, Integer>()
            .put("Jean", 32)
            .put("Paul", 12)
            .put("Lucie", 37)
            .put("Marie", 17)
            .put("Bernard", 17)
            .put("Toto", 17)
            .put("Loulou", 17)
            .build();
    final int nb = 3; // Jean, Paul et toto

    // Act
    final Predicate<String> sizePredicate = new Predicate<String>() {

        @Override
        public boolean apply(String from) {
            return from.length() < 5;
        }
    };

    final Map<String, Integer> filtered = Maps.filterKeys(ages, sizePredicate);

    // Assert
    Assert.assertEquals(nb, filtered.size());
}

@Test
public void testTransform() {
    // Arrange
    final List<Chien> chiens = Lists.newArrayList(
            new Chien("Milou", MALE), 
            new Chien("Pluto", MALE), 
            new Chien("Lassie", FEMALE), 
            new Chien("Volt", MALE), 
            new Chien("Rantanplan", MALE),
            new Chien("Idefix", MALE));

    final List<String> expected = Lists.newArrayList("Milou", "Pluto", "Lassie", "Volt", "Rantanplan", "Idefix");

    // Act
    final List<String> noms = Lists.transform(chiens, new Function<Chien, String>() {
        @Override
        public String apply(Chien from) {
            return from.getName();
        }
    });

    // Assert
    Assert.assertEquals(expected, noms);
}

@Test
public void testTransformToSuperDog() {
    // Arrange
    final Set<Chien> chiens = Sets.newHashSet(
            new Chien("Milou", MALE), 
            new Chien("Pluto", MALE), 
            new Chien("Lassie", FEMALE), 
            new Chien("Volt", MALE), 
            new Chien("Rantanplan", MALE),
            new Chien("Idefix", MALE));
    final String expectedPower = "Code en Java";

    // Act
    final Function<Chien, SuperDog> chienToSuperDogFunc = new Function<Chien, SuperDog>() {
        @Override
        public SuperDog apply(Chien from) {
            final SuperDog to = new SuperDog();

            to.setName(from.getName());
            final List<String> powers = Lists.newArrayList("Vole", "Code en Java", "Court vite");
            to.setPowers(powers);
            return to;
        }
    };
    final Iterable<SuperDog> iter = Iterables.transform(chiens, chienToSuperDogFunc);

    // Assert
    for(SuperDog sd : iter) {
        Assert.assertTrue(sd.getPowers().contains(expectedPower));
    }
}

@Test
public void testFilterMap() {
    // Arrange
    final List<Chien> chiens = Lists.newArrayList(
            new Chien("Milou", MALE), 
            new Chien("Pluto", MALE), 
            new Chien("Lassie", FEMALE), 
            new Chien("Volt", MALE), 
            new Chien("Rantanplan", MALE),
            new Chien("Idefix", MALE));

    final List<String> expected = Lists.newArrayList("Milou", "Pluto", "Volt", "Rantanplan", "Idefix");

    // Act

    final Predicate<Chien> malePredicate = new Predicate<Chien>() {
        @Override
        public boolean apply(Chien chien) {
            System.out.println("apply predicate");
            return chien.getSex() == SexeEnum.MALE;
        }
    };

    final Function<Chien, String> toNameFunc = new Function<Chien, String>() {
        @Override
        public String apply(Chien from) {
            System.out.println("apply function");
            return from.getName();
        }
    };

    final Iterable<Chien> filtered = Iterables.filter(chiens, malePredicate);
    final Iterable<String> mapped = Iterables.transform(filtered, toNameFunc);

    final List<String> noms = Lists.newArrayList(mapped);

    // Assert
    Assert.assertEquals(expected, noms);
}

final List<String> noms = FluentIterable.from(chiens)
        .filter(malePredicate)
        .transform(toNameFunc)
        .toList();

List<Dog> dogs = Lists.newArrayList(
	new Dog("effy", Dog.Gender.MALE, 5),
	new Dog("wolf", Dog.Gender.MALE, 7),
	new Dog("lili", Dog.Gender.FEMALE, 7),
	new Dog("poupette", Dog.Gender.FEMALE, 10),
	new Dog("rouquette", Dog.Gender.FEMALE, 11),
	new Dog("rouky", Dog.Gender.MALE, 8),
	new Dog("athos", Dog.Gender.MALE, 3));
 
//final float average = 0;
 
Optional<Float> average = FluentIterable
	.from(dogs)
	.filter(new Predicate<Dog>() {
		@Override
		public boolean apply(Dog t) {
			// filter keep only males
			return t.getGender() == Dog.Gender.MALE;
		}
	})
	.transform(new Function<Dog, Float>() {
		int index = 0;
		float previousAverage = 0;
	 
		@Override
		public Float apply(Dog f) {
			float age = f.getAge();
	 
			// calculate
			float prevSum = previousAverage * index; // step 1
			index++;
			float newSum = prevSum + age; // step 2
			float newAverage = newSum / index; // step 3
	 
			previousAverage = newAverage;
	 
			return newAverage;
		}
	})
	.last();
 
float test = (5 + 7 + 8 + 3) / 4F;
System.out.println(test);
System.out.println("Average of male ages : " + average);

public class Iterables2 {
 
	private Iterables2() {}
 
	public static <F extends Object> F reduce(Iterable<F> itrbl, Function<List<F>, ? extends F> fnctn) {
		F prevResult = null;
		F result = null;
 
		for (F elem : itrbl) {
			if (prevResult == null) {
				result = elem;
			} else {
				result = fnctn.apply(Lists.<F>newArrayList(prevResult, elem));
			}
			prevResult = result;
		}
		return result;
	}
}

float average = Iterables2.reduce(
	FluentIterable
		.from(dogs)
		.filter(new Predicate<Dog>() {
			@Override
			public boolean apply(Dog t) {
				// filter keep only males
				return t.getGender() == Dog.Gender.MALE;
			}
		})
		.transform(new Function<Dog, Float>() {
 
	int index = 0;
	float previousAverage = 0;
 
	@Override
	public Float apply(Dog f) {
		return Integer.valueOf(f.getAge()).floatValue();
	}
	}), new Function<List<Float>, Float>() {
 
		int currentIndex = 1;
	 
		@Override
		public Float apply(List<Float> f) {
			// recursive serie
	 
			float prevResult = f.get(0);
			float currentAge = f.get(1);
	 
			currentIndex++;
	 
			// calculate
			float prevSum = prevResult * (currentIndex - 1); // step 1
			float newSum = prevSum + currentAge; // step 2
			float newAverage = newSum / currentIndex; // step 3
	 
			return newAverage;
		}
	});

String csv = "" +
	"element 1.1, element 1.2, element 1.3, element 1.4\n" +
	"element 2.1, element 2.2\n" +
	"element 3.1, element 3.2, element 3.3\n" +
	"element 4.1, element 4.2, element 4.3, element 4.4, element 4.5\n" +
	"";
 
Iterables.all(Splitter.on('\n')
	.split(csv),
	new Predicate<String>() {
		// parse row
 
		@Override
		public boolean apply(String t) {
			// parse item
 
			Iterables.all(Splitter.on(',')
				.trimResults()
				.omitEmptyStrings()
				.split(t), 
				new Predicate<String>() {
 
				@Override
				public boolean apply(String t) {
					System.out.println("Parse : " + t);
					return true;
				}
			});
 
			return true;
		}
	}
);