Merge pull request #868 from FridaTveit/BinarySearchUseGenerics

binary-search: use generics

config.json

       "uuid": "76d28d97-75d3-47eb-bb77-3d347b76f1b6"
     },
     {
-      "core": true,
-      "difficulty": 6,
-      "slug": "linked-list",
-      "topics": [
-        "algorithms",
-        "lists",
-        "generics"
-      ],
-      "unlocked_by": null,
-      "uuid": "7ba5084d-3b75-4406-a0d7-87c26387f9c0"
-    },
-    {
       "core": false,
       "difficulty": 6,
       "slug": "grade-school",
       "uuid": "4b3f7771-c642-4278-a3d9-2fb958f26361"
     },
     {
+      "core": true,
+      "difficulty": 6,
+      "slug": "linked-list",
+      "topics": [
+        "algorithms",
+        "lists",
+        "generics"
+      ],
+      "unlocked_by": null,
+      "uuid": "7ba5084d-3b75-4406-a0d7-87c26387f9c0"
+    },
+    {
       "core": false,
       "difficulty": 6,
       "slug": "tournament",

exercises/binary-search/.meta/hints.md

+This exercise introduces [generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html).
+To make the tests pass you need to construct your class such that it accepts any type of input, e.g. `Integer` or `String`.
+
+Generics are useful because they allow you to write more general and reusable code.
+The Java [List](https://docs.oracle.com/javase/8/docs/api/java/util/List.html) and [Map](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html) implementations are both examples of classes that use generics.
+By using them you can construct a `List` containing `Integers` or a list containing `Strings` or any other type.
+
+There are a few constraints on the types used in generics.
+One of them is that once you've constructed a `List` containing `Integers`, you can't put `Strings` into it.
+You have to specify which type you want to put into the class when you construct it, and that instance can then only be used with that type.
+
+For example you could construct a list of `Integers`:
+
+`List<Integer> someList = new LinkedList<>();`
+
+Now `someList` can only contain `Integers`. You could also do:
+
+`List<String> someOtherList = new LinkedList<>()`
+
+Now `someOtherList` can only contain `Strings`.
+
+Another constraint is that any type used with generics cannot be a [primitive type](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html), such as `int` or `long`.
+However, every primitive type has a corresponding reference type, so instead of `int` you can use [`Integer`](https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html) and instead of `long` you can use [`Long`](https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html).
+
+It can help to look at an [example use case of generics](https://docs.oracle.com/javase/tutorial/java/generics/types.html) to get you started.

exercises/binary-search/.meta/src/reference/java/BinarySearch.java

 
 import java.util.List;
 
-public class BinarySearch<T extends Comparable<T>> {
+class BinarySearch<T extends Comparable<T>> {
 
     private List<T> array;
     private int arraySize;
 
-    public BinarySearch(List<T> array) {
+    BinarySearch(List<T> array) {
         this.array = array;
         this.arraySize = array.size();
     }
 
-    public int indexOf(T value) {
+    int indexOf(T value) {
         return search(value);
     }
 
-    public List<T> getArray() {
-        return array;
-    }
-
     private int search(T value) {
         int left = 0;
         int right = this.arraySize - 1;

exercises/binary-search/src/test/java/BinarySearchTest.java

 
     @Test
     public void findsAValueInAnArrayWithOneElement() {
-        List<Integer> listOfUnitLength = Collections.singletonList(6);
+        List<Character> listOfUnitLength = Collections.singletonList('6');
 
-        BinarySearch<Integer> search = new BinarySearch<>(listOfUnitLength);
+        BinarySearch<Character> search = new BinarySearch<>(listOfUnitLength);
 
-        assertEquals(0, search.indexOf(6));
+        assertEquals(0, search.indexOf('6'));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void findsAValueInTheMiddleOfAnArray() {
-        List<Integer> sortedList = Collections.unmodifiableList(
-                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        List<String> sortedList = Collections.unmodifiableList(
+                Arrays.asList("1", "3", "4", "6", "8", "9", "11")
         );
 
-        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+        BinarySearch<String> search = new BinarySearch<>(sortedList);
 
-        assertEquals(3, search.indexOf(6));
+        assertEquals(3, search.indexOf("6"));
     }
 
     @Ignore("Remove to run test")
     @Ignore("Remove to run test")
     @Test
     public void identifiesThatAValueIsNotIncludedInTheArray() {
-        List<Integer> sortedList = Collections.unmodifiableList(
-                Arrays.asList(1, 3, 4, 6, 8, 9, 11)
+        List<String> sortedList = Collections.unmodifiableList(
+                Arrays.asList("1", "3", "4", "6", "8", "9", "11")
         );
 
-        BinarySearch<Integer> search = new BinarySearch<>(sortedList);
+        BinarySearch<String> search = new BinarySearch<>(sortedList);
 
-        assertEquals(-1, search.indexOf(7));
+        assertEquals(-1, search.indexOf("7"));
     }
 
     @Ignore("Remove to run test")