Skip to content

Commit ded21b7

Browse files
hannomaliehannomalie
committed
iluwatar#184 Fluent interface pattern, lazy fluentiterable added
1 parent 0216299 commit ded21b7

File tree

5 files changed

+539
-153
lines changed

5 files changed

+539
-153
lines changed

‎fluentinterface/src/main/java/com/iluwatar/fluentinterface/App.java‎

Lines changed: 24 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
package com.iluwatar.fluentinterface;
22

3-
import com.iluwatar.fluentinterface.fluentiterable.FluentIterable;
3+
import com.iluwatar.fluentinterface.fluentiterable.lazy.LazyFluentIterable;
4+
import com.iluwatar.fluentinterface.fluentiterable.simple.SimpleFluentIterable;
45

5-
import java.util.ArrayList;
6-
import java.util.Iterator;
7-
import java.util.List;
8-
import java.util.StringJoiner;
6+
import java.util.*;
97
import java.util.function.Function;
108
import java.util.function.Predicate;
119

10+
import static java.lang.String.valueOf;
11+
1212
public class App {
1313

1414
public static void main(String[] args) {
@@ -34,35 +34,49 @@ public static void main(String[] args) {
3434
}};
3535
prettyPrint("The initial list contains: ", integerList);
3636

37-
List<Integer> firstFiveNegatives = FluentIterable.from(integerList)
37+
List<Integer> firstFiveNegatives = SimpleFluentIterable.from(integerList)
3838
.filter(negatives())
3939
.first(3)
4040
.asList();
4141
prettyPrint("The first three negative values are: ", firstFiveNegatives);
4242

4343

44-
List<Integer> lastTwoPositives = FluentIterable.from(integerList)
44+
List<Integer> lastTwoPositives = SimpleFluentIterable.from(integerList)
4545
.filter(positives())
4646
.last(2)
4747
.asList();
4848
prettyPrint("The last two positive values are: ", lastTwoPositives);
4949

50-
FluentIterable.from(integerList)
50+
SimpleFluentIterable.from(integerList)
5151
.filter(number -> number%2 == 0)
5252
.first()
5353
.ifPresent(evenNumber -> System.out.println(String.format("The first even number is: %d", evenNumber)));
5454

5555

56-
List<String> transformedList = FluentIterable.from(integerList)
56+
List<String> transformedList = SimpleFluentIterable.from(integerList)
5757
.filter(negatives())
5858
.map(transformToString())
5959
.asList();
6060
prettyPrint("A string-mapped list of negative numbers contains: ", transformedList);
6161

62+
63+
List<String> lastTwoOfFirstFourStringMapped = LazyFluentIterable.from(integerList)
64+
.filter(positives())
65+
.first(4)
66+
.last(2)
67+
.map(number -> "String[" + String.valueOf(number) + "]")
68+
.asList();
69+
prettyPrint("The lazy list contains the last two of the first four positive numbers mapped to Strings: ", lastTwoOfFirstFourStringMapped);
70+
71+
LazyFluentIterable.from(integerList)
72+
.filter(negatives())
73+
.first(2)
74+
.last()
75+
.ifPresent(lastOfFirstTwo -> System.out.println(String.format("The last of the first two negatives is: %d", lastOfFirstTwo)));
6276
}
6377

6478
private static Function<Integer, String> transformToString() {
65-
return integer -> "String[" + String.valueOf(integer) + "]";
79+
return integer -> "String[" + valueOf(integer) + "]";
6680
}
6781
private static Predicate<? super Integer> negatives() {
6882
return integer -> (integer < 0);

‎fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/FluentIterable.java‎

Lines changed: 32 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -1,189 +1,78 @@
11
package com.iluwatar.fluentinterface.fluentiterable;
22

3-
import java.util.*;
3+
import java.util.ArrayList;
4+
import java.util.Iterator;
5+
import java.util.List;
6+
import java.util.Optional;
47
import java.util.function.Consumer;
58
import java.util.function.Function;
69
import java.util.function.Predicate;
710

811
/**
912
* The FluentIterable is a more convenient implementation of the common iterable interface based
1013
* on the fluent interface design pattern.
11-
* This implementation demonstrates a possible way to implement this functionality, but
14+
* This interface defines common operations, but
1215
* doesn't aim to be complete. It was inspired by Guava's com.google.common.collect.FluentIterable.
1316
* @param <TYPE> is the class of objects the iterable contains
1417
*/
15-
public class FluentIterable<TYPE> implements Iterable<TYPE> {
16-
17-
private final Iterable<TYPE> iterable;
18+
public interface FluentIterable<TYPE> extends Iterable<TYPE> {
1819

1920
/**
20-
* This constructor creates a copy of a given iterable's contents.
21-
* @param iterable the iterable this interface copies to work on.
22-
*/
23-
protected FluentIterable(Iterable<TYPE> iterable) {
24-
ArrayList<TYPE> copy = new ArrayList<>();
25-
Iterator<TYPE> iterator = iterable.iterator();
26-
while (iterator.hasNext()) {
27-
copy.add(iterator.next());
28-
}
29-
this.iterable = copy;
30-
}
31-
32-
/**
33-
* Iterates over all elements of this iterator and filters them.
21+
* Filters the iteration with the given predicate.
3422
* @param predicate the condition to test with for the filtering. If the test
3523
* is negative, the tested object is removed by the iterator.
36-
* @return the same FluentIterable with a filtered collection
24+
* @return a filtered FluentIterable
3725
*/
38-
public final FluentIterable<TYPE> filter(Predicate<? super TYPE> predicate) {
39-
Iterator<TYPE> iterator = iterator();
40-
while (iterator.hasNext()) {
41-
TYPE nextElement = iterator.next();
42-
if(!predicate.test(nextElement)) {
43-
iterator.remove();
44-
}
45-
}
46-
return this;
47-
}
26+
FluentIterable<TYPE> filter(Predicate<? super TYPE> predicate);
4827

4928
/**
5029
* Uses the Iterable interface's forEach method to apply a given function
51-
* for each object of the iterator.
52-
* @param action the action for each object
53-
* @return the same FluentIterable with an untouched collection
30+
* for each object of the iterator. This is a terminating operation.
5431
*/
55-
public final FluentIterable<TYPE> forEachDo(Consumer<? super TYPE> action) {
56-
iterable.forEach(action);
57-
return this;
58-
}
32+
void forEachDo(Consumer<? super TYPE> action);
5933

6034
/**
61-
* Can be used to collect objects from the iteration.
62-
* @return an option of the first object of the iteration
35+
* Evaluates the iteration and returns the first element. This is a terminating operation.
36+
* @return the first element after the iteration is evaluated
6337
*/
64-
public final Optional<TYPE> first() {
65-
List<TYPE> list = first(1).asList();
66-
if(list.isEmpty()) {
67-
return Optional.empty();
68-
}
69-
return Optional.of(list.get(0));
70-
}
38+
Optional<TYPE> first();
7139

7240
/**
73-
* Can be used to collect objects from the iteration.
74-
* @param count defines the number of objects to return
75-
* @return the same FluentIterable with a collection decimated to a maximum of 'count' first objects.
41+
* Evaluates the iteration and leaves only the count first elements.
42+
* @return the first count elements as an Iterable
7643
*/
77-
public final FluentIterable<TYPE> first(int count) {
78-
Iterator<TYPE> iterator = iterator();
79-
int currentCount = 0;
80-
while (iterator.hasNext()) {
81-
iterator.next();
82-
if(currentCount >= count) {
83-
iterator.remove();
84-
}
85-
currentCount++;
86-
}
87-
return this;
88-
}
44+
FluentIterable<TYPE> first(int count);
8945

9046
/**
91-
* Can be used to collect objects from the iteration.
92-
* @return an option of the last object of the iteration
47+
* Evaluates the iteration and returns the last element. This is a terminating operation.
48+
* @return the last element after the iteration is evaluated
9349
*/
94-
public final Optional<TYPE> last() {
95-
List<TYPE> list = last(1).asList();
96-
if(list.isEmpty()) {
97-
return Optional.empty();
98-
}
99-
return Optional.of(list.get(0));
100-
}
50+
Optional<TYPE> last();
10151

10252
/**
103-
* Can be used to collect objects from the iteration.
104-
* @param count defines the number of objects to return
105-
* @return the same FluentIterable with a collection decimated to a maximum of 'count' last objects
53+
* Evaluates the iteration and leaves only the count last elements.
54+
* @return the last counts elements as an Iterable
10655
*/
107-
public final FluentIterable<TYPE> last(int count) {
108-
int remainingElementsCount = getRemainingElementsCount();
109-
Iterator<TYPE> iterator = iterator();
110-
int currentIndex = 0;
111-
while (iterator.hasNext()) {
112-
iterator.next();
113-
if(currentIndex < remainingElementsCount - count) {
114-
iterator.remove();
115-
}
116-
currentIndex++;
117-
}
118-
119-
return this;
120-
}
56+
FluentIterable<TYPE> last(int count);
12157

12258
/**
12359
* Transforms this FluentIterable into a new one containing objects of the type NEW_TYPE.
12460
* @param function a function that transforms an instance of TYPE into an instance of NEW_TYPE
12561
* @param <NEW_TYPE> the target type of the transformation
12662
* @return a new FluentIterable of the new type
12763
*/
128-
public final <NEW_TYPE> FluentIterable<NEW_TYPE> map(Function<? super TYPE, NEW_TYPE> function) {
129-
List<NEW_TYPE> temporaryList = new ArrayList();
130-
Iterator<TYPE> iterator = iterator();
131-
while (iterator.hasNext()) {
132-
temporaryList.add(function.apply(iterator.next()));
133-
}
134-
return from(temporaryList);
135-
}
136-
137-
/**
138-
* Collects all remaining objects of this iteration into a list.
139-
* @return a list with all remaining objects of this iteration
140-
*/
141-
public List<TYPE> asList() {
142-
return toList(iterable.iterator());
143-
}
64+
<NEW_TYPE> FluentIterable<NEW_TYPE> map(Function<? super TYPE, NEW_TYPE> function);
65+
List<TYPE> asList();
14466

14567
/**
146-
* @return a FluentIterable from a given iterable. Calls the FluentIterable constructor.
68+
* Utility method that iterates over iterable and adds the contents to a list.
69+
* @param iterable the iterable to collect
70+
* @param <TYPE> the type of the objects to iterate
71+
* @return a list with all objects of the given iterator
14772
*/
148-
public static final <TYPE> FluentIterable<TYPE> from(Iterable<TYPE> iterable) {
149-
return new FluentIterable<>(iterable);
150-
}
151-
152-
@Override
153-
public Iterator<TYPE> iterator() {
154-
return iterable.iterator();
155-
}
156-
157-
@Override
158-
public void forEach(Consumer<? super TYPE> action) {
159-
iterable.forEach(action);
160-
}
161-
162-
163-
@Override
164-
public Spliterator<TYPE> spliterator() {
165-
return iterable.spliterator();
166-
}
167-
168-
/**
169-
* @return the count of remaining objects in the current iteration
170-
*/
171-
public final int getRemainingElementsCount() {
172-
int counter = 0;
173-
Iterator<TYPE> iterator = iterator();
174-
while(iterator.hasNext()) {
175-
iterator.next();
176-
counter++;
177-
}
178-
return counter;
179-
}
180-
181-
/**
182-
* Collects the remaining objects of the given iterators iteration into an List.
183-
* @return a new List with the remaining objects.
184-
*/
185-
public static <TYPE> List<TYPE> toList(Iterator<TYPE> iterator) {
186-
List<TYPE> copy = new ArrayList<>();
73+
static <TYPE> List<TYPE> copyToList(Iterable<TYPE> iterable) {
74+
ArrayList<TYPE> copy = new ArrayList<>();
75+
Iterator<TYPE> iterator = iterable.iterator();
18776
while (iterator.hasNext()) {
18877
copy.add(iterator.next());
18978
}

‎fluentinterface/src/main/java/com/iluwatar/fluentinterface/fluentiterable/lazy/DecoratingIterator.java‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
package com.iluwatar.fluentinterface.fluentiterable.lazy;
2+
3+
import java.util.Iterator;
4+
5+
/**
6+
* This class is used to realize LazyFluentIterables. It decorates
7+
* a given iterator.
8+
* @param <TYPE>
9+
*/
10+
public abstract class DecoratingIterator<TYPE> implements Iterator<TYPE> {
11+
12+
protected final Iterator<TYPE> fromIterator;
13+
14+
private TYPE next = null;
15+
16+
/**
17+
* Creates an iterator that decorates the given iterator.
18+
* @param fromIterator
19+
*/
20+
public DecoratingIterator(Iterator<TYPE> fromIterator) {
21+
this.fromIterator = fromIterator;
22+
}
23+
24+
/**
25+
* Precomputes and caches the next element of the iteration.
26+
* @return true if a next element is available
27+
*/
28+
@Override
29+
public final boolean hasNext() {
30+
next = computeNext();
31+
return next != null;
32+
}
33+
34+
/**
35+
* Returns the next element of the iteration. This implementation caches it.
36+
* If no next element is cached, it is computed.
37+
* @return the next element obf the iteration
38+
*/
39+
@Override
40+
public final TYPE next() {
41+
TYPE result = next;
42+
next = null;
43+
result = (result == null ? fromIterator.next() : result);
44+
return result;
45+
}
46+
47+
/**
48+
* Computes the next object of the iteration. Can be implemented to
49+
* realize custom behaviour for an iteration process.
50+
* @return
51+
*/
52+
public abstract TYPE computeNext();
53+
}

0 commit comments

Comments
 (0)