Реализация Stream методов без использование Stream API (БОЛЬ)

 
 
 
Сообщения:2
Здравствуйте, уже 4 дня не могу решить это задание (хожу на бесплатные курсы по Java) тема была лямды и стримы, после чего дали вот такое домашнее задание:
Мало того что тема стримов и лямд (как и в целом функционального программирования) далась для понимания не легко, как тут нужно реализовать функционал самого стрима, без применения его API.
Я даже не знаю как к этому подойти(((( Очень прошу помощи, или совета хотя бы в каком направлении двигаться, спасибо.

    /*
    *  IMPLEMENT
    *  You are NOT supposed to use the stream API inside these methods!!!
    */
    

    public class CollectionUtils {
        private CollectionUtils() {
        }
        public static <E> List<E> generate(Supplier< E> generator, int count) {
            //TODO Implement me
            return null;
        }
        public static <E> List<E> filter(List< E> elements, Predicate< E> filter) {
            //TODO Implement me
            return null;
        }
        public static <E> boolean anyMatch(List< E> elements, Predicate< E> predicate) {
            //TODO Implement me
            return false;
        }
        public static <E> boolean allMatch(List< E> elements, Predicate< E> predicate) {
            //TODO Implement me
            return false;
        }
        public static <E> boolean noneMatch(List< E> elements, Predicate< E> predicate) {
            //TODO Implement me
            return false;
        }
        public static <T, R> List<R> map(List< T> elements, Function< T, R> mappingFunction) {
            //TODO Implement me
            return null;
        }
        public static <E> Optional< E> max(List< E> elements, Comparator< E> comparator) {
            //TODO Implement me
            return null;
        }
        public static <E> Optional< E> min(List< E> elements, Comparator< E> comparator) {
            //TODO Implement me
            return null;
        }
        public static <E> List<E> distinct(List< E> elements) {
            //TODO Implement me
            return null;
        }
        public static <E> void forEach(List< E> elements, Consumer< E> consumer) {
            //TODO Implement me
        }
        public static <E> Optional< E> reduce(List< E> elements, BinaryOperator< E> accumulator) {
            //TODO Implement me
            return null;
        }
        public static <E> E reduce(E seed, List< E> elements, BinaryOperator< E> accumulator) {
            //TODO Implement me
            return null;
        }
        public static <E> Map<Boolean, List< E>> partitionBy(List< E> elements, Predicate< E> predicate) {
            //TODO Implement me
            return null;
        }
        public static <T, K> Map<K, List<T>> groupBy(List< T> elements, Function< T, K> classifier) {
            //TODO Implement me
            return null;
        }
        public static <T, K, U> Map<K, U> toMap(List< T> elements,
                                                Function< T, K> keyFunction,
                                                Function< T, U> valueFunction,
                                                BinaryOperator< U> mergeFunction) {
            //TODO Implement me
            return null;
        }
    }

 
 
Сообщения:558
Стримы и лямбды - синтетический сахар, они имеют под собой простую реализацию, это те же классы и методы, что и в 1.2 и в 1.7, просто запись отличается.

Задание заключается примерно в следующем:
public class CollectionUtils {
    private CollectionUtils() {
    }
    public static <E> List<E> generate(Supplier< E> generator, int count) {
        //TODO Implement me
        List<E> list = new ArrayList<>();
        for (int i = 0; i < count; i++){
            list.add(generator.get());
        }
        return list;
    }
    public static <E> List<E> filter(List< E> elements, Predicate< E> filter) {
        //TODO Implement me
        List<E> list = new ArrayList<>();
        for (E element : elements){
            if(filter.test(element)){
                list.add(element);
            }
        }
        return list;
    }
// и так далее.......

Все не стал писать, а то тебе неинтересно будет. Или надо?

Я только учусь
 
 
Сообщения:558
import java.util.*;
import java.util.function.*;

public class CollectionUtils {
    private CollectionUtils() {
        throw new UnsupportedOperationException();
    }

    public static <E> List<E> generate(Supplier<E> generator, int count) {
        List<E> list = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            list.add(generator.get());
        }
        return list;
    }

    public static <E> List<E> filter(List<E> elements, Predicate<E> filter) {
        List<E> list = new ArrayList<>();
        for (E element : elements) {
            if (filter.test(element)) {
                list.add(element);
            }
        }
        return list;
    }

    public static <E> boolean anyMatch(List<E> elements, Predicate<E> predicate) {
        for (E elem : elements) {
            if (predicate.test(elem)) {
                return true;
            }
        }
        return false;
    }

    public static <E> boolean allMatch(List<E> elements, Predicate<E> predicate) {
        for (E elem : elements) {
            if (!predicate.test(elem)) {
                return false;
            }
        }
        return true;
    }

    public static <E> boolean noneMatch(List<E> elements, Predicate<E> predicate) {
        for (E elem : elements) {
            if (predicate.test(elem)) {
                return false;
            }
        }
        return true;
    }

    public static <T, R> List<R> map(List<T> elements, Function<T, R> mappingFunction) {
        List<R> list = new ArrayList<>();
        for (T elem : elements) {
            list.add(mappingFunction.apply(elem));
        }
        return list;
    }

    public static <E> Optional<E> max(List<E> elements, Comparator<E> comparator) {
        List<E> list = new ArrayList<>();
        list.addAll(elements);
        list.sort(comparator);
        return Optional.of(list.get(list.size() - 1));
    }

    public static <E> Optional<E> min(List<E> elements, Comparator<E> comparator) {
        List<E> list = new ArrayList<>();
        list.addAll(elements);
        list.sort(comparator);
        return Optional.of(list.get(0));
    }

    public static <E> List<E> distinct(List<E> elements) {
        List<E> list = new ArrayList<>();
        Set<E> set = new HashSet<>();
        set.addAll(elements);
        list.addAll(set);
        return list;
    }

    public static <E> void forEach(List<E> elements, Consumer<E> consumer) {
        for (E elem : elements) {
            consumer.accept(elem);
        }
    }

    public static <E> Optional<E> reduce(List<E> elements, BinaryOperator<E> accumulator) {
        E e = null;
        for (E elem : elements) {
            e = accumulator.apply(e, elem);
        }
        return Optional.of(e);
    }

    public static <E> E reduce(E seed, List<E> elements, BinaryOperator<E> accumulator) {
        E e = seed;
        for (E elem : elements) {
            e = accumulator.apply(e, elem);
        }
        return e;
    }

    public static <E> Map<Boolean, List<E>> partitionBy(List<E> elements, Predicate<E> predicate) {
        Map<Boolean, List<E>> map = new HashMap<>();
        map.put(Boolean.TRUE, new ArrayList<>());
        map.put(Boolean.FALSE, new ArrayList<>());
        for (E elem : elements) {
            map.get(predicate.test(elem)).add(elem);
        }
        return map;
    }

    public static <T, K> Map<K, List<T>> groupBy(List<T> elements, Function<T, K> classifier) {
        Map<K, List<T>> map = new HashMap<>();
        for (T elem : elements) {
            K key = classifier.apply(elem);
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }
            map.get(key).add(elem);
        }
        return map;
    }

    public static <T, K, U> Map<K, U> toMap(List<T> elements,
                                            Function<T, K> keyFunction,
                                            Function<T, U> valueFunction,
                                            BinaryOperator<U> mergeFunction) {
        Map<K, U> map = new HashMap<>();
        for (T elem : elements) {
            K key = keyFunction.apply(elem);
            if (map.containsKey(key)) {
                map.put(key, mergeFunction.apply(map.get(key), valueFunction.apply(elem)));
            } else {
                map.put(key, valueFunction.apply(elem));
            }
        }
        return map;
    }
}
 

Я только учусь
 
 
Сообщения:784
Приветствую!
Tachkin, зачем вы всё за топикстартера решили? Это может навредить, тем более человек на курсы пошёл.
 
 
Сообщения:184
То, что вы делаете - это не функционал стрима, а их видимость.
Главная фишка стримов - это ленивость и возможность параллельного выполнения.

Tachkin, не путай человека. Лямбды - это не синтаксический сахар. Конечно по началу разбираться в этом
нет необходиомсти, но все же надо помнить, что внутри есть нюансы.

"Мы же профессионалы! Мы всегда делаем чуть больше, чем требуется!" (с)
 
 
Сообщения:558
gidravlic:
Tachkin, зачем вы всё за топикстартера решили? Это может навредить, тем более человек на курсы пошёл.

Человек попросил показать все.
Ребят, как бы ветка "сделайте за меня", а не "подскажите в какую сторону смотреть".

MuH3gPaB:
Tachkin, не путай человека. Лямбды - это не синтаксический сахар. Конечно по началу разбираться в этом
нет необходиомсти, но все же надо помнить, что внутри есть нюансы.

Ок, есть нюансы, есть параллельность. А точно надо про это помнить, когда впревые столкнулся со стримами?

Я только учусь
 
 
Сообщения:2
gidravlic, здравствуйте, спасибо Вам за проявленный интерес и совет. Но к сожалению зашел в тупик при самостоятельном подходе (знания не поспевают за заданиями), понимаю что такой подход может навредить, но в этой ситуации лично для меня был очень и очень полезен.
Tachkin - Огромное спасибо Вам за помощь, это как раз то что требовалось по заданию, благодаря Вам "лёд" тронулся получилось понять подход к реализации методов, на понятном уровне для начинающих, без сложных подкапотных нюансов, что собственно и хотели видимо преподаватели для тех кто только пару дней как узнал про стримы))
 
 
Сообщения:184
Tachkin:
Ок, есть нюансы, есть параллельность. А точно надо про это помнить, когда впревые столкнулся со стримами?


Имхо! Прежде чем сталкиваться со стримами, хорошо бы понять как они работают и зачем их вообще сделали.
Вообще это можно сказать и про любые другие инструменты.

Но тут скорее камень в огород преподавателей, задание само по себе не особо приближает к пониманию функциональщины и стримов.

"Мы же профессионалы! Мы всегда делаем чуть больше, чем требуется!" (с)
 
Модераторы:alon4iknazicaTaky_
Сейчас эту тему просматривают:Нет