[Java] Collections Framework - List Interface

List <E> Interface

---

순서가 있는 데이터의 집합, 중복허용.

 

 

 

 

 

▶ 종류

컬렉션	읽기(접근 시간)	추가 / 삭제	비고
ArrayList	빠르다.	느리다.	순차적인 추가, 삭제는 더 빠르다.비효율적인 메모리사용.
LinkedList	느리다.	빠르다.	데이터가 많을수록 접근성이 떨어진다.

 

 

 

 

▶ 메서드

메서드	설명
void add(int index, Object element) boolean addAll(int index, Collection c)	지정된 위치(index)에 객체(element) 또는 Collection에 포함된 객체들을 추가한다.
Object get(int index)	지정된 위치(index)에 있는 객체를 반환한다.
int indexOf(Object o)	지정된 객체의 위치를 반환한다. (List의 첫 번째 요소부터 순방향으로 찾는다.)
int lastIndexOf(Object o)	지정된 객체의 위치를 반환한다. (List의 마지막 요소부터 역방향으로 찾는다.)
ListIterator listIterator() ListIterator listIterator(int index)	List의 객체에 접근 할 수 있는 ListIterator를 반환한다.
Object remove(int index)	지정된 위치(index)에 있는 객체를 삭제하고 삭제된 객체를 반환한다.
Object set(int index, Object element)	지정된 위치(index)에 객체(element)를 저장한다.
void sort(Comparator c)	지정된 비교자(Comparator)로 List를 정렬한다.
List subList(int fromIndex, int toIndex)	지정된 범위(fromIndex부터 toIndex)에 있는 객체를 반환한다.

 

 

 

 

 

ArrayList <E>

---

• 배열 기반 자료구조.
• 저장공간을 늘리는데 시간이 진짜 오래걸림.
• 삭제 과정의 연산이 오래 걸림.
• 참조가 빠르다.

 

 

 

▶ 배열의 장단점

• 장점
  • 구조가 간단하고 데이터를 읽는 데 걸리는 시간(Access time)이 짧다.
• 단점
  • 크기를 변경 할 수 없다.
    • 크기를 변경할 경우 새로운 배열을 생성 후 데이터를 복사하고 참조해야함.
  • 비순차적인 데이터의 추가 도는 삭제의 시간이 많이 걸린다.
    • 끝지점의 추가와 삭제는 빠르다.

 

 

 

 

▶ 메서드

메서드	설명
ArrayList()	크기가 0인 ArrayList를 생성
ArrayList(Collection c)	주어진 컬렌셕이 저장된 ArrayList를 생성
ArrayList(int initialCapacity)	지정된 초기용량을 갖는 ArrayList를 생성
boolean add(Object o)	ArrayList의 마지막에 객체를 추가. 성공하면 true
void add(int index, Object element)	지정된 위치(inedx)에 객체를 저장
boolean addAll(Collection c)	주어진 컬렉션의 모든 객체를 저장
void clear()	ArrayList를 완전히 비운다.
Object clone()	ArrayList를 복제한다.
boolean contains(Object o)	지정된 객체(o)가 ArrayList에 포함되어 있는지 확인
void ensureCapacity(int minCapacity)	ArrayList의 용량이 최소한 minCapacity가 되도록 한다.
Object get(int index)	지정된 위치(index)에 저장된 위치를 찾아 반환한다.
int indexOf(Object o)	지정된 객체가 저장된 위치를 찾아 반환한다.
boolean isEmpty()	ArrayList가 비어 있는지 확인한다.
Iterator iterator()	ArrayList의 Iterator 객체를 반환
int lastIndexOf(Object o)	객체(o)가 저장된 위치를 끝부터 역방향으로 검색해서 반환
ListIterator listIterator()	ArrayList의 Listiterator를 반환
ListIterator listIterator(int index)	ArrayList의 지정된 위치부터 시작하는 ListIterator를 반환
Object remove(int index)	지정된 위치(index)에 있는 객체를 제거한다.
boolean remove(Object o)	지정한 객체를 제거한다. (성공하면 true, 실패하면 false)
boolean removeAll(Collection c)	ArrayList에 저장된 객체 중에서 주어진 컬렉션과 공통된 것들만을 남기고 나머지는 삭제한다.
boolean retainAll(Collection c)	ArrayList에 저장된 객체 중에서 주어진 컬렉션과 공통된 것들만을 남기고 나머지는 삭제한다.
Object set(int index, Object element)	주어진 객체(element)를 지정된 위치(index)에 저장한다.
int size()	ArrayList에 저장된 객체의 수를 반환한다.
void sort(Comparator c)	지정된 정렬기준(c)으로 ArrayList를 정렬
List subList(int fromIndex, int toIndex)	fromIndex부터 toIndex사이에 저장된 객체를 반환한다.
Object[] toArray()	ArrayList에 저장된 모든 객체들을 객체배열로 반환한다.
Object[] toArray(Object[] a)	ArrayList에 저장된 모든 객체들을 객체배열 a에 담아 반환한다.
void trimToSize()	용량을 크기에 맞춰 줄인다.(빈 공간을 없앤다.)

 

 

 

    public static void main(String[] args) {
        // 기본길이(용량, capacity)가 10인 ArrayList를 생성
        // ArrayList에는 객체만 저장 가능.
        ArrayList list1 = new ArrayList(10);
        
        list1.add(new Integer(1));
        list1.add(new Integer(2));
        list1.add(new Integer(3));

        // autoBoxing에 의해 기본형이 참조형으로 자동 변환
        list1.add(4);
        list1.add(5);

        // ArrayList(Collection c)
        ArrayList list2 = new ArrayList(list1.subList(0, 4)); //0~3


        print(list1, list2);

        //오름 차순 정렬
        Collections.sort(list1);
        Collections.sort(list2);


        // list1에 list2의 모든 요소를 포함하고 있나?
        System.out.println("list1.containsAll(list2) = " + list1.containsAll(list2)); // true;


        // 추가할 위치를 설정
        // 중간위치에 추가하기 때문에 부담이 가는 작업.
        list2.add(3, "A");


        // 변경
        list2.set(3,"AA");


        // indexOf()는 지정된 객체의 위치를 알려준다.
        System.out.println("index = " + list2.indexOf("AA"));


        // 겹치는 부분만 남기고 삭제
        System.out.println("list1.retainAll(list2) = " + list1.retainAll(list2));
        print(list1, list2);


        // list2에서 list1에 포함된 객체들을 삭제.
        for(int i = list2.size() - 1; i >= 0; i--){
            if(list1.contains(list2.get(0)))
                list2.remove(i);
        }

        // 삭제
        list1.remove(0); // 인덱스가 0인걸 삭제
        list1.remove(new Integer(2)); //2를 삭제
        print(list1, list2);

    }

    static void print(ArrayList list1, ArrayList list2){
        System.out.println("list1 = " + list1);
        System.out.println("list2 = " + list2);
    }

 

 

* Collection은 Interface이고, Collections는 Class임에 주의.

 

 

public class ExamCollection {
    public static void main(String[] args) {
        // Cellection Instance (컬렉션 클래스)의 생성.
        // ArrayList 배열은 기반으로 데이터를 유지한다.
        // 장점 : 참조는 빠르다, 읽기.
        // 단점 : 데이터의 구조가 변하는경우 처리가 느리다.
        // 메모리를 잡는게 메모리를 엑세스 하는것보다 몇 만배 느리다 ㅋ.
        // 처음부터 Capaacity를 잘 잡아야된다!
        // Capacity가 변경되는 순간 끝이다!
        // * 데이터의 변경이 없고 읽기가 많은 경우 사용한다.
        List<String> list = new ArrayList<>(15000);


        // 리스트에 데이터를 입력한다.
        list.add("abc");
        list.add("kbs");
        list.add("JSR");


        // 리스트의 데이터를 읽는다.
        for(int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }

        System.out.println("--------------------------------------------------------");

        // 리스트의 데이터를 지운다.
        list.remove(1);

        // 리스트의 데이터를 읽는다.
        for(int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
    }

}

 

 

 

 

LinekedList <E>

---

• List 기반 자료구조.
• 참조가 느림.
  • 데이터 접근성이 나쁨
    • 이를 개선한 doubly linked list (실제 java에 구현)
      • doubly circular linked list
• 추가, 삭제 등 메모리 할당 해제가 빠름.
• 배열과 달리 불연속적으로 존재하는 데이터를 연결(link)
• 배열의 단점을 보안
  • 크기 변경 가능
  • 추가 삭제 유리