public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}   

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    // size >= length이므로 grow() 메서드 호출
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

public static void main(String[] args){
    recursive(); 
}

public static void recursive(){
    System.out.println("recursive");
    recursive(); // 자기 자신을 호출
}

    
    public static int length(String str){

        if(str == null || str.equals(""))
            return 0;

        int length = 0;
        for(int i=0; i<str.length(); i++) {
            length++;
        }
        return length;
    }

    public static int lengthByRecursive(String str){

        if(str == null || str.equals(""))
            return 0;

        return 1+length(str.substring(1));
    }

public static void main(String[] args){
    recursive(5); // 5번 호출
}

public static void recursive(int n){
    // base case
    if(n <= 0)
        return;

    System.out.println("recursive");
    recursive(n-1); // 자기 자신을 호출
}

public int search(int[] data, int n, int target){
    for(int i=0; i<n; i++){
        if(data[i]==target)
            return i;
    }
    return -1;
}

// 앞에서부터 순차적으로 target을 찾는 재귀함수
public int search(int[] data, int begin, int end, int target){
    if(begin>end)
        return -1;
    else if(target == data[begin]){
        return begin;
    }
    else
        return search(data,begin+1,end,target);

}

   public static void main(String[] args) {
        Object obj = new Object();
        String s = (String) obj; // down-casting
        Object o = (Object) new String("string"); // up-casting

    }

   public static void main(String[] args) {
        Object obj = new Object();
        String s = (String) obj; // down-casting (throw ClassCastException)

        Object strObj = new String("str"); // type is Object, but Concrete class is String.
        String str = (String) strObj; // down-casting (valid)
    }

// 컴파일 시점(실제 할당되는 객체는 알 수 없다)
Object obj = null;
String s = (String) obj;
Object strObj = null;
String str = (String) strObj;

// 런타임 시점(실제 객체가 할당된다)
Object obj = new Object();
String s = (String) obj; // down-casting (throw ClassCastException)
Object strObj = new String("str");
String str = (String) strObj; // down-casting (valid)

ArrayList.java

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

LinkedList.java

    /**
     * Appends the specified element to the end of this list.
     *
     * <p>This method is equivalent to {@link #addLast}.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

// 람다 표현식 기본 문법
1. (parameters) -> expression
2. (parameters) -> {statements;}


// 람다 표현식 1
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())
--------------------    ----------------------------------------
    파라미터 리스트          바디(return이 함축되어 있으므로 리턴 타입은 int)

// 람다 표현식 2
(int x, int y) -> { System.out.println("Result:");
                    System.out.println(x+y); }

--------------    ---------------------------------------------
 파라미터 리스트                   바디(리턴 타입은 void)

// 람다 표현식 3
  ()        ->     42
-------           ----
파라미터 x          리턴 타입은 int