@@ -51,6 +51,8 @@ public static void main(String[] args) {
       Arrays.copyOf(d, d.length, Sup[].class); // [4]
     show(b);
 
+//    Arrays.setAll(b, Sup::new);
+
     // This "downcast" works fine:
     Sub[] d2 =
       Arrays.copyOf(b, b.length, Sub[].class); // [5]
 
@@ -8,9 +8,9 @@ public class ArrayOfGenericType<T> {
   @SuppressWarnings("unchecked")
   public ArrayOfGenericType(int size) {
     // error: generic array creation:
-    //- array = new T[size];
+//    array = new T[size];
     array = (T[])new Object[size]; // unchecked cast
   }
   // error: generic array creation:
-  //- public <U> U[] makeArray() { return new U[10]; }
+//  public <U> U[] makeArray() { return new U[10]; }
 }
@@ -12,22 +12,28 @@ public static void main(String[] args) {
     ls = (List<String>[])la; // Unchecked cast
     ls[0] = new ArrayList<>();
 
-    //- ls[1] = new ArrayList<Integer>();
+//    ls[1] = new ArrayList<Integer>();
     // error: incompatible types: ArrayList<Integer>
     // cannot be converted to List<String>
     //     ls[1] = new ArrayList<Integer>();
-    //             ^
+
+    ls[1] = new ArrayList<String>();
 
     // The problem: List<String> is a subtype of Object
     Object[] objects = ls; // So assignment is OK
     // Compiles and runs without complaint:
     objects[1] = new ArrayList<>();
 
+    objects[2] = new ArrayList<Integer>();
+
     // However, if your needs are straightforward it is
     // possible to create an array of generics, albeit
     // with an "unchecked cast" warning:
     List<BerylliumSphere>[] spheres =
       (List<BerylliumSphere>[])new List[10];
     Arrays.setAll(spheres, n -> new ArrayList<>());
+
+    System.out.println(spheres);
+
   }
 }
@@ -15,6 +15,7 @@ public static void main(String[] args) {
     show("Sorted array", a);
     while(true) {
       int r = rand.getAsInt();
+//      r = 1000;
       int location = Arrays.binarySearch(a, r);
       if(location >= 0) {
         System.out.println(
 
@@ -8,14 +8,14 @@
 
 public class CountUpward {
   static long[] fillCounted(int size) {
-    return LongStream.iterate(0, i -> i + 1)
+    return LongStream.iterate(10, i -> i + 2)
       .limit(size).toArray();
   }
   public static void main(String[] args) {
     long[] l1 = fillCounted(20); // No problem
     show(l1);
     // On my machine, this runs out of heap space:
-    //- long[] l2 = fillCounted(10_000_000);
+//     long[] l2 = fillCounted(10_000_000);
   }
 }
 /* Output:
 
@@ -32,6 +32,15 @@ public static void main(String[] args) {
     Arrays.setAll(ia, n -> val++);             // [2]
     Arrays.setAll(la, n -> val++);
     Arrays.setAll(da, n -> val++);
+
+    show(ia);
+    show(la);
+    show(da);
+
+    Arrays.setAll(ia, n -> n*2);
+    Arrays.setAll(la, n -> n* 2L);
+    Arrays.setAll(da, n -> n*2);
+
     show(ia);
     show(la);
     show(da);
 
@@ -4,6 +4,7 @@
 // Visit http://OnJava8.com for more book information.
 import java.util.*;
 import onjava.*;
+import onjava.ConvertTo;
 
 public class StreamFromArray {
   public static void main(String[] args) {
Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,9 @@ public class ArrayOfGenericType<T> {`
`8`	`8`	`@SuppressWarnings("unchecked")`
`9`	`9`	`public ArrayOfGenericType(int size) {`
`10`	`10`	`// error: generic array creation:`
`11`		`- //- array = new T[size];`
	`11`	`+// array = new T[size];`
`12`	`12`	`array = (T[])new Object[size]; // unchecked cast`
`13`	`13`	`}`
`14`	`14`	`// error: generic array creation:`
`15`		`- //- public <U> U[] makeArray() { return new U[10]; }`
	`15`	`+// public <U> U[] makeArray() { return new U[10]; }`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,14 @@`
`8`	`8`
`9`	`9`	`public class CountUpward {`
`10`	`10`	`static long[] fillCounted(int size) {`
`11`		`- return LongStream.iterate(0, i -> i + 1)`
	`11`	`+ return LongStream.iterate(10, i -> i + 2)`
`12`	`12`	`.limit(size).toArray();`
`13`	`13`	`}`
`14`	`14`	`public static void main(String[] args) {`
`15`	`15`	`long[] l1 = fillCounted(20); // No problem`
`16`	`16`	`show(l1);`
`17`	`17`	`// On my machine, this runs out of heap space:`
`18`		`- //- long[] l2 = fillCounted(10_000_000);`
	`18`	`+// long[] l2 = fillCounted(10_000_000);`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`/* Output:`