klemek/BetterLists
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BetterLists 1.3

Browse Source
This commit is contained in:
Klemek
2018-06-18 14:54:05 +02:00
parent c8e15e0943
commit c9f641a4a4
9 changed files with 955 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+13 -3
View File
@@ -4,7 +4,7 @@ An extension of the java.util.List interface which include some of the C# LINQ u
List classes are extended as well. (ArrayList -> BetterArrayList) List classes are extended as well. (ArrayList -> BetterArrayList)
Current version v1.2 Current version v1.3
Before BetterLists : Before BetterLists :
```Java ```Java
@@ -30,7 +30,7 @@ NOTE : Please note that, unlike C# LINQ, these functions are not optimized at lo
## Download ## Download
* [betterlists-1.2.jar](../../raw/master/download/betterlists-1.2.jar) * [betterlists-1.3.jar](../../raw/master/download/betterlists-1.3.jar)
## Maven ## Maven
@@ -49,7 +49,7 @@ You can use this project as a maven dependency with this :
<dependency> <dependency>
<groupId>klemek</groupId> <groupId>klemek</groupId>
<artifactId>betterlists</artifactId> <artifactId>betterlists</artifactId>
<version>1.2</version> <version>1.3</version>
</dependency> </dependency>
</dependencies> </dependencies>
``` ```
@@ -71,6 +71,7 @@ You can use this project as a maven dependency with this :
| [orderBy / orderByDescending](#orderby-orderbydescending) | Sorts the elements of a sequence in ascending order by using a specified comparator. (You can user orderByDescending to change the order) | | [orderBy / orderByDescending](#orderby-orderbydescending) | Sorts the elements of a sequence in ascending order by using a specified comparator. (You can user orderByDescending to change the order) |
| [reverse](#reverse) | Inverts the order of the elements in the sequence. | | [reverse](#reverse) | Inverts the order of the elements in the sequence. |
| [select](#select) | Projects each element of a sequence into a new form. | | [select](#select) | Projects each element of a sequence into a new form. |
| [selectMany](#selectmany) | Projects each element of a sequence into a new list and flattens the resulting sequences into one sequence. |
| [skip / skipWhile](#skip-skipwhile) | Bypasses elements in the sequence as long as a specified condition is true and then returns the remaining elements. | | [skip / skipWhile](#skip-skipwhile) | Bypasses elements in the sequence as long as a specified condition is true and then returns the remaining elements. |
| [sum](#sum) | Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence. | | [sum](#sum) | Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence. |
| [take / takeWhile](#take-takewhile) | Returns a specified number of contiguous elements from the start of the sequence. | | [take / takeWhile](#take-takewhile) | Returns a specified number of contiguous elements from the start of the sequence. |
@@ -177,6 +178,15 @@ BetterArrayList<Contact> contacts = BetterArrayList.fromList(someFunction());
BetterList<String> contactsMails = contacts.select(c -> c.getEmail()); BetterList<String> contactsMails = contacts.select(c -> c.getEmail());
``` ```
### selectMany
Projects each element of a sequence into a new list and flattens the resulting sequences into one sequence.
```Java
BetterArrayList<Contact> contacts = BetterArrayList.fromList(someFunction());
BetterList<String> contactsMails = contacts.select(c -> c.getEmail().split(";"));
```
### skip / skipWhile ### skip / skipWhile
Bypasses elements in the sequence as long as a specified condition is true and then returns the remaining elements. Bypasses elements in the sequence as long as a specified condition is true and then returns the remaining elements.
```Java ```Java
download/betterlists-1.3.jar
BIN
View File
Binary file not shown.
src/fr/klemek/betterlists/BetterArrayList.java
+48 -55
View File
@@ -7,25 +7,23 @@ import java.util.Collection;
/** /**
* An extension of the java.util.ArrayList class which include some of the C# * An extension of the java.util.ArrayList class which include some of the C#
* LINQ useful functions. * LINQ useful functions.
*
* @author Klemek
* *
* @author Klemek
* @see java.util.ArrayList * @see java.util.ArrayList
*/ */
public class BetterArrayList<T> extends ArrayList<T> implements BetterList<T> { public class BetterArrayList<T> extends ArrayList<T> implements BetterList<T> {
private static final long serialVersionUID = 4772544470059394618L; private static final long serialVersionUID = 4772544470059394618L;
/** /**
* Constructs a list containing the elements of the specified collection, in the * Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator. * order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this list
* - the collection whose elements are to be placed into this list */
*/ public static <T> BetterArrayList<T> fromList(Collection<T> c) {
public static <T> BetterArrayList<T> fromList(Collection<T> c) { return new BetterArrayList<>(c);
return new BetterArrayList<>(c); }
}
/** /**
* Constructs a list containing the elements given in argument. * Constructs a list containing the elements given in argument.
@@ -36,29 +34,27 @@ public class BetterArrayList<T> extends ArrayList<T> implements BetterList<T> {
return new BetterArrayList<>(a); return new BetterArrayList<>(a);
} }
/** /**
* Constructs an empty list with an initial capacity of ten. * Constructs an empty list with an initial capacity of ten.
*/ */
public BetterArrayList() { public BetterArrayList() {
super(); super();
} }
/** /**
* Constructs a list containing the elements of the specified collection, in the * Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator. * order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this list
* - the collection whose elements are to be placed into this list */
*/ public BetterArrayList(Collection<? extends T> c) {
public BetterArrayList(Collection<? extends T> c) { super(c);
super(c); }
}
/** /**
* Constructs a list containing the elements given in argument. * Constructs a list containing the elements given in argument.
* *
* @param a * @param a - the elements to be placed into this list
* - the elements to be placed into this list
*/ */
public BetterArrayList(T... a) { public BetterArrayList(T... a) {
super(Arrays.asList(a)); super(Arrays.asList(a));
@@ -73,29 +69,26 @@ public class BetterArrayList<T> extends ArrayList<T> implements BetterList<T> {
super(initialCapacity); super(initialCapacity);
} }
/** /**
* Returns a view of the portion of this list between the specified fromIndex, * Returns a view of the portion of this list between the specified fromIndex,
* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the * inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the
* returned list is empty.) The returned list is backed by this list, so * returned list is empty.) The returned list is backed by this list, so
* non-structural changes in the returned list are reflected in this list, and * non-structural changes in the returned list are reflected in this list, and
* vice-versa. The returned list supports all of the optional list operations * vice-versa. The returned list supports all of the optional list operations
* supported by this list. This method eliminates the need for explicit range * supported by this list. This method eliminates the need for explicit range
* operations (of the sort that commonly exist for arrays). Any operation that * operations (of the sort that commonly exist for arrays). Any operation that
* expects a list can be used as a range operation by passing a subList view * expects a list can be used as a range operation by passing a subList view
* instead of a whole list. (see List.subList) * instead of a whole list. (see List.subList)
* *
* @param fromIndex * @param fromIndex - low endpoint (inclusive) of the subList
* - low endpoint (inclusive) of the subList * @param toIndex - high endpoint (exclusive) of the subList
* @param toIndex * @return a view of the specified range within this list
* - high endpoint (exclusive) of the subList * @throws IndexOutOfBoundsException for an illegal endpoint index value (fromIndex < 0 || toIndex >
* @return a view of the specified range within this list * size || fromIndex > toIndex)
* @throws IndexOutOfBoundsException * @see java.util.List
* for an illegal endpoint index value (fromIndex < 0 || toIndex > */
* size || fromIndex > toIndex) @Override
* @see java.util.List public BetterArrayList<T> subList(int fromIndex, int toIndex) {
*/
@Override
public BetterArrayList<T> subList(int fromIndex, int toIndex) {
return (BetterArrayList<T>) super.subList(fromIndex, toIndex); return (BetterArrayList<T>) super.subList(fromIndex, toIndex);
} }
} }
src/fr/klemek/betterlists/BetterCopyOnWriteArrayList.java
+86
View File
@@ -0,0 +1,86 @@
package fr.klemek.betterlists;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* An extension of the java.concurrent.CopyOnWriteArrayList class which include some of the C#
* LINQ useful functions.
*
* @author Klemek
* @see ArrayList
*/
public class BetterCopyOnWriteArrayList<T> extends CopyOnWriteArrayList<T> implements BetterList<T> {
private static final long serialVersionUID = -1148672915754560195L;
/**
* Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator.
*
* @param c - the collection whose elements are to be placed into this list
*/
public static <T> BetterCopyOnWriteArrayList<T> fromList(Collection<T> c) {
return new BetterCopyOnWriteArrayList<>(c);
}
/**
* Constructs a list containing the elements given in argument.
*
* @param a - the elements to be placed into this list
*/
public static <T> BetterCopyOnWriteArrayList<T> asList(T... a) {
return new BetterCopyOnWriteArrayList<>(a);
}
/**
* Constructs an empty list with an initial capacity of ten.
*/
public BetterCopyOnWriteArrayList() {
super();
}
/**
* Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator.
*
* @param c - the collection whose elements are to be placed into this list
*/
public BetterCopyOnWriteArrayList(Collection<? extends T> c) {
super(c);
}
/**
* Constructs a list containing the elements given in argument.
*
* @param a - the elements to be placed into this list
*/
public BetterCopyOnWriteArrayList(T... a) {
super(Arrays.asList(a));
}
/**
* Returns a view of the portion of this list between the specified fromIndex,
* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the
* returned list is empty.) The returned list is backed by this list, so
* non-structural changes in the returned list are reflected in this list, and
* vice-versa. The returned list supports all of the optional list operations
* supported by this list. This method eliminates the need for explicit range
* operations (of the sort that commonly exist for arrays). Any operation that
* expects a list can be used as a range operation by passing a subList view
* instead of a whole list. (see List.subList)
*
* @param fromIndex - low endpoint (inclusive) of the subList
* @param toIndex - high endpoint (exclusive) of the subList
* @return a view of the specified range within this list
* @throws IndexOutOfBoundsException for an illegal endpoint index value (fromIndex < 0 || toIndex >
* size || fromIndex > toIndex)
* @see java.util.List
*/
@Override
public BetterCopyOnWriteArrayList<T> subList(int fromIndex, int toIndex) {
return (BetterCopyOnWriteArrayList<T>) super.subList(fromIndex, toIndex);
}
}
src/fr/klemek/betterlists/BetterLinkedList.java
+28 -32
View File
@@ -7,25 +7,23 @@ import java.util.LinkedList;
/** /**
* An extension of the java.util.LinkedList class which include some of the C# * An extension of the java.util.LinkedList class which include some of the C#
* LINQ useful functions. * LINQ useful functions.
*
* @author Klemek
* *
* @author Klemek
* @see java.util.LinkedList * @see java.util.LinkedList
*/ */
public class BetterLinkedList<T> extends LinkedList<T> implements BetterList<T> { public class BetterLinkedList<T> extends LinkedList<T> implements BetterList<T> {
private static final long serialVersionUID = 4837198308074701770L; private static final long serialVersionUID = 4837198308074701770L;
/** /**
* Constructs a list containing the elements of the specified collection, in the * Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator. * order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this list
* - the collection whose elements are to be placed into this list */
*/ public static <T> BetterLinkedList<T> fromList(Collection<T> c) {
public static <T> BetterLinkedList<T> fromList(Collection<T> c) { return new BetterLinkedList<>(c);
return new BetterLinkedList<>(c); }
}
/** /**
* Constructs a list containing the elements given in argument. * Constructs a list containing the elements given in argument.
@@ -36,29 +34,27 @@ public class BetterLinkedList<T> extends LinkedList<T> implements BetterList<T>
return new BetterLinkedList<>(a); return new BetterLinkedList<>(a);
} }
/** /**
* Constructs an empty list. * Constructs an empty list.
*/ */
public BetterLinkedList() { public BetterLinkedList() {
super(); super();
} }
/** /**
* Constructs a list containing the elements of the specified collection, in the * Constructs a list containing the elements of the specified collection, in the
* order they are returned by the collection's iterator. * order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this list
* - the collection whose elements are to be placed into this list */
*/ public BetterLinkedList(Collection<? extends T> c) {
public BetterLinkedList(Collection<? extends T> c) { super(c);
super(c); }
}
/** /**
* Constructs a list containing the elements given in argument. * Constructs a list containing the elements given in argument.
* *
* @param a * @param a - the elements to be placed into this list
* - the elements to be placed into this list
*/ */
public BetterLinkedList(T... a) { public BetterLinkedList(T... a) {
super(Arrays.asList(a)); super(Arrays.asList(a));
src/fr/klemek/betterlists/BetterList.java
+380 -395
View File
@@ -1,456 +1,441 @@
package fr.klemek.betterlists; package fr.klemek.betterlists;
import java.util.Collections; import java.util.*;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.function.Function; import java.util.function.Function;
/** /**
* An extension of the java.util.List interface which include some of the C# * An extension of the java.util.List interface which include some of the C#
* LINQ useful functions. * LINQ useful functions.
*
* @author Klemek
* *
* @author Klemek
* @see java.util.List * @see java.util.List
*/ */
public interface BetterList<T> extends List<T> { public interface BetterList<T> extends List<T> {
/** /**
* Determines whether all elements of the sequence satisfy a condition. * Determines whether all elements of the sequence satisfy a condition.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return true if every element of the source sequence passes the test in the
* @return true if every element of the source sequence passes the test in the * specified predicate, or if the sequence is empty; otherwise, false.
* specified predicate, or if the sequence is empty; otherwise, false. */
*/ default boolean all(Function<T, Boolean> predicate) {
public default boolean all(Function<T, Boolean> predicate) { for (T element : this)
for (T element : this) if (!predicate.apply(element))
if (!predicate.apply(element)) return false;
return false; return true;
return true; }
}
/** /**
* Determines whether any element of the sequence satisfies a condition. * Determines whether any element of the sequence satisfies a condition.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return true if any elements in the source sequence pass the test in the
* @return true if any elements in the source sequence pass the test in the * specified predicate; otherwise, false.
* specified predicate; otherwise, false. */
*/
default boolean any(Function<T, Boolean> predicate) { default boolean any(Function<T, Boolean> predicate) {
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
return true; return true;
return false; return false;
} }
/** /**
* Returns the number of elements in the sequence. * Returns the number of elements in the sequence.
* *
* @return The number of elements in the input sequence. * @return The number of elements in the input sequence.
*/ */
default int count() { default int count() {
return count(e -> true); return count(e -> true);
} }
/** /**
* Returns a number that represents how many elements in the specified sequence * Returns a number that represents how many elements in the specified sequence
* satisfy a condition. * satisfy a condition.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return A number that represents how many elements in the sequence satisfy
* @return A number that represents how many elements in the sequence satisfy * the condition in the predicate function.
* the condition in the predicate function. */
*/
default int count(Function<T, Boolean> predicate) { default int count(Function<T, Boolean> predicate) {
int out = 0; int out = 0;
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
out++; out++;
return out; return out;
} }
/** /**
* Produces the set exclusion of two sequences. * Produces the set exclusion of two sequences.
* *
* @param other * @param other - Another List whose distinct elements form the second set for the
* - Another List whose distinct elements form the second set for the * exclusion.
* exclusion. * @return A List that contains the elements from the first sequence not present
* @return A List that contains the elements from the first sequence not present * in the other.
* in the other. */
*/
default BetterList<T> exclusion(List<T> other) { default BetterList<T> exclusion(List<T> other) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
for (T element : this) for (T element : this)
if (!other.contains(element)) if (!other.contains(element))
out.add(element); out.add(element);
return out; return out;
} }
/** /**
* Returns the first element in the sequence. * Returns the first element in the sequence.
* *
* @throws NoSuchElementException * @return The first element in the sequence.
* If the sequence is empty. * @throws NoSuchElementException If the sequence is empty.
* @return The first element in the sequence. */
*/
default T first() { default T first() {
return first(e -> true); return first(e -> true);
} }
/** /**
* Returns the first element in the sequence that satisfies a specified * Returns the first element in the sequence that satisfies a specified
* condition. * condition.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return The first element in the sequence that passes the test in the
* @throws NoSuchElementException * specified predicate function.
* No element satisfies the condition in predicate or the sequence * @throws NoSuchElementException No element satisfies the condition in predicate or the sequence
* is empty. * is empty.
* @return The first element in the sequence that passes the test in the */
* specified predicate function.
*/
default T first(Function<T, Boolean> predicate) { default T first(Function<T, Boolean> predicate) {
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
return element; return element;
throw new NoSuchElementException(); throw new NoSuchElementException();
} }
/** /**
* Returns the first element of the sequence that satisfies a condition or the * Returns the first element of the sequence that satisfies a condition or the
* default value if no such element is found. * default value if no such element is found.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @param defaultValue - A default value to be returned if no element passes the test
* @param defaultValue * @return defaultValue if the sequence is empty or if no element passes the
* - A default value to be returned if no element passes the test * test specified by predicate; otherwise, the first element in the
* @return defaultValue if the sequence is empty or if no element passes the * sequence that passes the test specified by predicate.
* test specified by predicate; otherwise, the first element in the */
* sequence that passes the test specified by predicate.
*/
default T firstOrDefault(Function<T, Boolean> predicate, T defaultValue) { default T firstOrDefault(Function<T, Boolean> predicate, T defaultValue) {
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
return element; return element;
return defaultValue; return defaultValue;
} }
/** /**
* Returns the first element of the sequence or a default value if the sequence * Returns the first element of the sequence or a default value if the sequence
* is empty. * is empty.
* *
* @param defaultValue * @param defaultValue - A default value to be returned if the sequence is empty
* - A default value to be returned if the sequence is empty * @return defaultValue if the sequence is empty otherwise, the first element in
* @return defaultValue if the sequence is empty otherwise, the first element in * the sequence.
* the sequence. */
*/
default T firstOrDefault(T defaultValue) { default T firstOrDefault(T defaultValue) {
return firstOrDefault(e -> true, defaultValue); return firstOrDefault(e -> true, defaultValue);
} }
/** /**
* Returns the last element of the sequence. * Returns the last element of the sequence.
* *
* @throws NoSuchElementException * @return the last element of the sequence.
* If the sequence is empty. * @throws NoSuchElementException If the sequence is empty.
* @return the last element of the sequence. */
*/
default T last() { default T last() {
return last(e -> true); return last(e -> true);
} }
/** /**
* Returns the last element of the sequence that satisfies a specified * Returns the last element of the sequence that satisfies a specified
* condition. * condition.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return the last element of the sequence that satisfies a specified
* @throws NoSuchElementException * condition.
* No element satisfies the condition in predicate or the sequence * @throws NoSuchElementException No element satisfies the condition in predicate or the sequence
* is empty. * is empty.
* @return the last element of the sequence that satisfies a specified */
* condition.
*/
default T last(Function<T, Boolean> predicate) { default T last(Function<T, Boolean> predicate) {
T value = null; T value = null;
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
value = element; value = element;
if (value == null) if (value == null)
throw new NoSuchElementException(); throw new NoSuchElementException();
return value; return value;
} }
/** /**
* Returns the last element of the sequence that satisfies a condition or the * Returns the last element of the sequence that satisfies a condition or the
* default value if no such element is found. * default value if no such element is found.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @param defaultValue - A default value to be returned if no element passes the test
* @param defaultValue * @return defaultValue if the sequence is empty or if no element passes the
* - A default value to be returned if no element passes the test * test specified by predicate; otherwise, the last element in the
* @return defaultValue if the sequence is empty or if no element passes the * sequence that passes the test specified by predicate.
* test specified by predicate; otherwise, the last element in the */
* sequence that passes the test specified by predicate.
*/
default T lastOrDefault(Function<T, Boolean> predicate, T defaultValue) { default T lastOrDefault(Function<T, Boolean> predicate, T defaultValue) {
T value = null; T value = null;
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
value = element; value = element;
return value == null ? defaultValue : value; return value == null ? defaultValue : value;
} }
/** /**
* Returns the last element of the sequence or a default value if the sequence * Returns the last element of the sequence or a default value if the sequence
* is empty. * is empty.
* *
* @param defaultValue * @param defaultValue - A default value to be returned if the sequence is empty
* - A default value to be returned if the sequence is empty * @return defaultValue if the sequence is empty otherwise, the last element in
* @return defaultValue if the sequence is empty otherwise, the last element in * the sequence.
* the sequence. */
*/
default T lastOrDefault(T defaultValue) { default T lastOrDefault(T defaultValue) {
return lastOrDefault(e -> true, defaultValue); return lastOrDefault(e -> true, defaultValue);
} }
/** /**
* Invokes a transform function on each element of the sequence and returns the * Invokes a transform function on each element of the sequence and returns the
* maximum nullable Double value. * maximum nullable Double value.
* *
* @param selector * @param selector - A transform function to apply to each element.
* - A transform function to apply to each element. * @return The value of type Double that corresponds to the maximum value in the
* @return The value of type Double that corresponds to the maximum value in the * sequence or null if the sequence is empty.
* sequence or null if the sequence is empty. */
*/
default Double max(Function<T, Double> selector) { default Double max(Function<T, Double> selector) {
Double max = null; Double max = null;
for (T element : this) for (T element : this)
if (max == null || selector.apply(element) > max) if (max == null || selector.apply(element) > max)
max = selector.apply(element); max = selector.apply(element);
return max; return max;
} }
/** /**
* Computes the mean of the sequence of Double values that are obtained by * Computes the mean of the sequence of Double values that are obtained by
* invoking a transform function on each element of the input sequence. * invoking a transform function on each element of the input sequence.
* *
* @param selector * @param selector - A transform function to apply to each element.
* - A transform function to apply to each element. * @return The mean of the projected values. Null if the sequence contains no
* @return The mean of the projected values. Null if the sequence contains no * elements.
* elements. */
*/
default Double mean(Function<T, Double> selector) { default Double mean(Function<T, Double> selector) {
int count = this.count(); int count = this.count();
if (count == 0) if (count == 0)
return null; return null;
return this.sum(selector) / this.count(); return this.sum(selector) / this.count();
} }
/** /**
* Invokes a transform function on each element of the sequence and returns the * Invokes a transform function on each element of the sequence and returns the
* minimum nullable Double value. * minimum nullable Double value.
* *
* @param selector * @param selector - A transform function to apply to each element.
* - A transform function to apply to each element. * @return The value of type Double that corresponds to the minimum value in the
* @return The value of type Double that corresponds to the minimum value in the * sequence or null if the sequence is empty.
* sequence or null if the sequence is empty. */
*/
default Double min(Function<T, Double> selector) { default Double min(Function<T, Double> selector) {
Double min = null; Double min = null;
for (T element : this) for (T element : this)
if (min == null || selector.apply(element) < min) if (min == null || selector.apply(element) < min)
min = selector.apply(element); min = selector.apply(element);
return min; return min;
} }
/** /**
* Sorts the elements of a sequence in ascending order by using a specified comparer. * Sorts the elements of a sequence in ascending order by using a specified comparer.
* @param selector *
* - A transform function to apply to each element. * @param selector - A transform function to apply to each element.
* @return a List whose elements are sorted according to a key. * @return a List whose elements are sorted according to a key.
*/ */
default <E extends Comparable<E>> BetterList<T> orderBy(Function<T, E> selector) { default <E extends Comparable<E>> BetterList<T> orderBy(Function<T, E> selector) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
out.addAll(this); out.addAll(this);
Collections.sort(out, (o1,o2) -> selector.apply(o1).compareTo(selector.apply(o2))); Collections.sort(out, (o1, o2) -> selector.apply(o1).compareTo(selector.apply(o2)));
return out; return out;
} }
/** /**
* Sorts the elements of a sequence in descending order by using a specified comparer. * Sorts the elements of a sequence in descending order by using a specified comparer.
* @param selector *
* - A transform function to apply to each element. * @param selector - A transform function to apply to each element.
* @return a List whose elements are sorted according to a key. * @return a List whose elements are sorted according to a key.
*/ */
default <E extends Comparable<E>> BetterList<T> orderByDescending(Function<T, E> selector) { default <E extends Comparable<E>> BetterList<T> orderByDescending(Function<T, E> selector) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
out.addAll(this); out.addAll(this);
Collections.sort(out, (o1,o2) -> selector.apply(o2).compareTo(selector.apply(o1))); Collections.sort(out, (o1, o2) -> selector.apply(o2).compareTo(selector.apply(o1)));
return out; return out;
} }
/** /**
* Inverts the order of the elements in the sequence. * Inverts the order of the elements in the sequence.
* *
* @return A sequence whose elements correspond to those of the sequence in * @return A sequence whose elements correspond to those of the sequence in
* reverse order. * reverse order.
*/ */
default BetterList<T> reverse() { default BetterList<T> reverse() {
BetterList<T> out = new BetterArrayList<>(this.size()); BetterList<T> out = new BetterArrayList<>(this.size());
for (T element : this) for (T element : this)
out.add(0, element); out.add(0, element);
return out; return out;
} }
/** /**
* Projects each element of a sequence into a new form. * Projects each element of a sequence into a new form.
* *
* @param <E> * @param <E> The type of the projected values
* The type of the projected values * @param selector - A transform function to apply to each element.
* @param selector * @return A List whose elements are the result of invoking the transform
* - A transform function to apply to each element. * function on each element of the sequence.
* @return A List whose elements are the result of invoking the transform */
* function on each element of the sequence.
*/
default <E> BetterList<E> select(Function<T, E> selector) { default <E> BetterList<E> select(Function<T, E> selector) {
BetterList<E> out = new BetterArrayList<>(); BetterList<E> out = new BetterArrayList<>();
for (T element : this) for (T element : this)
out.add(selector.apply(element)); out.add(selector.apply(element));
return out; return out;
} }
/** /**
* Bypasses a specified number of elements in the sequence and then returns the * Projects each element of a sequence into a new list and flattens the
* remaining elements. * resulting sequences into one sequence.
* *
* @param count * @param <E> The type of the projected values lists
* - The number of elements to skip before returning the remaining * @param selector - A transform function to apply to each element.
* elements. * @return A List whose elements are the result of invoking the one-to-many
* @return a List that contains the elements that occur after the specified * transform function on each element of the input sequence.
* index in the sequence. */
*/ default <E> BetterList<E> selectMany(Function<T, E[]> selector) {
BetterList<E> out = new BetterArrayList<>();
for (T element : this)
out.addAll(Arrays.asList(selector.apply(element)));
return out;
}
/**
* Bypasses a specified number of elements in the sequence and then returns the
* remaining elements.
*
* @param count - The number of elements to skip before returning the remaining
* elements.
* @return a List that contains the elements that occur after the specified
* index in the sequence.
*/
default BetterList<T> skip(int count) { default BetterList<T> skip(int count) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
int n = 0; int n = 0;
for (T element : this) { for (T element : this) {
if (n >= count) if (n >= count)
out.add(element); out.add(element);
n++; n++;
} }
return out; return out;
} }
/** /**
* Bypasses elements in the sequence as long as a specified condition is true * Bypasses elements in the sequence as long as a specified condition is true
* and then returns the remaining elements. * and then returns the remaining elements.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return a List that contains the elements from the sequence starting at the
* @return a List that contains the elements from the sequence starting at the * first element in the linear series that does not pass the test
* first element in the linear series that does not pass the test * specified by predicate.
* specified by predicate. */
*/
default BetterList<T> skipWhile(Function<T, Boolean> predicate) { default BetterList<T> skipWhile(Function<T, Boolean> predicate) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
boolean match = true; boolean match = true;
for (T element : this) for (T element : this)
if (!match || !predicate.apply(element)) { if (!match || !predicate.apply(element)) {
match = false; match = false;
out.add(element); out.add(element);
} }
return out; return out;
} }
/** /**
* Computes the sum of the sequence of Double values that are obtained by * Computes the sum of the sequence of Double values that are obtained by
* invoking a transform function on each element of the input sequence. * invoking a transform function on each element of the input sequence.
* *
* @param selector * @param selector - A transform function to apply to each element.
* - A transform function to apply to each element. * @return The sum of the projected values. Zero if the sequence contains no
* @return The sum of the projected values. Zero if the sequence contains no * elements.
* elements. */
*/
default Double sum(Function<T, Double> selector) { default Double sum(Function<T, Double> selector) {
double sum = 0d; double sum = 0d;
for (T element : this) for (T element : this)
sum += selector.apply(element); sum += selector.apply(element);
return sum; return sum;
} }
/** /**
* Returns a specified number of contiguous elements from the start of the * Returns a specified number of contiguous elements from the start of the
* sequence. * sequence.
* *
* @param count * @param count - The number of elements to return.
* - The number of elements to return. * @return a List that contains the specified number of elements from the start
* @return a List that contains the specified number of elements from the start * of the input sequence.
* of the input sequence. */
*/
default BetterList<T> take(int count) { default BetterList<T> take(int count) {
BetterList<T> out = new BetterArrayList<>(count); BetterList<T> out = new BetterArrayList<>(count);
int n = 0; int n = 0;
for (T element : this) { for (T element : this) {
if (n < count) if (n < count)
out.add(element); out.add(element);
else else
break; break;
n++; n++;
} }
return out; return out;
} }
/** /**
* Returns elements from the sequence as long as a specified condition is true. * Returns elements from the sequence as long as a specified condition is true.
* *
* @param predicate * @param predicate - A function to test each element for a condition.
* - A function to test each element for a condition. * @return a List that contains the elements from the sequence that occur before
* @return a List that contains the elements from the sequence that occur before * the element at which the test no longer passes.
* the element at which the test no longer passes. */
*/
default BetterList<T> takeWhile(Function<T, Boolean> predicate) { default BetterList<T> takeWhile(Function<T, Boolean> predicate) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
out.add(element); out.add(element);
else else
break; break;
return out; return out;
} }
/**
* Produces the set union of two sequences.
*
* @param other
* - Another List whose distinct elements form the second set for the
* union.
* @return A List that contains the elements from both sequences, excluding
* duplicates.
*/
default BetterList<T> union(List<T> other) {
BetterList<T> out = new BetterArrayList<>();
for (T element : this)
if (other.contains(element))
out.add(element);
return out;
}
/** /**
* Filters a sequence of values based on a predicate. * Produces the set union of two sequences.
* *
* @param predicate * @param other - Another List whose distinct elements form the second set for the
* - A function to test each element for a condition. * union.
* @return a List that contains elements from the sequence that satisfy the * @return A List that contains the elements from both sequences, excluding
* condition. * duplicates.
*/ */
default BetterList<T> union(List<T> other) {
BetterList<T> out = new BetterArrayList<>();
for (T element : this)
if (other.contains(element))
out.add(element);
return out;
}
/**
* Filters a sequence of values based on a predicate.
*
* @param predicate - A function to test each element for a condition.
* @return a List that contains elements from the sequence that satisfy the
* condition.
*/
default BetterList<T> where(Function<T, Boolean> predicate) { default BetterList<T> where(Function<T, Boolean> predicate) {
BetterList<T> out = new BetterArrayList<>(); BetterList<T> out = new BetterArrayList<>();
for (T element : this) for (T element : this)
if (predicate.apply(element)) if (predicate.apply(element))
out.add(element); out.add(element);
return out; return out;
} }
} }
src/fr/klemek/betterlists/BetterStack.java
+30 -34
View File
@@ -5,46 +5,42 @@ import java.util.Stack;
/** /**
* An extension of the java.util.Stack class which include some of the C# LINQ * An extension of the java.util.Stack class which include some of the C# LINQ
* useful functions. * useful functions.
*
* @author Klemek
* *
* @author Klemek
* @see java.util.Stack * @see java.util.Stack
*/ */
public class BetterStack<T> extends Stack<T> implements BetterList<T> { public class BetterStack<T> extends Stack<T> implements BetterList<T> {
private static final long serialVersionUID = 5642889973315247461L; private static final long serialVersionUID = 5642889973315247461L;
/** /**
* Creates an empty Stack. * Creates an empty Stack.
*/ */
public BetterStack() { public BetterStack() {
super(); super();
} }
/** /**
* Returns a view of the portion of this list between the specified fromIndex, * Returns a view of the portion of this list between the specified fromIndex,
* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the * inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the
* returned list is empty.) The returned list is backed by this list, so * returned list is empty.) The returned list is backed by this list, so
* non-structural changes in the returned list are reflected in this list, and * non-structural changes in the returned list are reflected in this list, and
* vice-versa. The returned list supports all of the optional list operations * vice-versa. The returned list supports all of the optional list operations
* supported by this list. This method eliminates the need for explicit range * supported by this list. This method eliminates the need for explicit range
* operations (of the sort that commonly exist for arrays). Any operation that * operations (of the sort that commonly exist for arrays). Any operation that
* expects a list can be used as a range operation by passing a subList view * expects a list can be used as a range operation by passing a subList view
* instead of a whole list. (see List.subList) * instead of a whole list. (see List.subList)
* *
* @param fromIndex * @param fromIndex - low endpoint (inclusive) of the subList
* - low endpoint (inclusive) of the subList * @param toIndex - high endpoint (exclusive) of the subList
* @param toIndex * @return a view of the specified range within this list
* - high endpoint (exclusive) of the subList * @throws IndexOutOfBoundsException for an illegal endpoint index value (fromIndex < 0 || toIndex >
* @return a view of the specified range within this list * size || fromIndex > toIndex)
* @throws IndexOutOfBoundsException * @see java.util.List
* for an illegal endpoint index value (fromIndex < 0 || toIndex > */
* size || fromIndex > toIndex) @Override
* @see java.util.List public BetterStack<T> subList(int fromIndex, int toIndex) {
*/ return (BetterStack<T>) super.subList(fromIndex, toIndex);
@Override }
public BetterStack<T> subList(int fromIndex, int toIndex) {
return (BetterStack<T>) super.subList(fromIndex, toIndex);
}
} }
src/fr/klemek/betterlists/BetterVector.java
+85 -93
View File
@@ -7,111 +7,103 @@ import java.util.Vector;
/** /**
* An extension of the java.util.Vector class which include some of the C# LINQ * An extension of the java.util.Vector class which include some of the C# LINQ
* useful functions. * useful functions.
*
* @author Klemek
* *
* @author Klemek
* @see java.util.Vector * @see java.util.Vector
*/ */
public class BetterVector<T> extends Vector<T> implements BetterList<T> { public class BetterVector<T> extends Vector<T> implements BetterList<T> {
private static final long serialVersionUID = -704157461726911759L; private static final long serialVersionUID = -704157461726911759L;
/** /**
* Constructs a vector containing the elements of the specified collection, in * Constructs a vector containing the elements of the specified collection, in
* the order they are returned by the collection's iterator. * the order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this vector
* - the collection whose elements are to be placed into this vector */
*/ public static <T> BetterVector<T> fromList(Collection<T> c) {
public static <T> BetterVector<T> fromList(Collection<T> c) { return new BetterVector<>(c);
return new BetterVector<>(c); }
}
/** /**
* Constructs a vector containing the elements given in argument. * Constructs a vector containing the elements given in argument.
* *
* @param a - the elements to be placed into this vector * @param a - the elements to be placed into this vector
*/ */
public static <T> BetterVector<T> asVector(T... a) { public static <T> BetterVector<T> asVector(T... a) {
return new BetterVector<>(a); return new BetterVector<>(a);
} }
/** /**
* Constructs an empty vector so that its internal data array has size 10 and * Constructs an empty vector so that its internal data array has size 10 and
* its standard capacity increment is zero. * its standard capacity increment is zero.
*/ */
public BetterVector() { public BetterVector() {
super(); super();
} }
/** /**
* Constructs a vector containing the elements of the specified collection, in * Constructs a vector containing the elements of the specified collection, in
* the order they are returned by the collection's iterator. * the order they are returned by the collection's iterator.
* *
* @param c * @param c - the collection whose elements are to be placed into this vector
* - the collection whose elements are to be placed into this vector */
*/ public BetterVector(Collection<? extends T> c) {
public BetterVector(Collection<? extends T> c) { super(c);
super(c); }
}
/** /**
* Constructs a vector containing the elements given in argument. * Constructs a vector containing the elements given in argument.
* *
* @param a - the elements to be placed into this list * @param a - the elements to be placed into this list
*/ */
public BetterVector(T... a) { public BetterVector(T... a) {
super(Arrays.asList(a)); super(Arrays.asList(a));
} }
/** /**
* Constructs an empty vector with the specified initial capacity and with its * Constructs an empty vector with the specified initial capacity and with its
* capacity increment equal to zero. * capacity increment equal to zero.
* *
* @param initialCapacity - the initial capacity of the vector * @param initialCapacity - the initial capacity of the vector
*/ */
public BetterVector(int initialCapacity) { public BetterVector(int initialCapacity) {
super(initialCapacity); super(initialCapacity);
} }
/** /**
* Constructs an empty vector with the specified initial capacity and capacity * Constructs an empty vector with the specified initial capacity and capacity
* increment. * increment.
* *
* @param initialCapacity * @param initialCapacity - the initial capacity of the vector
* - the initial capacity of the vector * @param capacityIncrement - the amount by which the capacity is increased when the vector
* @param capacityIncrement * overflows
* - the amount by which the capacity is increased when the vector */
* overflows public BetterVector(int initialCapacity, int capacityIncrement) {
*/ super(initialCapacity, capacityIncrement);
public BetterVector(int initialCapacity, int capacityIncrement) { }
super(initialCapacity, capacityIncrement);
}
/** /**
* Returns a view of the portion of this list between the specified fromIndex, * Returns a view of the portion of this list between the specified fromIndex,
* inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the * inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the
* returned list is empty.) The returned list is backed by this list, so * returned list is empty.) The returned list is backed by this list, so
* non-structural changes in the returned list are reflected in this list, and * non-structural changes in the returned list are reflected in this list, and
* vice-versa. The returned list supports all of the optional list operations * vice-versa. The returned list supports all of the optional list operations
* supported by this list. This method eliminates the need for explicit range * supported by this list. This method eliminates the need for explicit range
* operations (of the sort that commonly exist for arrays). Any operation that * operations (of the sort that commonly exist for arrays). Any operation that
* expects a list can be used as a range operation by passing a subList view * expects a list can be used as a range operation by passing a subList view
* instead of a whole list. (see List.subList) * instead of a whole list. (see List.subList)
* *
* @param fromIndex * @param fromIndex - low endpoint (inclusive) of the subList
* - low endpoint (inclusive) of the subList * @param toIndex - high endpoint (exclusive) of the subList
* @param toIndex * @return a view of the specified range within this list
* - high endpoint (exclusive) of the subList * @throws IndexOutOfBoundsException for an illegal endpoint index value (fromIndex < 0 || toIndex >
* @return a view of the specified range within this list * size || fromIndex > toIndex)
* @throws IndexOutOfBoundsException * @see java.util.List
* for an illegal endpoint index value (fromIndex < 0 || toIndex > */
* size || fromIndex > toIndex) @Override
* @see java.util.List public BetterVector<T> subList(int fromIndex, int toIndex) {
*/ return (BetterVector<T>) super.subList(fromIndex, toIndex);
@Override }
public BetterVector<T> subList(int fromIndex, int toIndex) {
return (BetterVector<T>) super.subList(fromIndex, toIndex);
}
} }
test/fr/klemek/betterlists/test/BetterListsTests.java
+285 -271
View File
@@ -1,332 +1,346 @@
package fr.klemek.betterlists.test; package fr.klemek.betterlists.test;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import fr.klemek.betterlists.BetterArrayList; import fr.klemek.betterlists.BetterArrayList;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import java.util.ArrayList;
import java.util.NoSuchElementException;
public class BetterListsTests { public class BetterListsTests {
protected class Dummy { protected class Dummy {
final double d; final double d;
final String s; final String s;
public Dummy(double d, String s) {
this.d = d;
this.s = s;
}
@Override public Dummy(double d, String s) {
public boolean equals(Object obj) { this.d = d;
if (this == obj) this.s = s;
return true; }
if (obj == null)
return false; @Override
if (getClass() != obj.getClass()) public boolean equals(Object obj) {
return false; if (this == obj)
Dummy other = (Dummy) obj; return true;
if (!getOuterType().equals(other.getOuterType())) if (obj == null)
return false; return false;
if (Double.doubleToLongBits(d) != Double.doubleToLongBits(other.d)) if (getClass() != obj.getClass())
return false; return false;
Dummy other = (Dummy) obj;
if (!getOuterType().equals(other.getOuterType()))
return false;
if (Double.doubleToLongBits(d) != Double.doubleToLongBits(other.d))
return false;
if (s == null && other.s != null) { if (s == null && other.s != null) {
return false; return false;
} else return s.equals(other.s); } else return s.equals(other.s);
} }
private BetterListsTests getOuterType() { private BetterListsTests getOuterType() {
return BetterListsTests.this; return BetterListsTests.this;
} }
@Override @Override
public int hashCode() { public int hashCode() {
final int prime = 31; final int prime = 31;
int result = 1; int result = 1;
result = prime * result + getOuterType().hashCode(); result = prime * result + getOuterType().hashCode();
long temp; long temp;
temp = Double.doubleToLongBits(d); temp = Double.doubleToLongBits(d);
result = prime * result + (int) (temp ^ (temp >>> 32)); result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + ((s == null) ? 0 : s.hashCode()); result = prime * result + ((s == null) ? 0 : s.hashCode());
return result; return result;
} }
} }
@Test @Test
public void testAll() { public void testAll() {
ArrayList<Dummy> al = new ArrayList<>(); ArrayList<Dummy> al = new ArrayList<>();
al.add(new Dummy(1d,"hello")); al.add(new Dummy(1d, "hello"));
al.add(new Dummy(2d,"test")); al.add(new Dummy(2d, "test"));
al.add(new Dummy(2d,"hello")); al.add(new Dummy(2d, "hello"));
BetterArrayList<Dummy> bal = BetterArrayList.fromList(al);
Assert.assertTrue(bal.all(du -> du.d > 0));
Assert.assertFalse(bal.all(du -> du.d > 1));
}
@Test BetterArrayList<Dummy> bal = BetterArrayList.fromList(al);
public void testAny() {
Assert.assertTrue(bal.all(du -> du.d > 0));
Assert.assertFalse(bal.all(du -> du.d > 1));
}
@Test
public void testAny() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(2d,"hello")); bal.add(new Dummy(2d, "hello"));
Assert.assertTrue(bal.any(du -> du.s.startsWith("t")));
Assert.assertFalse(bal.any(du -> du.s.startsWith("b")));
}
@Test Assert.assertTrue(bal.any(du -> du.s.startsWith("t")));
public void testCount() { Assert.assertFalse(bal.any(du -> du.s.startsWith("b")));
}
@Test
public void testCount() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(2d,"hello")); bal.add(new Dummy(2d, "hello"));
Assert.assertEquals(3, bal.count());
Assert.assertEquals(2, bal.count(du -> du.s.length() > 4));
}
@Test Assert.assertEquals(3, bal.count());
public void testExclude() { Assert.assertEquals(2, bal.count(du -> du.s.length() > 4));
}
@Test
public void testExclude() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hello"));
bal1.add(new Dummy(2d,"test")); bal1.add(new Dummy(2d, "test"));
bal1.add(new Dummy(3d,"hello")); bal1.add(new Dummy(3d, "hello"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
BetterArrayList<Dummy> bal2 = new BetterArrayList<>(); BetterArrayList<Dummy> bal2 = new BetterArrayList<>();
bal2.add(new Dummy(2d,"test")); bal2.add(new Dummy(2d, "test"));
bal2.add(new Dummy(3d,"hello")); bal2.add(new Dummy(3d, "hello"));
bal2.add(new Dummy(5d,"test")); bal2.add(new Dummy(5d, "test"));
BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.exclusion(bal2);
Assert.assertEquals(2, bal3.size());
Assert.assertEquals(bal1.get(0), bal3.get(0));
Assert.assertEquals(bal1.get(3), bal3.get(1));
}
@Test BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.exclusion(bal2);
public void testFirst() { Assert.assertEquals(2, bal3.size());
Assert.assertEquals(bal1.get(0), bal3.get(0));
Assert.assertEquals(bal1.get(3), bal3.get(1));
}
@Test
public void testFirst() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(2d,"hello")); bal.add(new Dummy(2d, "hello"));
Assert.assertEquals(bal.get(0), bal.first(du -> du.s.startsWith("h"))); Assert.assertEquals(bal.get(0), bal.first(du -> du.s.startsWith("h")));
try { try {
bal.first(du -> du.s.startsWith("d")); bal.first(du -> du.s.startsWith("d"));
Assert.fail("no error"); Assert.fail("no error");
} catch (NoSuchElementException e) { } catch (NoSuchElementException e) {
} }
Assert.assertEquals(bal.get(0), bal.firstOrDefault(du -> du.s.startsWith("h"), new Dummy(3d,"default"))); Assert.assertEquals(bal.get(0), bal.firstOrDefault(du -> du.s.startsWith("h"), new Dummy(3d, "default")));
Assert.assertEquals(new Dummy(3d,"default"), bal.firstOrDefault(du -> du.s.startsWith("d"), new Dummy(3d,"default")));
}
@Test Assert.assertEquals(new Dummy(3d, "default"), bal.firstOrDefault(du -> du.s.startsWith("d"), new Dummy(3d, "default")));
public void testLast() { }
@Test
public void testLast() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(2d,"hello")); bal.add(new Dummy(2d, "hello"));
Assert.assertEquals(bal.get(2), bal.last(du -> du.s.startsWith("h"))); Assert.assertEquals(bal.get(2), bal.last(du -> du.s.startsWith("h")));
try {
bal.last(du -> du.s.startsWith("d"));
Assert.fail("no error");
} catch (NoSuchElementException e) {
}
Assert.assertEquals(bal.get(2), bal.lastOrDefault(du -> du.s.startsWith("h"), new Dummy(3d,"default"))); try {
bal.last(du -> du.s.startsWith("d"));
Assert.assertEquals(new Dummy(3d,"default"), bal.lastOrDefault(du -> du.s.startsWith("d"), new Dummy(3d,"default"))); Assert.fail("no error");
} } catch (NoSuchElementException e) {
}
@Test Assert.assertEquals(bal.get(2), bal.lastOrDefault(du -> du.s.startsWith("h"), new Dummy(3d, "default")));
public void testMax() {
Assert.assertEquals(new Dummy(3d, "default"), bal.lastOrDefault(du -> du.s.startsWith("d"), new Dummy(3d, "default")));
}
@Test
public void testMax() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(3d,"hello2")); bal.add(new Dummy(3d, "hello2"));
Assert.assertEquals(6d, bal.max(du -> (double)du.s.length()), 0.001d);
}
@Test Assert.assertEquals(6d, bal.max(du -> (double) du.s.length()), 0.001d);
public void testMean() { }
@Test
public void testMean() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(3d,"hello2")); bal.add(new Dummy(3d, "hello2"));
Assert.assertEquals(5d, bal.mean(du -> (double)du.s.length()), 0.001d);
}
@Test Assert.assertEquals(5d, bal.mean(du -> (double) du.s.length()), 0.001d);
public void testMin() { }
@Test
public void testMin() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(3d,"hello2")); bal.add(new Dummy(3d, "hello2"));
Assert.assertEquals(4d, bal.min(du -> (double)du.s.length()), 0.001d);
}
@Test Assert.assertEquals(4d, bal.min(du -> (double) du.s.length()), 0.001d);
public void testOrderBy() { }
@Test
public void testOrderBy() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello1")); bal1.add(new Dummy(1d, "hello1"));
bal1.add(new Dummy(2d,"hello2")); bal1.add(new Dummy(2d, "hello2"));
bal1.add(new Dummy(3d,"hello0")); bal1.add(new Dummy(3d, "hello0"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
bal1.add(new Dummy(5d,"hello4")); bal1.add(new Dummy(5d, "hello4"));
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.orderBy(c -> c.s);
Assert.assertNotEquals(bal1, bal2);
Assert.assertEquals(bal1.get(2), bal2.get(0));
Assert.assertEquals(bal1.get(0), bal2.get(1));
Assert.assertEquals(bal1.get(1), bal2.get(2));
Assert.assertEquals(bal1.get(4), bal2.get(3));
Assert.assertEquals(bal1.get(3), bal2.get(4));
}
@Test BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.orderBy(c -> c.s);
public void testOrderByDescending() { Assert.assertNotEquals(bal1, bal2);
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); Assert.assertEquals(bal1.get(2), bal2.get(0));
bal1.add(new Dummy(1d,"hello1")); Assert.assertEquals(bal1.get(0), bal2.get(1));
bal1.add(new Dummy(2d,"hello2")); Assert.assertEquals(bal1.get(1), bal2.get(2));
bal1.add(new Dummy(3d,"hello0")); Assert.assertEquals(bal1.get(4), bal2.get(3));
bal1.add(new Dummy(4d,"test")); Assert.assertEquals(bal1.get(3), bal2.get(4));
bal1.add(new Dummy(5d,"hello4")); }
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.orderByDescending(c -> c.d);
Assert.assertNotEquals(bal1, bal2);
for(int i = 0; i < 5; i++)
Assert.assertEquals(bal1.get(4-i), bal2.get(i));
}
@Test @Test
public void testReverse() { public void testOrderByDescending() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hello1"));
bal1.add(new Dummy(2d,"hello")); bal1.add(new Dummy(2d, "hello2"));
bal1.add(new Dummy(3d,"hello")); bal1.add(new Dummy(3d, "hello0"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
bal1.add(new Dummy(5d,"hello")); bal1.add(new Dummy(5d, "hello4"));
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.reverse();
Assert.assertEquals(5, bal2.size());
for(int i = 0; i < 5; i++)
Assert.assertEquals(bal1.get(i), bal2.get(4-i));
}
@Test BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.orderByDescending(c -> c.d);
public void testSelect() { Assert.assertNotEquals(bal1, bal2);
for (int i = 0; i < 5; i++)
Assert.assertEquals(bal1.get(4 - i), bal2.get(i));
}
@Test
public void testReverse() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hello"));
bal1.add(new Dummy(2d,"hello")); bal1.add(new Dummy(2d, "hello"));
bal1.add(new Dummy(3d,"hello")); bal1.add(new Dummy(3d, "hello"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
bal1.add(new Dummy(5d,"hello")); bal1.add(new Dummy(5d, "hello"));
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.reverse();
Assert.assertEquals(5, bal2.size());
for (int i = 0; i < 5; i++)
Assert.assertEquals(bal1.get(i), bal2.get(4 - i));
}
@Test
public void testSelect() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d, "hello"));
bal1.add(new Dummy(2d, "hello"));
bal1.add(new Dummy(3d, "hello"));
bal1.add(new Dummy(4d, "test"));
bal1.add(new Dummy(5d, "hello"));
BetterArrayList<Double> bal2 = (BetterArrayList<Double>) bal1.select(du -> du.d); BetterArrayList<Double> bal2 = (BetterArrayList<Double>) bal1.select(du -> du.d);
Assert.assertEquals(5, bal2.size()); Assert.assertEquals(5, bal2.size());
for(int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
Assert.assertEquals(bal1.get(i).d, bal2.get(i), 0.0001); Assert.assertEquals(bal1.get(i).d, bal2.get(i), 0.0001);
} }
@Test @Test
public void testSkip() { public void testSelectMany() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hel;lo"));
bal1.add(new Dummy(2d,"hello")); bal1.add(new Dummy(2d, "hel;lo"));
bal1.add(new Dummy(3d,"hello"));
bal1.add(new Dummy(4d,"test")); BetterArrayList<String> bal2 = (BetterArrayList<String>) bal1.selectMany(du -> du.s.split(";"));
bal1.add(new Dummy(5d,"hello")); Assert.assertEquals(4, bal2.size());
Assert.assertEquals("hel", bal2.get(0));
Assert.assertEquals(bal1, bal1.skip(0)); Assert.assertEquals("lo", bal2.get(1));
Assert.assertEquals(0, bal1.skip(10).size()); Assert.assertEquals("hel", bal2.get(2));
Assert.assertEquals("lo", bal2.get(3));
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.skip(2); }
Assert.assertEquals(3, bal2.size());
for(int i = 0; i < 3; i++) @Test
Assert.assertEquals(bal1.get(i+2), bal2.get(i)); public void testSkip() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.skipWhile(du -> du.s.startsWith("h")); bal1.add(new Dummy(1d, "hello"));
Assert.assertEquals(2, bal3.size()); bal1.add(new Dummy(2d, "hello"));
for(int i = 0; i < 2; i++) bal1.add(new Dummy(3d, "hello"));
Assert.assertEquals(bal1.get(i+3), bal3.get(i)); bal1.add(new Dummy(4d, "test"));
} bal1.add(new Dummy(5d, "hello"));
@Test Assert.assertEquals(bal1, bal1.skip(0));
public void testSum() { Assert.assertEquals(0, bal1.skip(10).size());
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.skip(2);
Assert.assertEquals(3, bal2.size());
for (int i = 0; i < 3; i++)
Assert.assertEquals(bal1.get(i + 2), bal2.get(i));
BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.skipWhile(du -> du.s.startsWith("h"));
Assert.assertEquals(2, bal3.size());
for (int i = 0; i < 2; i++)
Assert.assertEquals(bal1.get(i + 3), bal3.get(i));
}
@Test
public void testSum() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(3d,"hello2")); bal.add(new Dummy(3d, "hello2"));
Assert.assertEquals(6d, bal.sum(du -> du.d), 0.001d); Assert.assertEquals(6d, bal.sum(du -> du.d), 0.001d);
} }
@Test @Test
public void testTake() { public void testTake() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hello"));
bal1.add(new Dummy(2d,"hello")); bal1.add(new Dummy(2d, "hello"));
bal1.add(new Dummy(3d,"hello")); bal1.add(new Dummy(3d, "hello"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
bal1.add(new Dummy(5d,"hello")); bal1.add(new Dummy(5d, "hello"));
Assert.assertEquals(bal1, bal1.take(10)); Assert.assertEquals(bal1, bal1.take(10));
Assert.assertEquals(0, bal1.take(0).size()); Assert.assertEquals(0, bal1.take(0).size());
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.take(2); BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal1.take(2);
Assert.assertEquals(2, bal2.size()); Assert.assertEquals(2, bal2.size());
for(int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
Assert.assertEquals(bal1.get(i), bal2.get(i)); Assert.assertEquals(bal1.get(i), bal2.get(i));
BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.takeWhile(du -> du.s.startsWith("h")); BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.takeWhile(du -> du.s.startsWith("h"));
Assert.assertEquals(3, bal3.size()); Assert.assertEquals(3, bal3.size());
for(int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
Assert.assertEquals(bal1.get(i), bal3.get(i)); Assert.assertEquals(bal1.get(i), bal3.get(i));
} }
@Test @Test
public void testUnion() { public void testUnion() {
BetterArrayList<Dummy> bal1 = new BetterArrayList<>(); BetterArrayList<Dummy> bal1 = new BetterArrayList<>();
bal1.add(new Dummy(1d,"hello")); bal1.add(new Dummy(1d, "hello"));
bal1.add(new Dummy(2d,"test")); bal1.add(new Dummy(2d, "test"));
bal1.add(new Dummy(3d,"hello")); bal1.add(new Dummy(3d, "hello"));
bal1.add(new Dummy(4d,"test")); bal1.add(new Dummy(4d, "test"));
BetterArrayList<Dummy> bal2 = new BetterArrayList<>(); BetterArrayList<Dummy> bal2 = new BetterArrayList<>();
bal2.add(new Dummy(2d,"test")); bal2.add(new Dummy(2d, "test"));
bal2.add(new Dummy(3d,"hello")); bal2.add(new Dummy(3d, "hello"));
bal2.add(new Dummy(5d,"test")); bal2.add(new Dummy(5d, "test"));
BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.union(bal2);
Assert.assertEquals(2, bal3.size());
Assert.assertEquals(bal1.get(1), bal3.get(0));
Assert.assertEquals(bal1.get(2), bal3.get(1));
}
@Test BetterArrayList<Dummy> bal3 = (BetterArrayList<Dummy>) bal1.union(bal2);
public void testWhere() { Assert.assertEquals(2, bal3.size());
Assert.assertEquals(bal1.get(1), bal3.get(0));
Assert.assertEquals(bal1.get(2), bal3.get(1));
}
@Test
public void testWhere() {
BetterArrayList<Dummy> bal = new BetterArrayList<>(); BetterArrayList<Dummy> bal = new BetterArrayList<>();
bal.add(new Dummy(1d,"hello")); bal.add(new Dummy(1d, "hello"));
bal.add(new Dummy(2d,"test")); bal.add(new Dummy(2d, "test"));
bal.add(new Dummy(3d,"hello")); bal.add(new Dummy(3d, "hello"));
BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal.where(du -> du.s.startsWith("h")); BetterArrayList<Dummy> bal2 = (BetterArrayList<Dummy>) bal.where(du -> du.s.startsWith("h"));
Assert.assertEquals(2, bal2.size()); Assert.assertEquals(2, bal2.size());
Assert.assertEquals(new Dummy(1d,"hello"), bal2.get(0)); Assert.assertEquals(new Dummy(1d, "hello"), bal2.get(0));
Assert.assertEquals(new Dummy(3d,"hello"), bal2.get(1)); Assert.assertEquals(new Dummy(3d, "hello"), bal2.get(1));
} }
} }