functionaljava · mperry · Jan 28, 2015 · Jan 28, 2015
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
@@ -1445,13 +1445,22 @@ public static <A> F<ArrayList<A>, List<A>> ArrayList_List() {
 
   /**
    * A function that converts Java lists to lists.
+   * @deprecated As of 4.3, use {@link #JavaList_List}
    *
    * @return A function that converts Java lists to lists.
    */
   public static <A> F<java.util.List<A>, List<A>> JUList_List() {
-    return as -> Collection_List(as);
+    return as -> JavaList_List(as);
+  }
+
+  public static <A> F<java.util.List<A>, List<A>> JavaList_List() {
+    return as -> JavaList_List(as);
   }
-
+
+  public static <A> List<A> JavaList_List(java.util.List<A> list) {
+    return List.list(list);
+  }
+
   // BEGIN BitSet ->
 
   /**

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
@@ -1331,6 +1331,10 @@ public final A minimum(final Ord<A> o) {
     return foldLeft1(o.min);
   }
 
+  public final java.util.List<A> toJavaList() {
+    return new java.util.LinkedList<A>(toCollection());
+  }
+
   /**
    * Projects an immutable collection of this list.
    *
@@ -1412,6 +1416,15 @@ public static <A> List<A> list(final A... as) {
     return Array.array(as).toList();
   }
 
+
+  public static <A> List<A> list(final Iterable<A> i) {
+    return iterableList(i);
+  }
+
+  public static <A> List<A> list(final Iterator<A> it) {
+    return iterableList(() -> it);
+  }
+
   /**
    * Returns an empty list.
    *

diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
@@ -714,6 +714,16 @@ public static <A> Stream<A> stream(final A... as) {
                                                 : some(P.p(as[i], P.p(as, i + 1)))), P.p(as, 0));
   }
 
+
+  public static <A> Stream<A> stream(Iterable<A> it) {
+    return iterableStream(it);
+  }
+
+  public static <A> Stream<A> stream(Iterator<A> it) {
+    return iteratorStream(it);
+  }
+
+
   /**
    * Returns a stream that is either infinite or bounded up to the maximum value of the given iterator starting at the
    * given value and stepping at increments of <code>1</code>.

diff --git a/core/src/test/java/fj/data/ListTest.java b/core/src/test/java/fj/data/ListTest.java
@@ -1,8 +1,9 @@
 package fj.data;
 
-import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Arrays;
+
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ -30,4 +31,12 @@ public void objectMethods() {
 
     }
 
+    @Test
+    public void integration() {
+        java.util.List<Integer> ul = Arrays.asList(1, 2, 3);
+        List<Integer> dl = List.list(ul);
+        assertTrue(ul.equals(dl.toJavaList()));
+
+    }
+
 }
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
@@ -5,6 +5,7 @@
 import fj.function.Try1;
 import fj.function.Try2;
 
+import java.util.Iterator;
 import java.util.Optional;
 import java.util.Spliterator;
 import java.util.Spliterators;
@@ -95,6 +96,10 @@ static public <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B
         return t -> (a, b) -> Try.f(t).f(a, b);
     }
 
+    public static <A> java.util.stream.Stream<A> List_JavaStream(List<A> list) {
+        return Iterable_JavaStream(list);
+    }
+
     static public <A> Option<A> Optional_Option(final Optional<A> o) {
         return Java8.<A>Optional_Option().f(o);
     }
@@ -122,13 +127,32 @@ public static <A> F<A, Unit> Consumer_F(Consumer<A> c) {
         };
     }
 
-    static public <A> java.util.stream.Stream<A> Stream_JStream(fj.data.Stream<A> s) {
-        Spliterator<A> sit = Spliterators.spliteratorUnknownSize(s.iterator(), 0);
-        return StreamSupport.stream(sit, false);
+    static public <A> java.util.stream.Stream<A> Stream_JavaStream(fj.data.Stream<A> s) {
+        return Iterable_JavaStream(s);
+    }
+
+    static public <A> java.util.stream.Stream<A> Iterable_JavaStream(Iterable<A> it) {
+        return StreamSupport.stream(it.spliterator(), false);
+    }
+
+    static public <A> java.util.stream.Stream<A> Iterator_JavaStream(Iterator<A> it) {
+        return Iterable_JavaStream(() -> it);
+    }
+
+    static public <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
+        return s -> Stream_JavaStream(s);
+    }
+
+    static public <A> Stream<A> JavaStream_Stream(java.util.stream.Stream<A> s) {
+        return s.collect(Collectors.toStream());
+    }
+
+    static public <A> List<A> JavaStream_List(java.util.stream.Stream<A> s) {
+        return s.collect(Collectors.toList());
     }
 
-    static public <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JStream() {
-        return s -> Stream_JStream(s);
+    static public <A> Array<A> JavaStream_Array(java.util.stream.Stream<A> s) {
+        return s.collect(Collectors.toArray());
     }
 
 }