Skip to content

Commit 1e40671

Browse files
jbgijbgi
committed
Array: simpler conversion to jdk collections
1 parent 93a003e commit 1e40671

File tree

3 files changed

+49
-66
lines changed

3 files changed

+49
-66
lines changed

‎core/src/main/java/fj/data/Array.java‎

Lines changed: 15 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,9 @@
1313

1414
import java.util.AbstractCollection;
1515
import java.util.ArrayList;
16+
import java.util.Arrays;
1617
import java.util.Collection;
18+
import java.util.Collections;
1719
import java.util.Iterator;
1820
import java.util.NoSuchElementException;
1921

@@ -775,44 +777,25 @@ public Array<P2<A, Integer>> zipIndex() {
775777
*
776778
* @return An immutable collection of this array.
777779
*/
778-
@SuppressWarnings("unchecked")
779780
public Collection<A> toCollection() {
780-
return new AbstractCollection<A>() {
781-
public Iterator<A> iterator() {
782-
return new Iterator<A>() {
783-
private int i;
784-
785-
public boolean hasNext() {
786-
return i < a.length;
787-
}
788-
789-
public A next() {
790-
if (i >= a.length)
791-
throw new NoSuchElementException();
792-
else {
793-
final A aa = (A) a[i];
794-
i++;
795-
return aa;
796-
}
797-
}
798-
799-
public void remove() {
800-
throw new UnsupportedOperationException();
801-
}
802-
};
803-
}
781+
return asJavaList();
782+
}
804783

805-
public int size() {
806-
return a.length;
807-
}
808-
};
784+
/**
785+
* Projects an unmodifiable list view of this array.
786+
*
787+
* @return An unmodifiable list view of this array.
788+
*/
789+
@SuppressWarnings("unchecked")
790+
public java.util.List<A> asJavaList() {
791+
return Collections.unmodifiableList(Arrays.asList((A[]) a));
809792
}
810793

811794
/**
812-
* Returns a standard java.util.List projection of this array.
795+
* Returns a java.util.ArrayList projection of this array.
813796
*/
814-
java.util.List<A> toJavaList() {
815-
return new ArrayList<>(toCollection());
797+
public ArrayList<A> toJavaList() {
798+
return new ArrayList<>(asJavaList());
816799
}
817800

818801
/**

‎core/src/main/java/fj/data/Java.java‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -227,7 +227,7 @@ public static <A> F<List<A>, SynchronousQueue<A>> List_SynchronousQueue(final bo
227227
* @return A function that converts arrays to array lists.
228228
*/
229229
public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
230-
return as -> new ArrayList<>(as.toCollection());
230+
return Array::toJavaList;
231231
}
232232

233233
/**
@@ -246,7 +246,7 @@ public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
246246
* @return A function that converts arrays to enum sets.
247247
*/
248248
public static <A extends Enum<A>> F<Array<A>, EnumSet<A>> Array_EnumSet() {
249-
return as -> copyOf(as.toCollection());
249+
return as -> copyOf(as.asJavaList());
250250
}
251251

252252
/**
@@ -255,7 +255,7 @@ public static <A extends Enum<A>> F<Array<A>, EnumSet<A>> Array_EnumSet() {
255255
* @return A function that converts arrays to hash sets.
256256
*/
257257
public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
258-
return as -> new HashSet<>(as.toCollection());
258+
return as -> new HashSet<>(as.asJavaList());
259259
}
260260

261261
/**
@@ -264,7 +264,7 @@ public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
264264
* @return A function that converts arrays to linked hash sets.
265265
*/
266266
public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
267-
return as -> new LinkedHashSet<>(as.toCollection());
267+
return as -> new LinkedHashSet<>(as.asJavaList());
268268
}
269269

270270
/**
@@ -273,7 +273,7 @@ public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
273273
* @return A function that converts arrays to linked lists.
274274
*/
275275
public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
276-
return as -> new LinkedList<>(as.toCollection());
276+
return as -> new LinkedList<>(as.asJavaList());
277277
}
278278

279279
/**
@@ -282,7 +282,7 @@ public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
282282
* @return A function that converts arrays to priority queues.
283283
*/
284284
public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
285-
return as -> new PriorityQueue<>(as.toCollection());
285+
return as -> new PriorityQueue<>(as.asJavaList());
286286
}
287287

288288
/**
@@ -293,7 +293,7 @@ public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
293293
public static <A> F<Array<A>, Stack<A>> Array_Stack() {
294294
return as -> {
295295
final Stack<A> s = new Stack<>();
296-
s.addAll(as.toCollection());
296+
s.addAll(as.asJavaList());
297297
return s;
298298
};
299299
}
@@ -304,7 +304,7 @@ public static <A> F<Array<A>, Stack<A>> Array_Stack() {
304304
* @return A function that converts arrays to tree sets.
305305
*/
306306
public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
307-
return as -> new TreeSet<>(as.toCollection());
307+
return as -> new TreeSet<>(as.asJavaList());
308308
}
309309

310310
/**
@@ -313,7 +313,7 @@ public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
313313
* @return A function that converts arrays to vectors.
314314
*/
315315
public static <A> F<Array<A>, Vector<A>> Array_Vector() {
316-
return as -> new Vector<>(as.toCollection());
316+
return as -> new Vector<>(as.asJavaList());
317317
}
318318

319319
/**
@@ -323,7 +323,7 @@ public static <A> F<Array<A>, Vector<A>> Array_Vector() {
323323
* @return A function that converts arrays to array blocking queues.
324324
*/
325325
public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(final boolean fair) {
326-
return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
326+
return as -> new ArrayBlockingQueue<>(as.length(), fair, as.asJavaList());
327327
}
328328

329329
/**
@@ -332,7 +332,7 @@ public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(fi
332332
* @return A function that converts arrays to concurrent linked queues.
333333
*/
334334
public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQueue() {
335-
return as -> new ConcurrentLinkedQueue<>(as.toCollection());
335+
return as -> new ConcurrentLinkedQueue<>(as.asJavaList());
336336
}
337337

338338
/**
@@ -341,7 +341,7 @@ public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQu
341341
* @return A function that converts arrays to copy on write array lists.
342342
*/
343343
public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayList() {
344-
return as -> new CopyOnWriteArrayList<>(as.toCollection());
344+
return as -> new CopyOnWriteArrayList<>(as.asJavaList());
345345
}
346346

347347
/**
@@ -350,7 +350,7 @@ public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayLis
350350
* @return A function that converts arrays to copy on write array sets.
351351
*/
352352
public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet() {
353-
return as -> new CopyOnWriteArraySet<>(as.toCollection());
353+
return as -> new CopyOnWriteArraySet<>(as.asJavaList());
354354
}
355355

356356
/**
@@ -359,7 +359,7 @@ public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet(
359359
* @return A function that converts arrays to delay queues.
360360
*/
361361
public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue() {
362-
return as -> new DelayQueue<>(as.toCollection());
362+
return as -> new DelayQueue<>(as.asJavaList());
363363
}
364364

365365
/**
@@ -368,7 +368,7 @@ public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue()
368368
* @return A function that converts arrays to linked blocking queues.
369369
*/
370370
public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue() {
371-
return as -> new LinkedBlockingQueue<>(as.toCollection());
371+
return as -> new LinkedBlockingQueue<>(as.asJavaList());
372372
}
373373

374374
/**
@@ -377,7 +377,7 @@ public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue(
377377
* @return A function that converts arrays to priority blocking queues.
378378
*/
379379
public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQueue() {
380-
return as -> new PriorityBlockingQueue<>(as.toCollection());
380+
return as -> new PriorityBlockingQueue<>(as.asJavaList());
381381
}
382382

383383
/**
@@ -389,7 +389,7 @@ public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQu
389389
public static <A> F<Array<A>, SynchronousQueue<A>> Array_SynchronousQueue(final boolean fair) {
390390
return as -> {
391391
final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
392-
q.addAll(as.toCollection());
392+
q.addAll(as.asJavaList());
393393
return q;
394394
};
395395
}

‎quickcheck/src/main/java/fj/test/Arbitrary.java‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -753,7 +753,7 @@ public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
753753
* @return An arbitrary implementation for array lists.
754754
*/
755755
public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
756-
return arbitrary(arbArray(aa).gen.map(a -> new ArrayList<>(a.toCollection())));
756+
return arbitrary(arbArray(aa).gen.map(Array::toJavaList));
757757
}
758758

759759
/**
@@ -810,7 +810,7 @@ public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final A
810810
* @return An arbitrary implementation for enum sets.
811811
*/
812812
public static <A extends Enum<A>> Arbitrary<EnumSet<A>> arbEnumSet(final Arbitrary<A> aa) {
813-
return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.toCollection())));
813+
return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.asJavaList())));
814814
}
815815

816816
/**
@@ -842,7 +842,7 @@ public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak,
842842
* @return An arbitrary implementation for hash sets.
843843
*/
844844
public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
845-
return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.toCollection())));
845+
return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.asJavaList())));
846846
}
847847

848848
/**
@@ -898,7 +898,7 @@ public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbit
898898
* @return An arbitrary implementation for hash sets.
899899
*/
900900
public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A> aa) {
901-
return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.toCollection())));
901+
return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.asJavaList())));
902902
}
903903

904904
/**
@@ -908,7 +908,7 @@ public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A
908908
* @return An arbitrary implementation for linked lists.
909909
*/
910910
public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa) {
911-
return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.toCollection())));
911+
return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.asJavaList())));
912912
}
913913

914914
/**
@@ -918,7 +918,7 @@ public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa)
918918
* @return An arbitrary implementation for priority queues.
919919
*/
920920
public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A> aa) {
921-
return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.toCollection())));
921+
return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.asJavaList())));
922922
}
923923

924924
/**
@@ -944,7 +944,7 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
944944
public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
945945
return arbitrary(arbArray(aa).gen.map(a -> {
946946
final Stack<A> s = new Stack<>();
947-
s.addAll(a.toCollection());
947+
s.addAll(a.asJavaList());
948948
return s;
949949
}));
950950
}
@@ -1005,7 +1005,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
10051005
* @return An arbitrary implementation for tree sets.
10061006
*/
10071007
public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
1008-
return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.toCollection())));
1008+
return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.asJavaList())));
10091009
}
10101010

10111011
/**
@@ -1016,7 +1016,7 @@ public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
10161016
*/
10171017
@SuppressWarnings("UseOfObsoleteCollectionType")
10181018
public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
1019-
return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.toCollection())));
1019+
return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.asJavaList())));
10201020
}
10211021

10221022
/**
@@ -1046,7 +1046,7 @@ public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary
10461046
public static <A> Arbitrary<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Arbitrary<A> aa) {
10471047
return arbitrary(arbArray(aa).gen.bind(arbInteger.gen, arbBoolean.gen,
10481048
a -> capacity -> fair -> new ArrayBlockingQueue<A>(a.length() + abs(capacity),
1049-
fair, a.toCollection())));
1049+
fair, a.asJavaList())));
10501050
}
10511051

10521052
/**
@@ -1071,7 +1071,7 @@ public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(fin
10711071
* @return An arbitrary implementation for concurrent linked queues.
10721072
*/
10731073
public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Arbitrary<A> aa) {
1074-
return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.toCollection())));
1074+
return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.asJavaList())));
10751075
}
10761076

10771077
/**
@@ -1082,7 +1082,7 @@ public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(f
10821082
* @return An arbitrary implementation for copy-on-write array lists.
10831083
*/
10841084
public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Arbitrary<A> aa) {
1085-
return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.toCollection())));
1085+
return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.asJavaList())));
10861086
}
10871087

10881088
/**
@@ -1093,7 +1093,7 @@ public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(fin
10931093
* @return An arbitrary implementation for copy-on-write array sets.
10941094
*/
10951095
public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Arbitrary<A> aa) {
1096-
return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.toCollection())));
1096+
return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.asJavaList())));
10971097
}
10981098

10991099
/**
@@ -1103,7 +1103,7 @@ public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final
11031103
* @return An arbitrary implementation for delay queues.
11041104
*/
11051105
public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final Arbitrary<A> aa) {
1106-
return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.toCollection())));
1106+
return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.asJavaList())));
11071107
}
11081108

11091109
/**
@@ -1114,7 +1114,7 @@ public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final A
11141114
* @return An arbitrary implementation for linked blocking queues.
11151115
*/
11161116
public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Arbitrary<A> aa) {
1117-
return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.toCollection())));
1117+
return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.asJavaList())));
11181118
}
11191119

11201120
/**
@@ -1125,7 +1125,7 @@ public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final
11251125
* @return An arbitrary implementation for priority blocking queues.
11261126
*/
11271127
public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Arbitrary<A> aa) {
1128-
return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.toCollection())));
1128+
return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.asJavaList())));
11291129
}
11301130

11311131
/**
@@ -1138,7 +1138,7 @@ public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(f
11381138
public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbitrary<A> aa) {
11391139
return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, a -> fair -> {
11401140
final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
1141-
q.addAll(a.toCollection());
1141+
q.addAll(a.asJavaList());
11421142
return q;
11431143
}));
11441144
}

0 commit comments

Comments
 (0)