@Override public Flow<T> reverse() { if (values.length < 2) return this; List<T> newValues = new ArrayList<T>(); newValues.addAll(Arrays.asList(values)); Collections.reverse(newValues); return new ArrayFlow<T>(newValues); }
@Override public Flow<T> reverse() { if (values.length < 2) return this; List<T> newValues = new ArrayList<T>(); newValues.addAll(Arrays.asList(values)); Collections.reverse(newValues); return new ArrayFlow<T>(newValues); }
@Override public Flow<T> take(int length) { if (length < 1) return F.emptyFlow(); return new ArrayFlow<T>(values, start, Math.min(count, length)); }
@Override public Flow<T> drop(int length) { assert length >= 0; if (length == 0) return this; if (length >= count) return F.emptyFlow(); return new ArrayFlow<T>(values, start + length, count - length); } }
@Override public Flow<T> sort(Comparator<T> comparator) { assert comparator != null; if (values.length < 2) return this; List<T> newValues = toMutableList(); Collections.sort(newValues, comparator); return new ArrayFlow<T>(newValues); }
/** * Creates a new Flow from the values. You should not change the values array * after invoking this method (i.e., no defensive copy of the values is made). */ public static <T> Flow<T> flow(T... values) { if (values.length == 0) return emptyFlow(); return new ArrayFlow<T>(values); }
@Override public Flow<T> drop(int length) { assert length >= 0; if (length == 0) return this; if (length >= count) return F.emptyFlow(); return new ArrayFlow<T>(values, start + length, count - length); } }
@Override public Flow<T> sort(Comparator<T> comparator) { assert comparator != null; if (values.length < 2) return this; List<T> newValues = toMutableList(); Collections.sort(newValues, comparator); return new ArrayFlow<T>(newValues); }
@Override public Flow<T> take(int length) { if (length < 1) return F.emptyFlow(); return new ArrayFlow<T>(values, start, Math.min(count, length)); }
@Override @SuppressWarnings("unchecked") public Flow<T> sort() { if (values.length < 2) return this; List<Comparable> newValues = (List<Comparable>) toMutableList(); Collections.sort(newValues); return new ArrayFlow<T>((List<T>) newValues); }
private Flow<T> buildRest() { if (count < 2) return F.emptyFlow(); return new ArrayFlow<T>(values, start + 1, count - 1); }
/** * Extracts the values from the collection to form a {@link Flow}. The Collection * may change after the Flow is created without affecting the Flow. */ public static <T> Flow<T> flow(Collection<T> values) { assert values != null; if (values.isEmpty()) return emptyFlow(); return new ArrayFlow<T>(values); }
private Flow<T> buildRest() { if (count < 2) return F.emptyFlow(); return new ArrayFlow<T>(values, start + 1, count - 1); }
/** * Creates a new Flow from the values. You should not change the values array * after invoking this method (i.e., no defensive copy of the values is made). */ public static <T> Flow<T> flow(T... values) { if (values.length == 0) return emptyFlow(); return new ArrayFlow<T>(values); }
@Override public Flow<T> reverse() { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).reverse(); }
@Override public Flow<T> sort() { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).sort(); }
@Override public Flow<T> sort() { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).sort(); }
@Override public Flow<T> sort(Comparator<T> comparator) { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).sort(comparator); }
@Override public Flow<T> sort(Comparator<T> comparator) { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).sort(comparator); }
@Override public Flow<T> reverse() { if (isEmpty()) return F.emptyFlow(); return new ArrayFlow<T>(this).reverse(); }