fix: CollectionUtils#get

fix: equals in private collections
change: CollectionUtils#first #last - signatures

src/main/java/net/ranides/assira/collection/CollectionUtils.java

@@ -8,6 +8,7 @@
 package net.ranides.assira.collection;
 
 import java.util.AbstractCollection;
+import java.util.AbstractSet;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
@@ -39,10 +40,10 @@ public final class CollectionUtils {
      */
     public static <T> T get(Collection<T> values, int index, T ddefault) {
         if(null == values) { return ddefault; }
-        if(index >= values.size() ) { return ddefault; }
+        if(index<0 || index >= values.size() ) { return ddefault; }
         Iterator<T> iterator = values.iterator();
         // pomijamy (index-1) elementów
-        for(int i=1; i<index; i++) {
+        for(int i=0; i<index; i++) {
             iterator.next();
         }
         return iterator.next();
@@ -73,7 +74,7 @@ public final class CollectionUtils {
      * @param clazz szukana klasa
      * @return
      */
-    public static <T> T first(Collection<?> values, Class<T> clazz) {
+    public static <T> T first(Iterable<?> values, Class<T> clazz) {
         if(null == values) { return null; }
         Iterator<?> i = values.iterator();
         while(i.hasNext()) {
@@ -92,9 +93,8 @@ public final class CollectionUtils {
      * @param values kolekcja, z której obiekt jest zwracany
      * @return
      */
-    public static <T> T first(Collection<T> values) {
-        if(null == values) { return null; }
-        return values.isEmpty() ? null : values.iterator().next();
+    public static <T> T first(Iterable<T> values) {
+        return null == values ? null : first(values.iterator());
     }
 
 
@@ -107,16 +107,8 @@ public final class CollectionUtils {
      * @param values kolekcja, iterator lub zwykły obiekt
      * @return psuedo-pierwszy element
      */
-    public static Object first(Object values) {
-        if(values instanceof Iterable) {
-            Iterator<?> iterator =((Iterable)values).iterator();
-            return iterator.hasNext() ? iterator.next() : null;
-        }
-        if(values instanceof Iterator) {
-            Iterator<?> iterator =(Iterator)values;
-            return iterator.hasNext() ? iterator.next() : null;
-        }
-        return values;
+    public static <T> T first(Iterator<T> iterator) {
+        return iterator.hasNext() ? iterator.next() : null;
     }
 
 
@@ -129,7 +121,7 @@ public final class CollectionUtils {
      * @param clazz szukana klasa
      * @return
      */
-    public static <T> T last(Collection<?> values, Class<T> clazz) {
+    public static <T> T last(Iterable<?> values, Class<T> clazz) {
         if(null == values) { return null; }
         Iterator<?> i = values.iterator();
         T result = null;
@@ -148,12 +140,8 @@ public final class CollectionUtils {
      * @param values kolekcja, z której obiekt jest zwracany
      * @return
      */
-    public static <T> T last(Collection<T> values) {
-        if(null == values) { return null; }
-        Iterator<T> i = values.iterator();
-        T result = null;
-        while(i.hasNext()) { result = i.next(); }
-        return result;
+    public static <T> T last(Iterable<T> values) {
+        return null == values ? null : last(values.iterator());
     }
 
     /**
@@ -165,19 +153,10 @@ public final class CollectionUtils {
      * @param values kolekcja, iterator lub zwykły obiekt
      * @return psuedo-pierwszy element
      */
-    public static Object last(Object values) {
-        Object result = null;
-        if(values instanceof Iterable) {
-            Iterator<?> iterator = ((Iterable)values).iterator();
-            while(iterator.hasNext()) { result = iterator.next(); }
-            return result;
-        }
-        if(values instanceof Iterator) {
-            Iterator<?> iterator = (Iterator)values;
-            while(iterator.hasNext()) { result = iterator.next(); }
-            return result;
-        }
-        return null;
+    public static <T> T last(Iterator<T> iterator) {
+        T result = null;
+        while(iterator.hasNext()) { result = iterator.next(); }
+        return result;
     }
 
     /**
@@ -190,7 +169,7 @@ public final class CollectionUtils {
     public static <T> int size(Collection<T> values) {
         return null == values ? 0 : values.size();
     }
-
+    
     /**
      * Sprawdza czy kolekcja jest pusta.
      * <div class="message-note">{@code null} safe method</div>
@@ -221,12 +200,11 @@ public final class CollectionUtils {
      * Sprawdza, czy kolekcje zawierają te same elementy ignorując kolejność.
      * Uwaga: bardzo kosztowna metoda, ponieważ kopiuje a następnie sortuje obie
      * kolekcje.
-     * @param <T>
      * @param a
      * @param b
      * @return
      */
-    public static <T> boolean equalContent(Collection<T> a, Collection<T> b) {
+    public static boolean equalContent(Collection<?> a, Collection<?> b) {
         if( a.size() != b.size() ){
             return false;
         }
@@ -258,8 +236,6 @@ public final class CollectionUtils {
         return new ClipCollection<>(values, size);
     }
 
-/* ************************************************************************** */
-
     private static final class ClipIterator<T> implements Iterator<T> {
 
         private final Iterator<T> iterator;
@@ -287,7 +263,7 @@ public final class CollectionUtils {
 
     }
 
-    private static final class ClipCollection<T> extends AbstractCollection<T> {
+    private static final class ClipCollection<T> extends AbstractSet<T> {
 
         private final Collection<T> values;
         private final int size;
@@ -363,7 +339,7 @@ public final class CollectionUtils {
      * @return
      */
     public static <T,S> Collection<T> adapt(final Collection<S> collection, final Function<T,S> function) {
-        return new AbstractCollection<T>() {
+        return new AbstractSet<T>() {
             @Override
             public Iterator<T> iterator() {
                 return adapt(collection.iterator(), function);

src/test/java/net/ranides/assira/collection/CollectionUtilsTest.java

@@ -0,0 +1,146 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import net.ranides.assira.generic.Function;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+@SuppressWarnings("UnnecessaryUnboxing")
+public class CollectionUtilsTest {
+    
+    public CollectionUtilsTest() {
+    }
+
+    @Test
+    public void testFirst() {
+        assertEquals(1, CollectionUtils.first(Arrays.asList(1,2,3)).intValue());
+        assertEquals(1, CollectionUtils.first(Arrays.asList(1)).intValue());
+        assertNull(CollectionUtils.first(Arrays.asList()));
+        assertNull(CollectionUtils.first((List<?>)null));
+        
+        assertEquals( 1L, CollectionUtils.first(Arrays.<Object>asList(0f, 7, 1L), Long.class).longValue());
+        assertEquals( 7L, CollectionUtils.first(Arrays.<Object>asList(7L, 0f, 7, 1L), Long.class).longValue());
+        assertEquals( 7L, CollectionUtils.first(Arrays.<Object>asList(7L, 1L), Long.class).longValue());
+        assertEquals( 7L, CollectionUtils.first(Arrays.<Object>asList(7L), Long.class).longValue());
+        assertNull( CollectionUtils.first(Arrays.<Object>asList(0f, 7), Long.class));
+        assertNull( CollectionUtils.first(Arrays.<Object>asList(), Long.class));
+        assertNull( CollectionUtils.first(null, Long.class));
+    }
+    
+    @Test
+    public void testLast() {
+        assertEquals(3, CollectionUtils.last(Arrays.asList(1,2,3)).intValue());
+        assertEquals(1, CollectionUtils.last(Arrays.asList(1)).intValue());
+        assertNull(CollectionUtils.last(Arrays.asList()));
+        assertNull(CollectionUtils.last((Collection<?>)null));
+        
+        assertEquals( 1L, CollectionUtils.last(Arrays.<Object>asList(0f, 7, 1L), Long.class).longValue());
+        assertEquals( 1L, CollectionUtils.last(Arrays.<Object>asList(7L, 0f, 7, 1L), Long.class).longValue());
+        assertEquals( 1L, CollectionUtils.last(Arrays.<Object>asList(7L, 1L), Long.class).longValue());
+        assertEquals( 7L, CollectionUtils.last(Arrays.<Object>asList(7L), Long.class).longValue());
+        assertNull( CollectionUtils.last(Arrays.<Object>asList(0f, 7), Long.class));
+        assertNull( CollectionUtils.last(Arrays.<Object>asList(), Long.class));
+        assertNull( CollectionUtils.last(null, Long.class));
+    }
+    
+    @Test
+    public void testGet() {
+        assertNull( CollectionUtils.get(null, 4) );
+        assertNull( CollectionUtils.get(null, 0) );
+        assertNull( CollectionUtils.get(Arrays.asList(1,2,3), 6) );
+        assertNull( CollectionUtils.get(Arrays.asList(1,2,3), -2) );
+        
+        assertEquals( 1, CollectionUtils.get(Arrays.asList(1,2,3), 0).intValue() );
+        assertEquals( 3, CollectionUtils.get(Arrays.asList(1,2,3), 2).intValue() );
+        
+        assertEquals(99, CollectionUtils.get(null, 4, 99).intValue() );
+        assertEquals(99, CollectionUtils.get(null, 0, 99).intValue() );
+        assertEquals(99, CollectionUtils.get(Arrays.asList(1,2,3), 6, 99).intValue() );
+        assertEquals(99, CollectionUtils.get(Arrays.asList(1,2,3), -2, 99).intValue() );
+        
+        assertEquals( 1, CollectionUtils.get(Arrays.asList(1,2,3), 0, 99).intValue() );
+        assertEquals( 3, CollectionUtils.get(Arrays.asList(1,2,3), 2, 99).intValue() );
+    }
+    
+    @Test
+    public void testSize() {
+        assertEquals(0, CollectionUtils.size((Collection<?>)null));
+        assertEquals(0, CollectionUtils.size(Collections.emptyList()));
+        assertEquals(1, CollectionUtils.size(Arrays.asList(1)));
+        assertEquals(3, CollectionUtils.size(Arrays.asList(1,1,1)));
+        
+        assertTrue(CollectionUtils.isEmpty(null));
+        assertTrue(CollectionUtils.isEmpty(Collections.emptyList()));
+        assertFalse(CollectionUtils.isEmpty(Arrays.asList(1)));
+        assertFalse(CollectionUtils.isEmpty(Arrays.asList(1,1,1)));
+        
+        assertTrue( CollectionUtils.equalSize(null, null) );
+        assertTrue( CollectionUtils.equalSize(Collections.emptyList(), null) );
+        assertTrue( CollectionUtils.equalSize(null, Collections.emptyList()) );
+        assertTrue( CollectionUtils.equalSize(Arrays.asList(1,1,1), Arrays.asList(1,3,4)) );
+        
+        assertFalse( CollectionUtils.equalSize(Arrays.asList(1,1,1), Arrays.asList(1,1)) );
+        assertFalse( CollectionUtils.equalSize(null, Arrays.asList(1,1)) );
+        assertFalse( CollectionUtils.equalSize(Arrays.asList(1,1),null) );
+    }
+
+    @Test
+    public void testClip() {
+        assertEquals(Arrays.asList(1,2,3), CollectionUtils.clip(Arrays.asList(1,2,3), 5));
+        assertEquals(Arrays.asList(1,2,3), CollectionUtils.clip(Arrays.asList(1,2,3), 3));
+        
+        assertEquals(SetUtils.asHashSet(1,2), CollectionUtils.clip(Arrays.asList(1,2,3), 2));
+        assertEquals(SetUtils.asHashSet(1), CollectionUtils.clip(Arrays.asList(1,2,3), 1));
+        assertEquals(SetUtils.asHashSet(), CollectionUtils.clip(Arrays.asList(1,2,3), 0));
+        
+        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
+        Iterator<Integer> iterator = CollectionUtils.clip(list, 3).iterator();
+        iterator.next();
+        iterator.next();
+        iterator.remove();
+        assertEquals(Arrays.asList(1,3,4,5), list);
+    }
+    
+    @Test
+    public void testAdapt() {
+        Collection<String> set1 = CollectionUtils.adapt(SetUtils.asHashSet(1,2,3,4), new Function<String, Integer>() {
+            @Override
+            public String apply(Integer source) {
+                return String.valueOf(source);
+            }
+        });
+        assertEquals(4, set1.size());
+        assertEquals(SetUtils.asHashSet("1","2","3","4"), set1);
+        
+        Iterator<String> iterator = CollectionUtils.adapt(Arrays.asList(1,2,3,4).iterator(), new Function<String, Integer>() {
+            @Override
+            public String apply(Integer source) {
+                return String.valueOf(source);
+            }
+        });
+        assertEquals(Arrays.asList("1","2","3","4"), ListUtils.asList(iterator));
+    }
+    
+    @Test
+    public void testAsCollection() {
+        Collection<Integer> collection = CollectionUtils.asCollection(4, Arrays.asList(1,2,3,4));
+        assertEquals(4, collection.size());
+        assertEquals("[1, 2, 3, 4]", collection.toString());
+    }
+    
+}