finished yayyyyy

src/main/java/io/zipcoder/Classroom.java

@@ -1,4 +1,116 @@
 package io.zipcoder;
 
+import java.util.*;
+
+import static java.util.Arrays.sort;
+
 public class Classroom {
+    private Integer currentAmountOfStudents;
+    private Integer maxNumberOfStudents;
+    private Student[] students;
+
+    public Classroom(Integer maxNumberOfStudents){
+        students = new Student[maxNumberOfStudents];
+        this.maxNumberOfStudents = maxNumberOfStudents;
+        currentAmountOfStudents = 0;
+    }
+    public Classroom(Student[] students) {
+        this.students = students;
+        currentAmountOfStudents = students.length;
+        maxNumberOfStudents = students.length;
+    }
+    public Classroom(){
+        this(30);
+    }
+    public Student[] getStudents(){
+        List<Student> studentList = new ArrayList<>();
+        for (Student student: students)
+            if (student != null)
+                studentList.add(student);
+            return studentList.toArray(new Student[studentList.size()]);
+    }
+    private Integer studentNoScores(){
+        Integer count = 0;
+        for(Student student : getStudents())
+            if (student.getNumberOfExamsTaken() == 0)
+                count ++;
+
+            return count;
+    }
+    public Double getAverageExamScore(){
+        Double sumOfAverageScore = 0.0;
+        Student[] allStudents = getStudents();
+        for(Student student : allStudents)
+            sumOfAverageScore += student.getAverageExamScore();
+
+        return sumOfAverageScore / (double) (allStudents.length - studentNoScores());
+    }
+    public Boolean addStudent(Student student) {
+        for (Integer index = 0; index < students.length; index++)
+            if (students[index] == null) {
+                students[index] = student;
+                currentAmountOfStudents++;
+                return true;
+            }
+        return false;
+    }
+    public Student[] getStudentUseScore(){
+        Comparator<Student> nameComparator = Comparator.comparing(Student::getAverageExamScore).reversed().thenComparing(Student::getLastName);
+        Student[] sortedStudents = getStudents();
+        Arrays.sort(sortedStudents, nameComparator);
+
+        return sortedStudents;
+    }
+    public void removeStudent(String firstName, String lastName){
+        List<Student> studentList = new ArrayList<>(Arrays.asList(students));
+        for (Student student : getStudents()){
+            if (student.getFirstName().equals(firstName) && student.getLastName().equals(lastName)){
+                studentList.remove(student);
+                currentAmountOfStudents--;
+                break;
+            }
+        }
+        students = studentList.toArray(new Student[maxNumberOfStudents]);
+    }
+    public HashMap getGradeBook(){
+        HashMap<Student, Character> grades = new HashMap<>();
+        Student[] sortedStudents = getStudentUseScore();
+        Integer rankings = 1;
+
+        for(Student student : sortedStudents){
+            double percentGrades = ((double)(rankings) / (double)currentAmountOfStudents) * (double)100;
+
+            if(student.getNumberOfExamsTaken() == 0)
+                grades.put(student, ' ');
+            else if (percentGrades <= 10)
+                grades.put(student, 'A');
+            else if (percentGrades <= 29)
+                grades.put(student, 'B');
+            else if (percentGrades <= 50)
+                grades.put(student, 'C');
+            else if (percentGrades <= 89)
+                grades.put(student, 'D');
+            else
+                grades.put(student, 'F');
+            rankings++;
+        }
+        return grades;
+    }
+    public void printGrades(){
+        HashMap grades = getGradeBook();
+        for(Student student : getStudentUseScore())
+            System.out.print(student.getFirstName() + " " + student.getLastName() + ", " + grades.get(student));
+    }
+    @Override
+    public String toString(){
+        String names = "";
+        Student[] allStudents = getStudents();
+        for(Student student : allStudents)
+            names += (student.getFirstName() + " " + student.getLastName() + "\n");
+
+        return "Class room: \n"
+                + "Capacity of classroom: " + maxNumberOfStudents + "\n"
+                + "Current amount of students: " + currentAmountOfStudents + "\n"
+                + names;
+    }
 }

src/main/java/io/zipcoder/Grade.java

@@ -0,0 +1,23 @@
+package io.zipcoder;
+
+public class Grade {
+    private Character grade;
+    private Student student;
+
+    public Grade(Student student, Character grade){
+        this.grade = grade;
+        this.student = student;
+    }
+    public Student getStudent(){
+        return student;
+    }
+    public Character getGrade(){
+        return grade;
+    }
+
+    @Override
+    public String toString(){
+        return String.format("%s %s, Grade: %c/n",
+                student.getFirstName(),student.getLastName(),grade);
+    }
+}

src/main/java/io/zipcoder/GradeBook.java

@@ -0,0 +1,21 @@
+package io.zipcoder;
+
+import java.util.Arrays;
+
+public class GradeBook {
+    private Grade[] grades;
+
+    public GradeBook(Grade[] grades){
+        this.grades = grades;
+    }
+    public Grade[] getGrades() {
+        return grades;
+    }
+    @Override
+    public String toString(){
+        String result = "";
+        for(Grade grade: grades)
+            result += grade.toString();
+        return result;
+    }
+}

src/main/java/io/zipcoder/Student.java

@@ -1,4 +1,68 @@
 package io.zipcoder;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 public class Student {
+    String firstName;
+    String lastName;
+    ArrayList<Double> examScores;
+
+    public Student(String firstName, String lastName, Double[] testScores){
+        this.firstName = firstName;
+        this.lastName = lastName;
+        if (testScores != null)
+        examScores = new ArrayList(Arrays.asList(testScores));
+    }
+    public String getFirstName(){
+        return firstName;
+}
+    public void setFirstName(String newName){
+        firstName = newName;
+}
+    public String getLastName(){
+        return lastName;
+}
+    public void setLastName(String newLastName){
+        lastName = newLastName;
+}
+    public Integer getNumberOfExamsTaken(){
+        return examScores == null ? 0 : examScores.size();
+    }
+    public String getExamScores(){
+        String output = "";
+        Integer examNum = 1;
+        for(Double i : examScores)
+            output += "Exam " + examNum++ + " -> " + i + "\n";
+
+        return output;
+    }
+    public void addExamScore(Double examScore) {
+        if (examScore == null)
+            examScores = new ArrayList<>(0);
+
+        else
+            examScores.add(examScore);
+    }
+    public void setExamScores(Integer nthExam, Double examScore){
+        examScores.set(nthExam - 1, examScore);
+    }
+    public Double getExamScore(Integer nthExam){
+        return examScores.get(nthExam - 1);
+    }
+    public Double getAverageExamScore(){
+        Double sum = 0.0;
+        if (examScores == null)
+            return 0.0;
+
+        for (Double score : examScores)
+            sum += score;
+        return sum / (double) getNumberOfExamsTaken();
+    }
+    @Override
+    public String toString(){
+        return String.format("Student Name: %s %s\n"+
+                "> Average Score: %f\n"+
+                "%s", firstName, lastName, getAverageExamScore(), getExamScores());
+    }
 }

src/test/java/io/zipcoder/ClassroomTest.java

@@ -1,4 +1,85 @@
 package io.zipcoder;
 
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.HashMap;
+
 public class ClassroomTest {
-}
+    private Classroom presetRoom;
+    private Classroom presetRoomWithStudent;
+    private Classroom presetRoomMultipleStudents;
+    private final double DELTA = 0.001;
+    private Student[] presetStudent = new Student[]{
+            new Student(" Phamdy", "Sand", new Double[]{90.0, 89.0}),
+            new Student(" Sandy", "Pham", new Double[]{99.0, 95.0, 91.0}),
+            new Student(" Sandicus", "Phamicus", null)
+    };
+
+    @Before
+    public void settings() {
+        presetRoomWithStudent = new Classroom(presetStudent);
+        presetRoomMultipleStudents = new Classroom(10);
+        presetRoom = new Classroom();
+
+        presetRoomMultipleStudents.addStudent(presetStudent[0]);
+        presetRoomMultipleStudents.addStudent(presetStudent[1]);
+    }
+    @Test
+    public void getGrades(){
+        HashMap<Student, Character> expected = new HashMap<>();
+        expected.put(presetStudent[0], 'D');
+        expected.put(presetStudent[1], 'C');
+        expected.put(presetStudent[2], ' ');
+
+        Assert.assertEquals(expected, presetRoomWithStudent.getGradeBook());
+    }
+    @Test
+    public void getAverageExamScoreMultiple(){
+        Assert.assertEquals(92.25, presetRoomMultipleStudents.getAverageExamScore(), DELTA);
+    }
+    @Test
+    public void getAverageExamScorePresetStudent(){
+        Assert.assertEquals(92.25, presetRoomWithStudent.getAverageExamScore(), DELTA);
+    }
+    @Test
+    public void addStudentPresetRoomBool(){
+        Assert.assertTrue(presetRoom.addStudent(presetStudent[0]));
+    }
+    @Test
+    public void addStudentPresetRoom(){
+        presetRoom.addStudent(presetStudent[0]);
+        Assert.assertEquals(presetRoom.getStudents()[0], presetStudent[0]);
+    }
+    @Test
+    public void addMultipleStudentPresetRoomBool(){
+        Assert.assertTrue(presetRoomMultipleStudents.addStudent(presetStudent[2]));
+    }
+    @Test
+    public void addStudentNoSpace(){
+        Assert.assertFalse(presetRoomWithStudent.addStudent(new Student("George", "Washington", null)));
+    }
+    @Test
+    public void removeNonexistent(){
+        presetRoomWithStudent.removeStudent("bleep","bloop");
+        Assert.assertArrayEquals(presetStudent, presetRoomWithStudent.getStudents());
+    }
+    @Test
+    public void getMultipleStudentWithScore(){
+        Student[] expectedStudent = new Student[]{
+                presetStudent[1],
+                presetStudent[0]};
+
+        Assert.assertArrayEquals(expectedStudent, presetRoomMultipleStudents.getStudentUseScore());
+    }
+    @Test
+    public void getStudentsScorePreset(){
+        Student[] expectedStudent = new Student[]{
+                presetStudent[1],
+                presetStudent[0],
+                presetStudent[2]};
+        presetRoomWithStudent.printGrades();
+        Assert.assertArrayEquals(expectedStudent, presetRoomWithStudent.getStudentUseScore());
+    }
+}

src/test/java/io/zipcoder/StudentTest.java

@@ -1,5 +1,52 @@
 package io.zipcoder;
 
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+
 public class StudentTest {
 
+    @Test
+    public void getNumberOfExamsTakenTest() {
+        Student student = new Student("Sandy", "Pham", new Double[]{40.0, 50.0});
+        Assert.assertEquals(2, (int) student.getNumberOfExamsTaken());
+    }
+
+    @Test
+    public void getNumberOfExamTakenNoneTest() {
+        Student student = new Student("Sandy", "Pham", null);
+        Assert.assertEquals(0, (int) student.getNumberOfExamsTaken());
+    }
+
+    @Test
+    public void addExamScoreTest() {
+        Student student = new Student("Sandy", "Pham", new Double[]{80.0, 90.0});
+        student.addExamScore(66.0);
+        System.out.println(student.toString());
+        Assert.assertEquals(66.0, student.getExamScore(3), 0.0001);
+    }
+
+    @Test
+    public void addExamScoreNullTest() {
+        Student student = new Student("Phamdy", "Sand", new Double[] {});
+        student.addExamScore(80.0);
+        Assert.assertEquals(80.0, student.getExamScore(1), 0.0001);
+    }
+
+    @Test
+    public void setExamScoresTest() {
+        Student student = new Student("Sandy", "Pham", new Double[] {80.0, 90.0});
+        student.setExamScores(1, 66.0);
+        System.out.println(student.toString());
+        Assert.assertEquals(66.0, student.getExamScore(1), 0.0001);
+    }
+
+    @Test
+    public void getAverageExamScoreTest(){
+        Student student = new Student("Sandy", "Pham", new Double [] {25.0,35.0,45.0});
+        System.out.println(student.toString());
+        Assert.assertEquals(35.0, student.getAverageExamScore(), 0.0001);
+    }
 }