Array 구현

1. Array 특징

---

• 동일한 데이터 타입을 순서에 따라 관리
• 정해진 크기 있음
• 요소 추가, 제거시 다른 요소의 이동 필요
• 배열의 i번 째 요소를 찾는 인덱스 연ㅅ나 빠름
• jdk : ArrayList, Vector

 

 

2. Array 구현

---

package arrayList;

public class MyArray {

    int[] intArr;
    int count;

    public int ARRAY_SIZE;
    public static final int ERROR_NUM = -99999999;
    public static final int OK = 200;

    public MyArray() {
        count = 0;
        ARRAY_SIZE = 10;
        intArr = new int[ARRAY_SIZE];
    }

    public MyArray(int size) {
        count = 0;
        ARRAY_SIZE = size;
        intArr = new int[size];
    }

    public void addElement(int num) throws IllegalArgumentException {

        isMemoryEnough();
        intArr[count++] = num;
    }

    /**
     * 중간에 요소를 추가하면 마지막 요소부터 한칸씩 뒤로 옮겨야함.
     */
    public void insertElement(int position, int num) throws IllegalArgumentException {

        positionValidation(position);

        isMemoryEnough();

        for (int i = count-1; i>=position; i--){
            intArr[i+1] = intArr[i];
        }
        intArr[position] = num;
        count++;
    }

    /**
     * 삽입할 위치의 다음 요소부터 한칸 씩 앞으로 옮김.
     * 기존 마지막 위치는 초기화시킴
     */
    public int removeElement(int position) throws IllegalArgumentException {

        if(isEmpty()){
            System.out.println("array is Empty");
            throw new IllegalArgumentException();
        }

        positionValidationForRemove(position);

        int ret = intArr[position];

        for (int i = position+1; i <= count-1; i++){
            intArr[i-1] = intArr[i];
        }

        intArr[count-1] = 0;
        count--;

        return ret;
    }

    private int positionValidation(int position) throws IllegalArgumentException {
        if (position > ARRAY_SIZE || position < 0 || position > count) {
            System.out.println("position error");
            throw new IllegalArgumentException();
        }
        return OK;
    }

    private int positionValidationForRemove(int position) throws IllegalArgumentException {
        if (position > ARRAY_SIZE || position < 0 || position >= count) {
            System.out.println("position error");
            throw new IllegalArgumentException();
        }
        return OK;
    }

    private int isMemoryEnough() throws OutOfMemoryError {
        if (count >= ARRAY_SIZE) {
            System.out.println("not enough memory");
            throw new OutOfMemoryError();
        }
        return OK;
    }

    public Boolean isEmpty(){
        if(count == 0){
            return true;
        }
        return false;
    }

    public int size(){
        return this.count;
    }

    public void clear(){
        for (int i=0; i<count; i++){
            this.intArr[i] = 0;
        }
        this.count = 0;
    }
}

 

 

3. Array Test

---

• arrary size는 10으로 지정하고 5개만 채워보자.
• 독립적인 test를 위해서 각 테스트 실행 전 배열을 생성, 테스트 후  clear해준다.
• 정상적인 테스트 외에도 비정상 테스트도 진행.

class MyArrayTest {

    MyArray array = new MyArray(10);

    int cnt = 5;

    @BeforeEach
    void initTest() throws IllegalArgumentException {
        for (int i=0; i<cnt; i++){
            array.addElement(i);
        }
    }

    @AfterEach
    void afterTest(){
        array.clear();
    }

    @Test
    void addElement() throws IllegalArgumentException {

        array.addElement(2);

        assertEquals(array.size(), cnt+1);
        assertEquals(array.intArr[cnt], 2);
    }

    @Test
    void insertElement() throws IllegalArgumentException {
        //given
        int insertIndex = 2;

        //when
        array.insertElement(insertIndex,5);

        //then
        assertEquals(array.size(), cnt+1);
        assertEquals(array.intArr[insertIndex], 5);

    }

    @Test
    void insertElementWrongPosition() throws IllegalArgumentException {

        //given
        int insertIndex = array.ARRAY_SIZE+10;

        //when, then
        assertThrows(IllegalArgumentException.class, () -> array.insertElement(insertIndex,5));

    }

    @Test
    void removeElement() throws IllegalArgumentException {

        //given
        int deleteIndex = 2;
        int deleteNum = array.intArr[deleteIndex];
        int nexNum = array.intArr[deleteIndex + 1];

        //when
        array.removeElement(deleteIndex);

        //then
        assertEquals(array.size(), cnt-1);
        assertEquals(array.intArr[deleteIndex], nexNum);

    }

    @Test
    void removeElementWrongPosition() throws IllegalArgumentException {

        //given
        int deleteIndex = array.ARRAY_SIZE+10;

        //when, then
        assertThrows(IllegalArgumentException.class, ()-> array.removeElement(deleteIndex));


    }

    @Test
    void noEnoughMemoryTest() throws OutOfMemoryError {
        for (int i = cnt; i <array.ARRAY_SIZE;i++){
            array.addElement(i);
        }
        assertThrows(OutOfMemoryError.class, ()-> array.addElement(10));
    }

    @Test
    void isEmpty() {

        assertEquals(array.isEmpty(), false);

        MyArray myArray = new MyArray();
        assertEquals(myArray.isEmpty(), true);
    }

}

 

 

4. GitHub: 211024 Array 구현

---

GitHub - bsh6463/dataStructure