Java 학습--day 09

주요 내용
4

용기 소개
4

ArrayList 소개 4

4

손글씨로 ArrayList 흉내내기 4

4

손글씨로 링크드 리스트 흉내내기 4

상세한 상황을 필기하다.
용기 소개
컨테이너는 바로 Collection이다. 이것은 하나의 대상을 나타낸다. 그는 집중하고 수집하는 뜻이며, 일부 데이터를 수집하는 것이다.Collection 함수 라이브러리는 Java입니다.util 패키지 아래의 일부 클래스와 인터페이스, 그 중 클래스는 대상이 데이터를 저장하는 데 사용되며, 인터페이스는 데이터에 접근하는 방법이다.
Collection 인터페이스에서 기본적인 접근 방법을 정의했습니다. 이로써 우리는 Collection과 하위 인터페이스를 통해 데이터에 접근할 수 있는 통일된 방식을 가지게 되었습니다.Collection에는 많은 하위 인터페이스가 있는데, 그 중에서 비교적 중요하고 자주 사용하는 것은 set과list 인터페이스가 있다.set 인터페이스의 특징은 무질서하고 원소가 중복될 수 없다는 것이다.list 인터페이스의 특징은 질서정연하고 요소가 중복될 수 있다는 것이다.
ArrayList 소개
Array List는 인터페이스list를 계승하는데, 그 밑바닥의 실현은 수치이기 때문에 데이터를 조회할 때 매우 빠르지만, 수정하고, 데이터를 삽입하고 삭제할 때 좀 느리다.그것과 같은 등급의 링크드 리스트도 있는데 그 밑바닥은 체인 테이블로 데이터 조회가 느리고 데이터 수정, 삽입과 삭제가 빠르다.이 두 가지의 공통된 특징은 라인이 안전하지 않지만 효율이 높고 그것들과 같은 등급의 Vector 라인이 안전하며 효율이 낮다는 것이다.
다음은 ArrayList 사용법에 대한 몇 가지 설명입니다.

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class Test01 {

    public static void main(String[] args) {

        List list = new ArrayList();

        //         ，         
        list.add("fengzhen");
        list.add("Tom");
        list.add(1234);     //    ，    ，    
        list.add(new Date());
        list.add(new Dog());    //      

        System.out.println(list.size());        //         ，   5

        //         ，          ，     
        list.remove("fengzhen");
        list.remove(new Date());        //         new Date()       ，     new Date()       

        System.out.println(list.size());    //          ，   4

        //         
        String strName = (String) list.get(0);      //        ，      
        Object c = list.get(1);
    }
}

class Dog {
    String dogName;
}

손글씨로 Array List 따라하기

package fengzhen.collectionBase;

public class MyArrayList {

    private Object elementData[];
    private int size;       //         

    public MyArrayList() {
        this(3);
    }

    public MyArrayList(int listSize) {
        if (listSize < 0) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        elementData = new Object[listSize];
    }

    //         
    public void add(Object newElement) {
        //             
        if (size == elementData.length) {
            int newSize = size * 2 + 1;
            Object newElementData[] = new Object[newSize];
            for (int i = 0; i < elementData.length; i++) {
                newElementData[i] = elementData[i];
            }
            this.elementData = newElementData;
        }

        elementData[size++] = newElement;
    }

    //         
    public void add(int index, Object obj) {
        if (index < 1 || index > size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        System.arraycopy(elementData, index - 1, elementData, index, size - index + 1);
        elementData[index-1] = obj;
    }

    //         
    public Object remove(int index) {
        rangeCheck(index);

        for (int i = index; i < size - 2; i++) {
            elementData[i] = elementData[i + 1];
        }
        size--;
        return elementData[index];
    }

    //         
    public Object remove(Object obj) {
        for (int i = 0; i < size; i++) {
            if (elementData[i].equals(obj)) {
                remove(i);
                return obj;
            }
        }

        return obj;
    }

    //         
    public Object get(int index) {
        rangeCheck(index);
        return elementData[index];
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        if (size == 0) {
            return true;
        }
        return false;
    }

    //      index    
    public void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

손글씨로 링크드 리스트 따라하기.

package fengzhen.collectionBase;

public class MyLinkedList {

    private int size;
    Node first;
    Node last;

    //         
    public void add(Object obj) {
        Node newNode = new Node();

        if (first == null) {
            newNode.setBefore(null);
            newNode.setValue(obj);
            newNode.setNext(null);

            first = newNode;
            last = newNode;
        } else {
            newNode.setBefore(last);
            newNode.setValue(obj);
            newNode.setNext(null);

            last.setNext(newNode);
            last = newNode;
        }
        size++;
    }

    //         
    public void add(int index, Object obj) {
        if (index < 0 || index > size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        if (index == 0) {   //          
            Node newFirst = new Node();
            newFirst.setBefore(null);
            newFirst.setValue(obj);
            newFirst.setNext(first);
            first = newFirst;
            size++;
        } else {
            Node temp = node(index - 1);

            if (temp.getNext() == null) {   //          
                this.add(obj);
            } else {
                Node before = temp;
                Node next = temp.getNext();
                Node newNode = new Node();
                newNode.setValue(obj);
                newNode.setBefore(before);
                newNode.setNext(next);
                before.setNext(newNode);
                next.setBefore(newNode);
                size++;
            }
        }
    }

    //         
    public void remove(int index) {
        Node temp = node(index);

        if (index == 0) {       //        
            first = first.getNext();
            first.setBefore(null);
        } else if (index == size - 1) {       //         
            last = last.getBefore();
            last.setNext(null);
        } else {
            Node before = temp.getBefore();
            Node next = temp.getNext();
            before.setNext(next);
            next.setBefore(before);
        }

        size--;
    }

    //        ，       
    public Node node(int index) {
        Node temp = first;
        if (first != null) {
            for (int i = 0; i < index; i++) {
                temp = temp.getNext();
            }
        }
        return temp;
    }

    //         
    public Object get(int index) {
        Node temp = first;
        if (index < 0 || index >= size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        temp = node(index);
        return temp.getValue();
    }

    //          
    public int size() {
        return size;
    }
    
}