getPlantsOfStudent returns a list instead of an Array

fixed casing on newRowLocation variable
fixed misspelling of int

exercises/kindergarten-garden/src/example/java/KindergartenGarden.java

 public class KindergartenGarden {
     private String[] students;
     private String garden;
-    private final int PLANTS_PER_STUDENT_PER_ROW = 2;
-    private final nt NEW_ROW_LOCATION;
+    private static final int PLANTS_PER_STUDENT_PER_ROW = 2;
+    private final int newRowLocation;
 
-    private final static String[] DEFAULT_STUDENTS = {
+    private static final String[] DEFAULT_STUDENTS = {
             "Alice", "Bob", "Charlie", "David",
             "Eve", "Fred", "Ginny", "Harriet",
             "Ileana", "Joseph", "Kincaid", "Larry"
         this.garden = garden;
         Arrays.sort(students);
         this.students = students;
-        NEW_ROW_LOCATION = garden.indexOf('\n') + 1;
+        newRowLocation = garden.indexOf('\n') + 1;
     }
 
     public KindergartenGarden(String garden) {
         this(garden, DEFAULT_STUDENTS);
     }
 
-    public Plant[] getPlantsOfStudent(String student) {
+    public List<Plant> getPlantsOfStudent(String student) {
         List<Plant> plants = new ArrayList<Plant>();
         int studentPlantsIndex = Arrays.binarySearch(students, student) * PLANTS_PER_STUDENT_PER_ROW;
 
             plants.add(Plant.getPlant(garden.charAt(i)));
         }
 
-        for (int i = NEW_ROW_LOCATION + studentPlantsIndex;
-             i < NEW_ROW_LOCATION + studentPlantsIndex + PLANTS_PER_STUDENT_PER_ROW; i++) {
+        for (int i = newRowLocation + studentPlantsIndex;
+             i < newRowLocation + studentPlantsIndex + PLANTS_PER_STUDENT_PER_ROW; i++) {
             plants.add(Plant.getPlant(garden.charAt(i)));
         }
 
-        return plants.toArray(new Plant[0]);
+        return plants;
     }
 }

exercises/kindergarten-garden/src/main/java/KindergartenGarden.java

+import java.util.List;
+
 public class KindergartenGarden {
     public KindergartenGarden(String garden, String[] students) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    public Plant[] getPlantsOfStudent(String student) {
+    public List<Plant> getPlantsOfStudent(String student) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 }

exercises/kindergarten-garden/src/test/java/KindergartenGardenTest.java

+import java.util.List;
+import java.util.Arrays;
+
 import org.junit.Test;
 import org.junit.Ignore;
 
     public void singleStudent() {
         String student = "Alice";
         String plants = "RC\nGG";
-        Plant[] expected = {Plant.RADISHES, Plant.CLOVER, Plant.GRASS, Plant.GRASS};
+        List<Plant> expected = Arrays.asList(Plant.RADISHES, Plant.CLOVER, Plant.GRASS, Plant.GRASS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void singleStudent2() {
         String student = "Alice";
         String plants = "VC\nRC";
-        Plant[] expected = {Plant.VIOLETS, Plant.CLOVER, Plant.RADISHES, Plant.CLOVER};
+        List<Plant> expected = Arrays.asList(Plant.VIOLETS, Plant.CLOVER, Plant.RADISHES, Plant.CLOVER);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void twoStudents() {
         String student = "Bob";
         String plants = "VVCG\nVVRC";
-        Plant[] expected = {Plant.CLOVER, Plant.GRASS, Plant.RADISHES, Plant.CLOVER};
+        List<Plant> expected = Arrays.asList(Plant.CLOVER, Plant.GRASS, Plant.RADISHES, Plant.CLOVER);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void oneGardenSecondStudent() {
         String student = "Bob";
         String plants = "VVCCGG\nVVCCGG";
-        Plant[] expected = {Plant.CLOVER, Plant.CLOVER, Plant.CLOVER, Plant.CLOVER};
+        List<Plant> expected = Arrays.asList(Plant.CLOVER, Plant.CLOVER, Plant.CLOVER, Plant.CLOVER);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void oneGardenThirdStudent() {
         String student = "Charlie";
         String plants = "VVCCGG\nVVCCGG";
-        Plant[] expected = {Plant.GRASS, Plant.GRASS, Plant.GRASS, Plant.GRASS};
+        List<Plant> expected = Arrays.asList(Plant.GRASS, Plant.GRASS, Plant.GRASS, Plant.GRASS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void fullGardenFirstStudent() {
         String student = "Alice";
         String plants = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV";
-        Plant[] expected = {Plant.VIOLETS, Plant.RADISHES, Plant.VIOLETS, Plant.RADISHES};
+        List<Plant> expected = Arrays.asList(Plant.VIOLETS, Plant.RADISHES, Plant.VIOLETS, Plant.RADISHES);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void fullGardenSecondStudent() {
         String student = "Bob";
         String plants = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV";
-        Plant[] expected = {Plant.CLOVER, Plant.GRASS, Plant.CLOVER, Plant.CLOVER};
+        List<Plant> expected = Arrays.asList(Plant.CLOVER, Plant.GRASS, Plant.CLOVER, Plant.CLOVER);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void fullGardenSecondToLastStudent() {
         String student = "Kincaid";
         String plants = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV";
-        Plant[] expected = {Plant.GRASS, Plant.CLOVER, Plant.CLOVER, Plant.GRASS};
+        List<Plant> expected = Arrays.asList(Plant.GRASS, Plant.CLOVER, Plant.CLOVER, Plant.GRASS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void fullGardenLastStudent() {
         String student = "Larry";
         String plants = "VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV";
-        Plant[] expected = {Plant.GRASS, Plant.VIOLETS, Plant.CLOVER, Plant.VIOLETS};
+        List<Plant> expected = Arrays.asList(Plant.GRASS, Plant.VIOLETS, Plant.CLOVER, Plant.VIOLETS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void customStudentGardenFirstStudent() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Patricia";
         String plants = "VCRRGVRG\nRVGCCGCV";
-        Plant[] expected = {Plant.VIOLETS, Plant.CLOVER, Plant.RADISHES, Plant.VIOLETS};
+        List<Plant> expected = Arrays.asList(Plant.VIOLETS, Plant.CLOVER, Plant.RADISHES, Plant.VIOLETS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void customStudentGardenSecondStudent() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Roger";
         String plants = "VCRRGVRG\nRVGCCGCV";
-        Plant[] expected = {Plant.RADISHES, Plant.RADISHES, Plant.GRASS, Plant.CLOVER};
+        List<Plant> expected = Arrays.asList(Plant.RADISHES, Plant.RADISHES, Plant.GRASS, Plant.CLOVER);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void customStudentGardenThirdStudent() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Samantha";
         String plants = "VCRRGVRG\nRVGCCGCV";
-        Plant[] expected = {Plant.GRASS, Plant.VIOLETS, Plant.CLOVER, Plant.GRASS};
+        List<Plant> expected = Arrays.asList(Plant.GRASS, Plant.VIOLETS, Plant.CLOVER, Plant.GRASS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
+        );
     }
 
-    @Ignore("Remove to run test")
+    //@Ignore("Remove to run test")
     @Test
     public void customStudentGardenFourthStudent() {
         String[] studentArray = {"Samantha", "Patricia", "Xander", "Roger"};
         String student = "Xander";
         String plants = "VCRRGVRG\nRVGCCGCV";
-        Plant[] expected = {Plant.RADISHES, Plant.GRASS, Plant.CLOVER, Plant.VIOLETS};
+        List<Plant> expected = Arrays.asList(Plant.RADISHES, Plant.GRASS, Plant.CLOVER, Plant.VIOLETS);
 
-        assertEquals(expected,
-                new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student));
+        assertEquals(
+            expected,
+            new KindergartenGarden(plants, studentArray).getPlantsOfStudent(student)
+        );
     }
 }