From 0363c0a329adb16b2e8d0d940c043f73cae3bc94 Mon Sep 17 00:00:00 2001 From: overflowerror Date: Wed, 8 Jul 2020 15:48:29 +0200 Subject: [PATCH] add java version --- java/business/AbstractFibonacciSequence.java | 33 +++++++++++++ java/business/Couple.java | 27 ++++++++++ .../FibonacciBusinessApplication.java | 18 +++++++ java/business/IntegerFibonacciSequence.java | 12 +++++ java/business/RecursiveSeqeunce.java | 49 +++++++++++++++++++ java/business/Sequence.java | 7 +++ java/business/StatefulConsumer.java | 32 ++++++++++++ java/business/StatefulSupplier.java | 31 ++++++++++++ java/minimal-loop-less/Fibonacci.java | 17 +++++++ 9 files changed, 226 insertions(+) create mode 100644 java/business/AbstractFibonacciSequence.java create mode 100644 java/business/Couple.java create mode 100644 java/business/FibonacciBusinessApplication.java create mode 100644 java/business/IntegerFibonacciSequence.java create mode 100644 java/business/RecursiveSeqeunce.java create mode 100644 java/business/Sequence.java create mode 100644 java/business/StatefulConsumer.java create mode 100644 java/business/StatefulSupplier.java create mode 100644 java/minimal-loop-less/Fibonacci.java diff --git a/java/business/AbstractFibonacciSequence.java b/java/business/AbstractFibonacciSequence.java new file mode 100644 index 0000000..b26add1 --- /dev/null +++ b/java/business/AbstractFibonacciSequence.java @@ -0,0 +1,33 @@ +package business; + +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +public abstract class AbstractFibonacciSequence extends RecursiveSeqeunce { + private List startValues = new ArrayList<>(2); + + protected abstract T add(T v1, T v2); + + public AbstractFibonacciSequence(T value1, T value2) { + startValues.add(value1); + startValues.add(value2); + } + + @Override + protected List getInitialState() { + return new ArrayList<>(startValues); + } + + @Override + protected T getNext(List last) { + return this.add(last.get(0), last.get(1)); + } + + public static Consumer prettyPrintConsumer(PrintStream stream, String format) { + return RecursiveSeqeunce.accumulatedConsumer(3, l -> { + stream.printf(format, l.get(0), l.get(1), l.get(2)); + }); + } +} diff --git a/java/business/Couple.java b/java/business/Couple.java new file mode 100644 index 0000000..66cea81 --- /dev/null +++ b/java/business/Couple.java @@ -0,0 +1,27 @@ +package business; + +public class Couple { + private T1 v1; + private T2 v2; + + public Couple(T1 v1, T2 v2) { + this.v1 = v1; + this.v2 = v2; + } + + public T1 getV1() { + return v1; + } + + public void setV1(T1 v1) { + this.v1 = v1; + } + + public T2 getV2() { + return v2; + } + + public void setV2(T2 v2) { + this.v2 = v2; + } +} diff --git a/java/business/FibonacciBusinessApplication.java b/java/business/FibonacciBusinessApplication.java new file mode 100644 index 0000000..b06dd16 --- /dev/null +++ b/java/business/FibonacciBusinessApplication.java @@ -0,0 +1,18 @@ +package business; + +public class FibonacciBusinessApplication { + public static void main(String[] args) { + System.out.printf("Result: %d\n", + new IntegerFibonacciSequence(1, 1) + .stream() + .limit(5) + .peek( + AbstractFibonacciSequence.prettyPrintConsumer( + System.out, + "%d + %d = %d\n" + ) + ).mapToInt(Integer::intValue) + .max() + .getAsInt()); + } +} \ No newline at end of file diff --git a/java/business/IntegerFibonacciSequence.java b/java/business/IntegerFibonacciSequence.java new file mode 100644 index 0000000..3b24cb6 --- /dev/null +++ b/java/business/IntegerFibonacciSequence.java @@ -0,0 +1,12 @@ +package business; + +public class IntegerFibonacciSequence extends AbstractFibonacciSequence { + @Override + protected Integer add(Integer v1, Integer v2) { + return v1 + v2; + } + + public IntegerFibonacciSequence(Integer value1, Integer value2) { + super(value1, value2); + } +} diff --git a/java/business/RecursiveSeqeunce.java b/java/business/RecursiveSeqeunce.java new file mode 100644 index 0000000..2374be1 --- /dev/null +++ b/java/business/RecursiveSeqeunce.java @@ -0,0 +1,49 @@ +package business; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; + +public abstract class RecursiveSeqeunce implements Sequence { + + protected abstract List getInitialState(); + protected abstract T getNext(List last); + + private T supplierGetter(Couple> _state) { + List state = _state.getV2(); + int size = state.size(); + int index = _state.getV1(); + + _state.setV1(index + 1); + + if (index < size) { + return state.get(index); + } + + T value = getNext(state); + + state.remove(0); + state.add(value); + + return value; + } + + @Override + public Stream stream() { + return Stream.generate(StatefulSupplier.get(new Couple<>(0, getInitialState()), this::supplierGetter)); + } + + public static Consumer accumulatedConsumer(int recursionLength, Consumer> consumer) { + return StatefulConsumer.get(new ArrayList(recursionLength), (l, o) -> { + if (l.size() >= recursionLength) { + l.remove(0); + } + l.add(o); + + if (l.size() >= recursionLength) { + consumer.accept(l); + } + }); + } +} diff --git a/java/business/Sequence.java b/java/business/Sequence.java new file mode 100644 index 0000000..0c5534d --- /dev/null +++ b/java/business/Sequence.java @@ -0,0 +1,7 @@ +package business; + +import java.util.stream.Stream; + +public interface Sequence { + Stream stream(); +} diff --git a/java/business/StatefulConsumer.java b/java/business/StatefulConsumer.java new file mode 100644 index 0000000..4c5165b --- /dev/null +++ b/java/business/StatefulConsumer.java @@ -0,0 +1,32 @@ +package business; + +import java.util.function.BiConsumer; +import java.util.function.Consumer; + +public interface StatefulConsumer extends Consumer { + class StatefulConsumerImpl implements StatefulConsumer { + private S state; + private BiConsumer consumer; + + private StatefulConsumerImpl(S state, BiConsumer consumer) { + this.state = state; + this.consumer = consumer; + } + + @Override + public void accept(S state, T value) { + consumer.accept(state, value); + } + + @Override + public void accept(T t) { + accept(state, t); + } + } + + void accept(S state, T value); + + static StatefulConsumer get(S state, BiConsumer consumer) { + return new StatefulConsumerImpl<>(state, consumer); + } +} diff --git a/java/business/StatefulSupplier.java b/java/business/StatefulSupplier.java new file mode 100644 index 0000000..7396abf --- /dev/null +++ b/java/business/StatefulSupplier.java @@ -0,0 +1,31 @@ +package business; + +import java.util.function.Function; +import java.util.function.Supplier; + +public interface StatefulSupplier extends Supplier { + class StatefulSupplierImpl implements StatefulSupplier { + private S state; + private Function getter; + + private StatefulSupplierImpl(S state, Function getter) { + this.state = state; + this.getter = getter; + } + + @Override + public T get(S s) { + return getter.apply(s); + } + + public T get() { + return get(state); + } + } + + T get(S s); + + static StatefulSupplier get(S state, Function getter) { + return new StatefulSupplierImpl<>(state, getter); + } +} diff --git a/java/minimal-loop-less/Fibonacci.java b/java/minimal-loop-less/Fibonacci.java new file mode 100644 index 0000000..a57d532 --- /dev/null +++ b/java/minimal-loop-less/Fibonacci.java @@ -0,0 +1,17 @@ +import java.util.Map; +import java.util.stream.Stream; + +public class Fibonacci { + public static void main(String[] args) { + System.out.printf("Result: %d\n", + Stream.iterate( + Map.entry(1, 1), e -> Map.entry(e.getValue(), e.getKey() + e.getValue()) + ).limit(args.length == 1 ? Integer.valueOf(args[0]) : 3 + ).peek(e -> System.out.printf("%d + %d = ", e.getKey(), e.getValue()) + ).mapToInt(e -> e.getKey() + e.getValue() + ).peek(System.out::println + ).max( + ).getAsInt() + ); + } +} \ No newline at end of file