ewhk9887/korean_code_reviews_from_github huggingface dataset:
@@ -0,0 +1,44 @@
+package com.codesquad.datastructurestudy.basic;
+
+import java.util.Arrays;
+
+public class BinarySearchOperationCount {
+
+  private static int binarySearch(int[] numbers, int number, int first, int last) {
+    int mid;
+    int opCount = 0;
+
+    while (first <= last) {
+      mid = (first + last) / 2;
+
+      if (numbers[mid] == number) {
+        return mid;
+      } else if (numbers[mid] < number) {
+        first = mid + 1;
+      } else {
+        last = mid - 1;
+      }
+      opCount++;
+    }
+    return opCount;
+  }
+
+  public static void main(String[] args) {
+    int[] arr1 = new int[500];
+    int[] arr2 = new int[5000];
+    int[] arr3 = new int[50000];
+    int number = 5000;
+
+    Arrays.fill(arr1, 0);
+    Arrays.fill(arr2, 0);
+    Arrays.fill(arr3, 0);
+
+    int opCount1 = binarySearch(arr1, number, 0, arr1.length - 1);
+    int opCount2 = binarySearch(arr2, number, 0, arr2.length - 1);
+    int opCount3 = binarySearch(arr3, number, 0, arr3.length - 1);
+
+    System.out.println("비교연산횟수 : " + opCount1);
+    System.out.println("비교연산횟수 : " + opCount2);
+    System.out.println("비교연산횟수 : " + opCount3);
+  }
+}

리뷰: 여기도 리뷰 참고해서 수정하시길 바랄게요!
@@ -0,0 +1,44 @@
+package com.codesquad.datastructurestudy.basic;
+
+import java.util.Arrays;
+
+public class BinarySearchOperationCount {
+
+  private static int binarySearch(int[] numbers, int number, int first, int last) {
+    int mid;
+    int opCount = 0;
+
+    while (first <= last) {
+      mid = (first + last) / 2;
+
+      if (numbers[mid] == number) {
+        return mid;
+      } else if (numbers[mid] < number) {
+        first = mid + 1;
+      } else {
+        last = mid - 1;
+      }
+      opCount++;
+    }
+    return opCount;
+  }
+
+  public static void main(String[] args) {
+    int[] arr1 = new int[500];
+    int[] arr2 = new int[5000];
+    int[] arr3 = new int[50000];
+    int number = 5000;
+
+    Arrays.fill(arr1, 0);
+    Arrays.fill(arr2, 0);
+    Arrays.fill(arr3, 0);
+
+    int opCount1 = binarySearch(arr1, number, 0, arr1.length - 1);
+    int opCount2 = binarySearch(arr2, number, 0, arr2.length - 1);
+    int opCount3 = binarySearch(arr3, number, 0, arr3.length - 1);
+
+    System.out.println("비교연산횟수 : " + opCount1);
+    System.out.println("비교연산횟수 : " + opCount2);
+    System.out.println("비교연산횟수 : " + opCount3);
+  }
+}

리뷰: 제가 윤성우 책에서 안좋아하는 부분이 명확하지 않은 변수명이에요.
약어를 사용하시기 보다는 보다 명확한 변수명을 사용하시는게 좋을 것 같아요.
@@ -0,0 +1,26 @@
+package com.codesquad.datastructurestudy.basic;
+
+public class LinearSearch {
+
+  private static int linearSearch(int[] numbers, int number) {
+    int i;
+    for (i = 0; i < numbers.length; i++) {
+      if (numbers[i] == number) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public static void main(String[] args) {
+    int[] arr = {1,2,3,4,5};
+    int number = 2;
+    int index = linearSearch(arr, number);
+
+    if (index == -1) {
+      System.out.println("못찾았다");
+    } else {
+      System.out.println((index+1) + "번째 에서 찾았다");
+    }
+  }
+}

리뷰: 앗... 아아...
@@ -0,0 +1,26 @@
+package com.codesquad.datastructurestudy.basic;
+
+public class LinearSearch {
+
+  private static int linearSearch(int[] numbers, int number) {
+    int i;
+    for (i = 0; i < numbers.length; i++) {
+      if (numbers[i] == number) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public static void main(String[] args) {
+    int[] arr = {1,2,3,4,5};
+    int number = 2;
+    int index = linearSearch(arr, number);
+
+    if (index == -1) {
+      System.out.println("못찾았다");
+    } else {
+      System.out.println((index+1) + "번째 에서 찾았다");
+    }
+  }
+}

리뷰: ```suggestion
      System.out.println((index + 1) + "번째 에서 찾았다");
```

사소한거지만, 이런건 띄어쓰는게 관례입니다.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 특이하네요 ㅋㅋㅋ 제네릭을 이렇게 구현하신 이유가 있을까요?
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 음 가급적이면 숫자 상수도 private static final로 빼서 사용하는 편이 좋지 않을까 싶어요.
그리고 numOfData는 그냥 제거해도 0으로 초기화 되니 그 점을 염두에 두시는게 좋을 것 같네요.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 추가로...
저라면 생성자를 
```java
public ArrayList(int initialSize) {
  this.numbers = new int[initialSize];
}
```

이런 식으로 만들고 생성자 오버로딩을 통해서 

```java
public ArrayList() {
  this(INITIAL_SIZE);
}
```

와 같은 식으로 구현해봤을 것 같네요.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 살짝 애매한 생성자 같아요.
이 생성자가 과연 필요할까? 라는 생각도 들고요.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 안쓰는 주석은 제거해주세요~
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 이 메서드 확실한가요?
행동하는 것은 replace에 가까운데, 하는 동작에 군더더기가 많이 들어간 느낌입니다.
특히 개수 체크하는 로직은 없어도 될 것 같고, 마찬가지로 `numOfData++;` 도 불필요해보입니다.
그리고 `IndexOutOfBoundException`도 발생가능한 코드입니다.

1. add인데, 만약 0번 위치에 계속 데이터를 집어넣으면? 나중엔 배열이 가득 찼다고 하면서 데이터는 바뀌고, `numOfData`도 계속 증가할겁니다. if문이 종료되고 아래 라인들이 실행될 필요가 없다면 `return`문을 사용해주세요.
2. `numOfData`라는 멤버변수에 `this` 키워드를 추가해주세요. 헷갈릴 수 있습니다.
3. 23번 라인에 `IndexOutOfBoundException`이 발생가능한 코드가 그대로 있습니다. 예외 처리를 추가해주시던지, if 문으로 조건을 달아주세요. (인덱스의 범위를 생각해봅시다.)
4. 23번 라인에 element가 unboxing될 때, 어떻게 될지도 생각해봅시다. `null`이 그대로 들어가게 된다면? 어떤 결과가 벌어질까요?
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 여기도 마찬가지입니다. 위의 코멘트를 참고해서 정확한 로직으로 변경해주세요.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 메서드명은 관례상 `size()`가 좀 더 적합해보입니다.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: `wrapper type`으로 반환하게 되면 `auto boxing`이 일어나기 때문에
여기선 불필요하다고 보입니다.
`Integer`와 `int` 타입은 많은 차이가 있습니다.
특히 메모리 공간, Nullable 등의 차이가 있겠네요.
@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

리뷰: 데이터가 없다면 0을 주겠네요?
뭔가 이상하지 않을까요 ㅎㅎ