//package com.neutrino.ads; //import com.neutrino.janum.Range; import java.util.*; import java.util.stream.Collectors; import java.util.stream.IntStream; /** * This is an extension the {@link ArrayList} object but with some added frills. * . Some extra trivial methods are added. * @param Object type of values of this object. */ class NList extends ArrayList { /** * Initialize {@link NList} with list of values. * * @param values values of the series. */ public NList(List values) { super(values); } /** * Initialize {@link NList} with arrays * To use this constructor, keys must be Integers. * * @param values array of objects */ public NList(V[] values) { super(Arrays.asList(values)); } /** * Initialize an empty {@link NList} object. */ public NList() { super(); } /** * Returns the first value in this list. * @return value in the first index. * @throws IndexOutOfBoundsException if list is empty. */ public V first() { return get(0); } /** * Returns the last value in this list. * @return value in the last index. * @throws IndexOutOfBoundsException if list is empty. */ public V last() { return get(size() - 1); } /** * Return all the indices that contains the argument value. * @param value value to check. * @return NList of indices. */ public NList indices(V value) { NList res = IntStream.range(0, size()).filter(i -> get(i).equals(value)).boxed().collect(Collectors.toCollection(NList::new)); return res; } /** * Returns the sum of values in this list if the values are in Number class hierachy * or can be parsed to Number. * @return sum of values in this object. * @throws NumberFormatException if values cannot be parsed to number. */ public double sum() { if(size() == 0) return 0; return this.stream().mapToDouble(val -> Double.valueOf(val.toString())).sum(); } /** * Returns the mean of values in this list if the values are in Number class hierachy * or can be parsed to Number. * @return mean of values in this object. * @throws NumberFormatException if values cannot be parsed to number. */ public double mean() { if(size() == 0) return 0; return this.stream().mapToDouble(val -> Double.valueOf(val.toString())).sum() / size(); } /** * Returns a {@link TreeMap} object with keys a unique of values of this list * and values as the number of their appearances in the list. * @return a treeMap object. */ public TreeMap counter() { TreeMap res; // don't get shy to understand the following line res = this.parallelStream().collect(Collectors.toMap(val -> val, val -> 1, Integer::sum, TreeMap::new)); return res; } /** * Returns a {@link TreeMap} object with keys a unique of values of this list * and values as the number of their expectation in the list. * @return a treeMap object. */ public TreeMap hist() { TreeMap res; TreeMap counter = counter(); res = counter.keySet().parallelStream().collect(Collectors.toMap(val -> val, val -> counter.get(val).doubleValue() / counter.size(), (a, b) -> b, TreeMap::new)); return res; } /** * Removes the last value in this list and returns it. * @return value removed. * @throws IndexOutOfBoundsException if list is empty. */ public V pop() { return remove(size() - 1); } /** * Shuffles the elements in this list. * Applies the Fisher Yates shuffle algorithm. */ public void shuffle() { for (int i = 0; i < size(); i++) { int j = (int) (Math.random() * i + 1); V temp = get(i); set(i, get(j)); set(j, temp); } } /** * Extends this object values with values in the argument list. * @param c {@link Collection} object of compatible values. */ public void extend(Collection c) { addAll(c); } /** * Returns a sub List of this list from the specified indices. * @param start starting index. * @param end ending index. * @return a sub list of this list. */ public NList subList(int start, int end) { NList res = new NList<>(); for (int i = start; i < end; i++) { res.add(get(i)); } return res; } /** * Returns a sub List of this list from index 0 to index in the argument. * @param end ending index. * @return a sub list of this list. */ public NList subList(int end) { return subList(0, end); } /** * Returns unique items in this object as {@link NList} object. * @return NList with items appearing only once. */ public NList unique() { NList res = new NList<>(); for (V val : this) { if(res.contains(val)) continue; res.add(val); } return res; } /** * Reverses the order of values in this list. */ public void reverse() { for (int i = 0; i < size(); i++) { int j = size() - i - 1; if (i >= j) break; V temp = get(i); set(i, get(j)); set(j, temp); } } /** * Returns a copy of this object. * Note both hold the same object. * @return list. */ public NList copy() { return new NList<>(this); } /** * Returns a new {@link NList} object with values of this object passed through * the method in the argument object. * @param callable {@link Callable} object. * @param return type of the callable object. * @return new list with type values as defined in callable. */ public NList apply(Callable callable) { NList s = new NList<>(); forEach(v -> s.add(callable.call(v))); return s; } } interface Callable{ S call(E param); } public class NListDemo{ public static void main(String[] args){ NList list = new NList<>(new String[]{"Java", "Python", "Php", "C++", "Javascript", "C", "R", "C#", "Ruby", "Pascal", "Scala", "Go", "Kotlin", "Dart"}); System.out.println("Java generic list beyond limits\n"); System.out.printf("Original list%n%n%s%n", list); list.sort(Comparator.naturalOrder()); System.out.printf("%nSorted list%n%n%s%n", list); list.reverse(); System.out.printf("%nReversed list%n%n%s%n", list); list.shuffle(); System.out.printf("%nShuffled list%n%n%s", list); list = list.apply(new Callable(){ public String call(String param){ return param.toLowerCase(); } }); System.out.printf("%n%nLowercased%n%n%s", list); } }