@Override public boolean filter(T t) { return _predicateFilter.filter(t); }
@Override public boolean filter(T t) { return !_predicateFilter.filter(t); }
@Override public boolean filter(T t) { return _predicateFilter.filter(t); }
public static <T> List<T> filter( List<? extends T> inputList, List<T> outputList, PredicateFilter<T> predicateFilter) { for (T item : inputList) { if (predicateFilter.filter(item)) { outputList.add(item); } } return outputList; }
public static <K1, V1, K2 extends K1, V2 extends V1> void filter( Map<? extends K2, ? extends V2> inputMap, Map<? super K2, ? super V2> outputMap, PredicateFilter<? super Map.Entry<K1, V1>> predicateFilter) { for (Map.Entry<? extends K2, ? extends V2> entry : inputMap.entrySet()) { if (predicateFilter.filter((Map.Entry<K1, V1>)entry)) { outputMap.put(entry.getKey(), entry.getValue()); } } }
public static <T> int count(T[] array, PredicateFilter<T> predicateFilter) { if (isEmpty(array)) { return 0; } int count = 0; for (T t : array) { if (predicateFilter.filter(t)) { count++; } } return count; }
public static <T> boolean exists( T[] array, PredicateFilter<T> predicateFilter) { if (isEmpty(array)) { return false; } for (T t : array) { if (predicateFilter.filter(t)) { return true; } } return false; }
public static <E> boolean exists( List<? extends E> list, PredicateFilter<E> predicateFilter) { if (isEmpty(list)) { return false; } for (E element : list) { if (predicateFilter.filter(element)) { return true; } } return false; }
public static <E> int count( List<? extends E> list, PredicateFilter<E> predicateFilter) { if (isEmpty(list)) { return 0; } int count = 0; for (E element : list) { if (predicateFilter.filter(element)) { count++; } } return count; }
public static <T> T[] filter( T[] array, PredicateFilter<T> filterPredicate) { if (isEmpty(array)) { return array; } List<T> filteredList = new ArrayList<>(); for (T t : array) { if (filterPredicate.filter(t)) { filteredList.add(t); } } Object[] filteredArray = filteredList.toArray(); return (T[])Arrays.copyOf( filteredArray, filteredArray.length, array.getClass()); }
public static byte[] filter( byte[] array, PredicateFilter<Byte> predicateFilter) { if (isEmpty(array)) { return array; } List<Byte> filteredList = new ArrayList<>(); for (byte b : array) { if (predicateFilter.filter(b)) { filteredList.add(b); } } return toArray(filteredList.toArray(new Byte[filteredList.size()])); }
public static double[] filter( double[] array, PredicateFilter<Double> predicateFilter) { if (isEmpty(array)) { return array; } List<Double> filteredList = new ArrayList<>(); for (double d : array) { if (predicateFilter.filter(d)) { filteredList.add(d); } } return toArray(filteredList.toArray(new Double[filteredList.size()])); }
public static short[] filter( short[] array, PredicateFilter<Short> predicateFilter) { if (isEmpty(array)) { return array; } List<Short> filteredList = new ArrayList<>(); for (short s : array) { if (predicateFilter.filter(s)) { filteredList.add(s); } } return toArray(filteredList.toArray(new Short[filteredList.size()])); }
public static long[] filter( long[] array, PredicateFilter<Long> predicateFilter) { if (isEmpty(array)) { return array; } List<Long> filteredList = new ArrayList<>(); for (long l : array) { if (predicateFilter.filter(l)) { filteredList.add(l); } } return toArray(filteredList.toArray(new Long[filteredList.size()])); }
public static char[] filter( char[] array, PredicateFilter<Character> predicateFilter) { if (isEmpty(array)) { return array; } List<Character> filteredList = new ArrayList<>(); for (char c : array) { if (predicateFilter.filter(c)) { filteredList.add(c); } } return toArray( filteredList.toArray(new Character[filteredList.size()])); }
public static boolean[] filter( boolean[] array, PredicateFilter<Boolean> predicateFilter) { if (isEmpty(array)) { return array; } List<Boolean> filteredList = new ArrayList<>(); for (boolean b : array) { if (predicateFilter.filter(b)) { filteredList.add(b); } } return toArray(filteredList.toArray(new Boolean[filteredList.size()])); }
public static float[] filter( float[] array, PredicateFilter<Float> predicateFilter) { if (isEmpty(array)) { return array; } List<Float> filteredList = new ArrayList<>(); for (float f : array) { if (predicateFilter.filter(f)) { filteredList.add(f); } } return toArray(filteredList.toArray(new Float[filteredList.size()])); }
public static int[] filter( int[] array, PredicateFilter<Integer> predicateFilter) { if (isEmpty(array)) { return array; } List<Integer> filteredList = new ArrayList<>(); for (int i : array) { if (predicateFilter.filter(i)) { filteredList.add(i); } } return toArray(filteredList.toArray(new Integer[filteredList.size()])); }