[Java] Vector 구현

* 보완점 

: add, remove메서드 구현시 반복문으로 처리하지 않고 System.arraycopy()를 활용하면 좋음. 

반복문은 배열 요소를 하나하나씩 복사하는데 System.arraycopy()는 지정된 범위의 메모리를 한번에 통째로 복사하므로 속도면에서 유리함. (ex. int값 5개면 20Byte를 통째로 복사함) 

: 유효성 검사에 신경쓸 것

 

package sorasNewPackage;
 
public class MyVector {
    // add, get, toString, indexOf, remove 구현 only
 
    Object[] objArr = {};
    // = Object[] objArr = new Object[0]
    // = Object[] objArr = {};
 
    int size;
 
    // 기본생성자 -> capacity 10으로 초기화
    MyVector() {
        this(10);
    }
 
    // 입력받은 매개변수로 objArr capacity를 설정한다.
    MyVector(int capacity) {
        objArr = new Object[capacity];
    }
 
    // size를 return하는 메서드
    int size() {
        return size;
    }
 
    // capacity를 return하는 메서드
    int capacity() {
        return objArr.length;
    }
 
    // Vector의 Empty여부를 확인하는 메서드
    boolean isEmpty() {
        return (this.size == 0);
    }
 
    // Vector에 Object를 추가하는 메서드
    void add(Object obj) {
 
//        if (size == capacity()) {
//            Object[] newArr = new Object[size * 2];
//            for (int i = 0; i < objArr.length; i++) {
//                newArr[i] = objArr[i];
//            }
//            objArr = newArr;
//        }
        if (size == capacity()) {
            Object[] tmp = new Object[size * 2];
            System.arraycopy(objArr, 0, tmp, 0, size);
 
            objArr = tmp;
        }
 
        for (int i = 0; i < objArr.length; i++) {
            if (objArr[i] == null) {
                objArr[i] = obj;
                size++;
                break;
            }
        }
    }
 
    // 해당하는 index에 들어있는 값을 보여주는 메서드.
    // 유효하지 않은 index입력시 OutOfBoundsException 발생
    Object get(int index) {
        if (index < 0 || index >= size) {
            // = if (index < 0 || index >= objArr.length || objArr[index] == null)
 
            throw new ArrayIndexOutOfBoundsException();
            // = ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException();
            // = thorw e;
        }
        return objArr[index];
    }
 
    // Vector에 들어있는 값을 문자열로 반환하는 메서드. Object의 toString 내용 그대로 오버라이딩 하면 더 편리!  
    public String toString() {
 
        String str = "[";
 
        for (int i = 0; i < size; i++) {
            str += objArr[i];
            if (i != size - 1)
                str += ", ";
        }
        str += "]";
 
        return str;
    }
 
    // 해당하는 Object가 있는지 찾고 그 index를 반환. 해당하는 Object가 없으면 -1, 있으면 index 반환
    int indexOf(Object obj) {
        if (size() == 0)
            return -1;
        for (int i = 0; i < size; i++) {
            // obj가 null이 들어오는 경우. objArr에 저장된 값이 없을때(null일때) 그 index를 반환
            if (obj == objArr[i]) {
                return i;
            }
            // obj가 null이 아닐때(위에서 걸러지지 않았을 때) 안에 들어있는 값을 비교
            if (obj != null && objArr[i].equals(obj)) {
                return i;
            }
        }
        return -1;
    }
 
    // 해당하는 Object를 지우는 메서드.
    boolean remove(Object obj) {
        // indexOf()로 해당 index를 찾아서 remove
        int index = indexOf(obj);
        
        // obj가 objArr에 없으면 index가 -1을 반환 => false 
        if (index == -1)
            return false;
 
        // 마지막 index면
        if (index == size - 1) {
            objArr[index] = null;
            size--;
            return true;
        }
        // 그게 아니면 한칸씩 옮긴다
        System.arraycopy(objArr, index + 1, objArr, index, size - index + 1);
        objArr[size - 1] = null;
        size--;
        return true;
 
//        for (int i = index; i < size - 1; i++)
//            objArr[i] = objArr[i + 1];
//
//        objArr[size - 1] = null;
//        size--;
//        return true;
    }
 
} // end of MyVector

 

 

 

<jUnit Test Code >

package sorasNewPackage;
 
import static org.junit.jupiter.api.Assertions.assertTrue;
 
import java.util.Vector;
 
import org.junit.jupiter.api.Test;
 
class MyVectorTest {
 
    @Test
    void isEmptyTest() {
        // Vector v = new Vector();
        MyVector v = new MyVector();
 
        assertTrue(v.isEmpty() == true);
        v.add("aa");
        assertTrue(v.isEmpty() == false);
    }
 
    @Test
    void getIndexTest() {
        MyVector v = new MyVector();
        System.out.println(v.toString());
        v.add("aa");
        v.add("bb");
        assertTrue(v.isEmpty() == false);
        assertTrue(v.size == 2);
        assertTrue(v.get(2) == "bb");
        assertTrue(v.get(2) == "aa");
 
    }
 
    @Test
    void getTest() {
        Vector v = new Vector();
        MyVector v = new MyVector();
        v.add("aa");
        v.add("bb");
        System.out.println(v.get(0).toString());
    }
 
    @Test
    void toStringTest() {
        MyVector v = new MyVector();
        v.add("aa");
        v.add("bb");
        assertTrue(v.get(0).equals("aa"));
        assertTrue(v.get(1).equals("bb"));
        assertTrue(v.toString().equals("[aa, bb]"));
        System.out.println(v.toString());
        assertTrue(v.get(-1).equals(null)); // ArrayIndexOutOfBoundsException 발생해야함
    }
 
    @Test
    void capaTest() {
 
        MyVector v = new MyVector();
        v.add("aa");
        v.add("bb");
 
        assertTrue(v.capacity() == 16);
        assertTrue(v.size() == 2);
 
    }
 
    @Test
    void indexOfTest() {
        Vector v = new Vector();
        MyVector v = new MyVector();
        System.out.println(v.indexOf("aa"));
        System.out.println(v.indexOf("dsafasdfsasfaa"));
 
        assertTrue(v.indexOf("aa") == -1);
    }
 
    @Test
    void removeTest() {
        Vector v = new Vector();
        // MyVector v = new MyVector();
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");
 
        assertTrue(v.remove("2") == true);
        assertTrue(v.size() == 4);
        assertTrue(v.remove("b3243b") == false);
        assertTrue(v.get(v.size() - 1).equals("4"));
    }
 
    @Test
    void finalTest() {
        // Vector v = new Vector();
        MyVector v = new MyVector();
        assertTrue(v.isEmpty() == true);
        assertTrue(v.size() == 0);
        assertTrue(v.remove("aa") == false);
 
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");
        v.add("5");
 
        assertTrue(v.capacity() == 10);
        assertTrue(v.size() == 6);
        assertTrue(v.toString().equals("[0, 1, 2, 3, 4, 5]"));
        assertTrue(v.remove("2") == true);
        assertTrue(v.remove("3234322") == false);
        assertTrue(v.size() == 5);
        assertTrue(v.get(3).equals("4"));
        assertTrue(v.isEmpty() == false);
        assertTrue(v.remove("0") == true);
        assertTrue(v.remove("1") == true);
        assertTrue(v.remove("3") == true);
        assertTrue(v.remove("4") == true);
        assertTrue(v.remove("5") == true);
        assertTrue(v.size() == 0);
        assertTrue(v.capacity() == 10);
        assertTrue(v.isEmpty() == true);
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");
        v.add("5");
        v.add("6");
        v.add("7");
        v.add("8");
        v.add("9");
 
        assertTrue(v.capacity() == 10);
        System.out.println(v.capacity());
        System.out.println(v.toString());
 
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");
        v.add("5");
        v.add("6");
        v.add("7");
        v.add("8");
        v.add("9");
 
        assertTrue(v.capacity() == 20);
        System.out.println(v.capacity());
        System.out.println(v.toString());
 
        v.add("0");
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");
        v.add("5");
        v.add("6");
        v.add("7");
        v.add("8");
        v.add("9");
 
        assertTrue(v.capacity() == 40);
        System.out.println(v.capacity());
        System.out.println(v.toString());
 
        for (int i = 0; i < 50; i++) {
            v.add(i + "");
        }
 
        System.out.println(v.toString());
        System.out.println(v.capacity());
 
    }
 
}