com.annimon.stream.EntryStream Maven / Gradle / Ivy
The newest version!
/** Eclipse Class Decompiler plugin, Copyright (c) 2017 Chen Chao. */
/*
* Copyright (C) 2017 HaiYang Li
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.annimon.stream;
import java.io.Closeable;
import java.util.AbstractMap;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import com.annimon.stream.function.BiConsumer;
import com.annimon.stream.function.BiFunction;
import com.annimon.stream.function.BiPredicate;
import com.annimon.stream.function.BinaryOperator;
import com.annimon.stream.function.Consumer;
import com.annimon.stream.function.Function;
import com.annimon.stream.function.Predicate;
import com.annimon.stream.function.Supplier;
/**
*
* @since 0.9
*
* @author Haiyang Li
*/
public final class EntryStream implements Closeable {
private static final Function, Stream>> mapper_func = new Function, Stream>>() {
@Override
public Stream> apply(Map t) {
return Stream.of(t);
}
};
@SuppressWarnings({ "rawtypes", "unchecked" })
private static final EntryStream EMPTY = new EntryStream(Stream. empty());
private final Stream> s;
@SuppressWarnings("unchecked")
EntryStream(final Stream> s) {
this.s = (Stream>) s;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
static Function, Stream>> mapFunc() {
return (Function) mapper_func;
}
@SuppressWarnings("unchecked")
public static EntryStream empty() {
return EMPTY;
}
public static EntryStream of(final Stream> s) {
return new EntryStream<>(s);
}
public static EntryStream of(final Iterator> iterator) {
return new EntryStream<>(Stream.of(iterator));
}
public static EntryStream of(final Map map) {
return new EntryStream<>(Stream.of(map));
}
public static EntryStream of(final Collection> entries) {
return new EntryStream<>(Stream.of(entries));
}
@SafeVarargs
public static EntryStream of(final Map.Entry... entries) {
return new EntryStream<>(Stream.of(entries));
}
public static EntryStream of(final Collection c, final Function keyExtractor) {
final Function valueMapper = Fn.identity();
return Stream.of(c).mapToEntry(keyExtractor, valueMapper);
}
public static EntryStream of(final T[] a, final Function keyExtractor) {
final Function valueMapper = Fn.identity();
return Stream.of(a).mapToEntry(keyExtractor, valueMapper);
}
@SafeVarargs
public static EntryStream concat(final Map... maps) {
final Function, Stream>> mapper = mapFunc();
return Stream.of(maps).flatMapToEntry(mapper);
}
public static EntryStream concat(final Collection> maps) {
final Function, Stream>> mapper = mapFunc();
return Stream.of(maps).flatMapToEntry(mapper);
}
public static EntryStream zip(final K[] keys, final V[] values) {
final BiFunction> zipFunction = new BiFunction>() {
@Override
public Entry apply(K k, V v) {
return new AbstractMap.SimpleImmutableEntry<>(k, v);
}
};
final Function, Map.Entry> mapper = Fn.identity();
return Stream.zip(keys, values, zipFunction).mapToEntry(mapper);
}
public static EntryStream zip(final Collection keys, final Collection values) {
final BiFunction> zipFunction = new BiFunction>() {
@Override
public Entry apply(K k, V v) {
return new AbstractMap.SimpleImmutableEntry<>(k, v);
}
};
final Function, Map.Entry> mapper = Fn.identity();
return Stream.zip(keys, values, zipFunction).mapToEntry(mapper);
}
public Stream keys() {
final Function, K> func = Fn.key();
return s.map(func);
}
public Stream values() {
final Function, V> func = Fn.value();
return s.map(func);
}
public Stream> entries() {
return s;
}
public EntryStream inversed() {
final Function, Map.Entry> mapper = new Function, Map.Entry>() {
@Override
public Entry apply(Entry e) {
return new AbstractMap.SimpleImmutableEntry<>(e.getValue(), e.getKey());
}
};
return map(mapper);
}
public EntryStream filter(final Predicate> predicate) {
return of(s.filter(predicate));
}
public EntryStream filter(final BiPredicate predicate) {
final Predicate> predicate2 = new Predicate>() {
@Override
public boolean test(Entry entry) {
return predicate.test(entry.getKey(), entry.getValue());
}
};
return of(s.filter(predicate2));
}
public EntryStream filterByKey(final Predicate keyPredicate) {
final Predicate> predicate = Fn.testByKey(keyPredicate);
return of(s.filter(predicate));
}
public EntryStream filterByValue(final Predicate valuePredicate) {
final Predicate> predicate = Fn.testByValue(valuePredicate);
return of(s.filter(predicate));
}
public EntryStream map(final Function, Map.Entry> mapper) {
return of(s.map(mapper));
}
public EntryStream map(final BiFunction> mapper) {
final Function, Map.Entry> mapper2 = new Function, Map.Entry>() {
@Override
public Entry apply(Map.Entry entry) {
return mapper.apply(entry.getKey(), entry.getValue());
}
};
return of(s.map(mapper2));
}
public EntryStream map(final Function keyMapper, final Function valueMapper) {
final Function, Map.Entry> mapper = new Function, Map.Entry>() {
@Override
public Entry apply(Entry t) {
return new AbstractMap.SimpleImmutableEntry<>(keyMapper.apply(t.getKey()), valueMapper.apply(t.getValue()));
}
};
return map(mapper);
}
public EntryStream mapKey(final Function keyMapper) {
final Function, Map.Entry> mapper = Fn.mapKey(keyMapper);
return of(s.map(mapper));
}
public EntryStream mapValue(final Function valueMapper) {
final Function, Map.Entry> mapper = Fn.mapValue(valueMapper);
return of(s.map(mapper));
}
// public EntryStream flatMap(final Function, EntryStream> mapper) {
// final Function, Stream>> mapper2 = new Function, Stream>>() {
// @Override
// public Stream> apply(Entry t) {
// return mapper.apply(t).s;
// }
// };
//
// return flatMap2(mapper2);
// }
public EntryStream flatMap(final Function, Stream>> mapper) {
return of(s.flatMap(mapper));
}
// public EntryStream flatMap3(final Function, Map> mapper) {
// final Function, Stream>> mapper2 = new Function, Stream>>() {
// @Override
// public Stream> apply(Entry t) {
// return Stream.of(mapper.apply(t));
// }
// };
//
// return flatMap2(mapper2);
// }
public EntryStream flatMapKey(final Function> keyMapper) {
final Function, Stream>> mapper2 = new Function, Stream>>() {
@Override
public Stream> apply(final Map.Entry e) {
return keyMapper.apply(e.getKey()).map(new Function>() {
@Override
public Map.Entry apply(KK kk) {
return new AbstractMap.SimpleImmutableEntry<>(kk, e.getValue());
}
});
}
};
return flatMap(mapper2);
}
public EntryStream flatMapValue(final Function> valueMapper) {
final Function, Stream>> mapper2 = new Function, Stream>>() {
@Override
public Stream> apply(final Entry e) {
return valueMapper.apply(e.getValue()).map(new Function>() {
@Override
public Map.Entry apply(VV vv) {
return new AbstractMap.SimpleImmutableEntry<>(e.getKey(), vv);
}
});
}
};
return flatMap(mapper2);
}
/**
*
* @param classifier
* @return
* @see Collectors#groupingBy(Function)
*/
public EntryStream> groupBy() {
final Function, K> classifier = Fn.key();
final Function, V> valueMapper = Fn.value();
final Collector, ?, List> collector = Collectors.mapping(valueMapper, Collectors. toList());
return of(s.groupBy(classifier, collector));
}
/**
*
* @param downstream
* @return
* @see Collectors#groupingBy(Function, Collector)
*/
public EntryStream groupBy(final Collector, A, D> downstream) {
final Function, K> classifier = Fn.key();
return of(s.groupBy(classifier, downstream));
}
/**
*
* @param downstream
* @param mapFactory
* @return
* @see Collectors#groupingBy(Function, Collector)
*/
public EntryStream groupBy(final Collector, A, D> downstream, final Supplier> mapFactory) {
final Function, K> classifier = Fn.key();
return of(s.groupBy(classifier, downstream, mapFactory));
}
/**
*
* @return
*/
public Map> groupTo() {
final Function, K> classifier = Fn.key();
final Function, V> valueMapper = Fn.value();
final Collector, ?, List> downstream = Collectors.mapping(valueMapper, Collectors. toList());
return s.groupTo(classifier, downstream);
}
/**
*
* @param downstream
* @return
*/
public Map groupTo(final Collector, A, D> downstream) {
final Function, K> classifier = Fn.key();
return s.groupTo(classifier, downstream);
}
/**
*
* @param downstream
* @param mapFactory
* @return
*/
public > M groupTo(final Collector, A, D> downstream, final Supplier mapFactory) {
final Function, K> classifier = Fn.key();
return s.groupTo(classifier, downstream, mapFactory);
}
public EntryStream sorted(final Comparator> comparator) {
return of(s.sorted(comparator));
}
public EntryStream sortedByKey(final Comparator keyComparator) {
final Comparator> comparator = Comparators.comparingByKey(keyComparator);
return of(s.sorted(comparator));
}
public EntryStream sortedByValue(final Comparator valueComparator) {
final Comparator> comparator = Comparators.comparingByValue(valueComparator);
return of(s.sorted(comparator));
}
public > EntryStream sortedBy(final Function, U> keyExtractor) {
return of(s.sortedBy(keyExtractor));
}
public EntryStream distinct() {
return of(s.distinct());
}
public EntryStream distinctByKey() {
final Function, K> keyExtractor = Fn.key();
return of(s.distinctBy(keyExtractor));
}
public EntryStream distinctByValue() {
final Function, V> keyExtractor = Fn.value();
return of(s.distinctBy(keyExtractor));
}
public EntryStream distinctBy(final Function, ?> keyExtractor) {
return of(s.distinctBy(keyExtractor));
}
public EntryStream skip(long n) {
return of(s.skip(n));
}
public EntryStream limit(long n) {
return of(s.limit(n));
}
public EntryStream peek(final Consumer> action) {
return of(s.peek(action));
}
public EntryStream peek(final BiConsumer action) {
final Consumer> action2 = new Consumer>() {
@Override
public void accept(Entry entry) {
action.accept(entry.getKey(), entry.getValue());
}
};
return of(s.peek(action2));
}
public void forEach(final Consumer> action) {
s.forEach(action);
}
public void forEach(final BiConsumer action) {
final Consumer> action2 = new Consumer>() {
@Override
public void accept(Entry entry) {
action.accept(entry.getKey(), entry.getValue());
}
};
s.forEach(action2);
}
public int count() {
return s.count();
}
public Iterator> iterator() {
return s.iterator();
}
/**
*
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
*/
public Map toMap() {
final Function, K> keyMapper = Fn.key();
final Function, V> valueMapper = Fn.value();
return s.toMap(keyMapper, valueMapper);
}
/**
*
* @param mapFactory
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
*/
public Map toMap(final BinaryOperator mergeFunction) {
final Function, K> keyMapper = Fn.key();
final Function, V> valueMapper = Fn.value();
return s.toMap(keyMapper, valueMapper, mergeFunction);
}
/**
*
* @param mapFactory
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
*/
public > M toMap(final Supplier mapFactory) {
final Function, K> keyMapper = Fn.key();
final Function, V> valueMapper = Fn.value();
return s.toMap(keyMapper, valueMapper, mapFactory);
}
/**
* @param mergeFunction
* @param mapFactory
* @return
* @see Collectors#toMap(Function, Function, BinaryOperator, Supplier)
*/
public > M toMap(final BinaryOperator mergeFunction, final Supplier mapFactory) {
final Function, K> keyMapper = Fn.key();
final Function, V> valueMapper = Fn.value();
return s.toMap(keyMapper, valueMapper, mergeFunction, mapFactory);
}
public Optional> reduce(final BinaryOperator> accumulator) {
return s.reduce(accumulator);
}
public U reduce(final U identity, final BiFunction, U> accumulator) {
return s.reduce(identity, accumulator);
}
public R collect(final Supplier supplier, final BiConsumer> accumulator) {
return s.collect(supplier, accumulator);
}
public R collect(final Collector, A, R> collector) {
return s.collect(collector);
}
public EntryStream chain(Function>, ? extends Stream>> transfer) {
return of(transfer.apply(s));
}
public R __(Function, R> transfer) {
return transfer.apply(this);
}
public void println() {
s.println();
}
public EntryStream onClose(Runnable closeHandler) {
return of(s.onClose(closeHandler));
}
@Override
public void close() {
s.close();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy