Hello world

1.3 LinkedList

 

배열은 가장기본적인 형태의 자료구조로 사용하기 쉽고 데이터를 읽어오는데 걸리는 시간이 가장 빠르다는 장점을 가지고 있다.

 

단점 1 : 크기를 변경 할 수 없다.

2. 비순차적인 데이터의 추가 또는 삭제에 시간이 많이 걸린다.

 

이를 보완하기 위해 링크드 리스트 자료구조가 고안되었다.

 

Class Node {

Node next; // 다음 요소의 주소 저장

Object obj; // 데이터를 저장.

}

 

LinkedList 클래스

 

- LinkedList() : LinkedList 객체 생성

- LinkedList(Collection c) : 주어진 컬렉션을 포함하는 LinkedList객체를 생성

- boolean add(Object o) : 지정된 객체(o)를 LinkedList의 끝에 추가, 저장에 성공하면 true, 실패하면 false

- void add(int index, Object element) : 지정된 위치(index)에 객체(element)를 추가

- boolean addAll(Collection c) : 주어진 컬렉션에 포함된 모든 요소를 LinkedList의 끝에 추가한다. 성공하면 true, 실패하면 false

- boolean addAll(int index, Collection c) : 지정된 위치에 주어진 컬렉션에 포함된 모든 요소를 추가. 성공하면 true, 실패하면 false

- void clear() : LinkedList의 모든 요소를 삭제

- boolean contains(Object c) : 지정된 객체가 LinkedList에 포함되었는지 알려줌

- boolean containsAll(Collection c) : 지정된 컬렉션의 모든 요소가 포함되었는지 알려줌

- Object get(int index) : 지정된 위치의 객체를 반환

- int indexOf(Object o) : 지정된 객체가 저장된 위치를 반환

- boolean isEmpty() : LinkedList가 비어있는지 알려준다. 비어있으면 true

- Iterator iterator() : Iterator를 반환한다.

- int lastindexOF(Object o) : 지정된 객체의 위치를 반환(끝부터 역순검색)

- ListIterator listiterator() : listIterator 를 반환

- ListIterator listiterator(int index) : 지정된 위치에서부터 시작하는 listIterator를 반환

- Object remove(int index) : 지정된 위치의 객체를 LinkedList에서 제거

- boolean remove(Object o) : 지정된 객체를 LinkedList에서 제거. 성공하면 true, 실패하면 false

- boolean removeAll(Collection c) : 지정된 컬렉션의 요소와 일치하는 요소를 모두 삭제

- boolean retainAll(Collection c) : 지정된 컬렉션의 모든 요소가 포함되어 있는지 확인.

- Object set(int index, Object element) : 지정된 위치의 객체를 주어진 객체로 바꿈

- int size() : LinkedList에 저장된 객체 수를 반환

- List subList(int fromindex, ind tolndex) : LinkedList의 일부를 list로 반환

- Object[] toArray() : LinkedList저장된 객체를 배열로 반환

- Object[] toArray(Object[] a) : LinkedList저장된 객체를 주어진 배열에 저장하여 반환

- Object element() : LinkedList의 첫 번째 요소를 반환

- boolean offer(Object o) : 지정된 객체 를 LinkedList의 끝에 추가, 성공하면 ture, 실패하면 false

- Object peek() : LinkedList의 첫 번째 요소를 반환

- Object poll() : LinkedList의 첫 번째 요소를 반환. LinkedList에서는 제거된다.

- Object remove() : LinkedList의 첫 번째 요소를 제거

- void addFirst(Object o) : LinkedList의 맨 앞의 객체를 추가

- void addLast(Object o) : LinkedList의 맨 끝의 객체를 추가.

- Iterator dexcendingiterator() : 역순으로 조회하기 위한 DescendingIterator를 반환

- Object getFirst() : LinkedList의 첫번째 요소를 반환

- Object getLast() : LinkedList의 마지막 요소를 반환

- boolean offerFirst(Object o) : LinkedList의 맨 앞에 객체를 추가 성공하면 true

- boolean offerLast(Object o) : LinkedList의 맨 뒤에 객체를 추가 성공하면 true

- Object peekFirst() : LinkedList의 첫번째 요소를 반환

- Object peekLast() : LinkedList의 마지막 요소를 반환

- Object pollFirst() : LinkedList의 첫번째 요소를 반환하면서 제거

- Object pollLast() : LinkedList의 마지막 요소를 반환하면서 제거

- Object pop() : removeFirst()와 동일

- void push(Object o) : addFirst()와 동일

- Object removeFirst() : LinkedList의 첫번째 요소를 제거

- Object removeLast() : LinkedList의 마지막 요소를 제거

- boolean removefirstOccurrence(Object o) : LinkedList에서 첫번쨰로 일치하는 객체를 제거

- boolean removeLastOccurrence(Object o) : LinkedList에서 마지막으로 일치하는 객체를 제거

 

실습1. ArrayList와 LinkedList 수행 속도 차이

 

package Collection_Framework;

import java.util.*;

public class LinkedList1 {

 

public static void main(String[] args) {

ArrayList a1 = new ArrayList(2000000);

ArrayList ll = new ArrayList();

 

System.out.println("=순차적으로 추가하기=");

System.out.println("ArrayList :"+add1(a1));

System.out.println("LinkedList :"+add1(ll));

System.out.println();

System.out.println("=중간에 추가하기=");

System.out.println("ArrayList :"+add2(a1));

System.out.println("LinkedList :"+add2(ll));

System.out.println();

System.out.println("=중간에서 삭제하기 =");

System.out.println("ArrayList :"+remove2(a1));

System.out.println("LinkedList :"+remove2(ll));

System.out.println();

System.out.println("=순차적으로 삭제하기=");

System.out.println("ArrayList :"+remove1(a1));

System.out.println("LinkedList :"+remove1(ll));

}

 

public static long add1(List list) {

long start = System.currentTimeMillis();

for(int i = 0; i<100000;i++)

list.add(i+"");

long end = System.currentTimeMillis();

return end -start;

}

 

public static long add2(List list) {

long start = System.currentTimeMillis();

for(int i = 0; i<10000;i++)

list.add(500,"X");

long end = System.currentTimeMillis();

return end -start;

}

 

public static long remove1(List list) {

long start = System.currentTimeMillis();

for(int i=list.size()-1;i>=0;i--)

list.remove(i);

long end = System.currentTimeMillis();

return end - start;

}

 

public static long remove2(List list) {

long start = System.currentTimeMillis();

for(int i=0;i<10000;i++)

list.remove(i);

long end = System.currentTimeMillis();

return end - start;

}

}

 

 

출력 결과 :

=순차적으로 추가하기=
ArrayList :62
LinkedList :49

=중간에 추가하기=
ArrayList :316
LinkedList :295

=중간에서 삭제하기 =
ArrayList :294
LinkedList :279

=순차적으로 삭제하기=
ArrayList :5
LinkedList :1

1.2 ArrayList

 

: 가장 많이 사용되는 컬렉션 클래스. 데이터의 저장 순서가 유지되고 중복을 허용한다.

 

기존의 vector를 개선한 것, Object배열을 이용해서 데이터를 순차적으로 저장한다.

 

0번부터 차례로 저장, 더이상 공간이 없으면 새로운 배열을 생성하여 기존배열에 저장된 내용을 복사 한 후 저장된다.

 

public class arrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

{

transient Object[] elementData;

}

 

ArrayList 제공 메서드

- ArrayList() : 크기가 0인 ArrayList를 생성

- ArrayList(Collection c) : 주어진 컬렉션이 저장된 ArrayList를 생성 

- ArrayList(int initialCapacity) : 지정된 초기 용량을 갖는 ArrayList를 생성

- ArrayList(int initialCapacity, int capacityincrement) : 지정된 초기 용량과 용량의 증분을 갖는 ArrayList를 생성

- boolean add(Object o) : ArrayList의 마지막에 객체를 추가, 성공하면 true

- void add(int index, Object element) : 지정된 위치(index)에 객체를 저장

- boolean addAll(Collection c) : 주어진 컬렉션의 모든 객체를 저장한다.

- boolean addAll(int index, 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() : 용량을 크기에 맞게 줄인다.(빈공간을 없앤다.)

 

실습 1. 기본적인 ArrayList 메서드 이용하여 객체를 다루는 방법.

 

 

package Collection_Framework;

import java.util.*;

public class ArrayList1 {

 

public static void main(String[] args) {

ArrayList list1 = new ArrayList(10);

list1.add(new Integer(5));

list1.add(new Integer(4));

list1.add(new Integer(2));

list1.add(new Integer(0));

list1.add(new Integer(1));

list1.add(new Integer(3));

 

ArrayList list2 = new ArrayList(list1.subList(1, 4));

print(list1,list2);

 

Collections.sort(list1);

Collections.sort(list2);

print(list1,list2);

 

System.out.println("list1.containsAll(list2):" +list1.containsAll(list2));

list2.add("B");

list2.add("C");

list2.add(3,"A");

print(list1,list2);

 

list2.set(3, "AA");

print(list1, list2);

 

System.out.println("list1.retainAll(list2):"+list1.retainAll(list2));

print(list1,list2);

 

for(int i = list2.size()-1; i>=0;i--) {

 

if(list1.contains(list2.get(i)))

list2.remove(i);

}

 

print(list1,list2);

}

 

static void print(ArrayList list1, ArrayList list2) {

 

System.out.println("list1:" +list1);

System.out.println("list2:" +list2);

System.out.println();

}

}

 

 

 

 

 

출력결과 :

list1:[5, 4, 2, 0, 1, 3]
list2:[4, 2, 0]

list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4]

list1.containsAll(list2):true
list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, A, B, C]

list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, AA, B, C]

list1.retainAll(list2):true
list1:[0, 2, 4]
list2:[0, 2, 4, AA, B, C]

list1:[0, 2, 4]
list2:[AA, B, C]

 

실습 2. 긴 문자열 데이터를 원하는 길이로 잘라서 ArrayList에 담은 다음 출력하는 예제.

 

package Collection_Framework;

import java.util.*;

public class ArrayList2 {

 

public static void main(String[] args) {

final int LIMIT = 10;

String source = "0123456789abcdefghijABCDEFGHIJ!@#$%^&*()ZZZ";

int length = source.length();

 

List list = new ArrayList(length/LIMIT +10);

 

for (int i =0; i<length; i+=LIMIT) {

if(i+LIMIT < length)

list.add(source.substring(i, i+LIMIT));

else

list.add(source.substring(i));

}

 

for (int i =0; i<list.size();i++) {

System.out.println(list.get(i));

}

}

 

}

 

 

출력결과 :

0123456789
abcdefghij
ABCDEFGHIJ
!@#$%^&*()
ZZZ

 

실습 3. Vector의 용량과 크기에 관한 예제.

 

 

package Collection_Framework;

import java.util.*;

public class ArrayList3 {

 

public static void main(String[] args) {

Vector v = new Vector(5);

v.add("1");

v.add("2");

v.add("3");

print(v);

 

v.trimToSize();

System.out.println("=== After trimToSize() ===");

print(v);

 

v.ensureCapacity(6);

System.out.println("=== After ensureCapacity(6) ===");

print(v);

 

v.setSize(7);

System.out.println("=== After setSize(7) ===");

print(v);

 

v.clear();

System.out.println("=== After clear() ===");

print(v);

}

 

public static void print(Vector v){

System.out.println(v);

System.out.println("size:"+ v.size());

System.out.println("capacity:"+v.capacity());

}

}

 

 

출력 결과:

[1, 2, 3]
size:3
capacity:5
=== After trimToSize() ===
[1, 2, 3]
size:3
capacity:3
=== After ensureCapacity(6) ===
[1, 2, 3]
size:3
capacity:6
=== After setSize(7) ===
[1, 2, 3, null, null, null, null]
size:7
capacity:12
=== After clear() ===
[]
size:0
capacity:12

 

 

1.7 Comparator, Comparable

 

Arrays.sort() 호출시 배열을 정렬하나, 사실은 Character 클래스의 Comparable의 구현에 의해 정렬됨.

 

Comparator, Comparable은 모두 인터페이스로 컬렉션을 정렬하는데 필요한 메서드를 정의함.

 

- Comparator : 기본 정렬기준 외에 다른 기준으로 정렬하고자 할 때 사용.

- Comparable : 기본 정렬기준을 구현하는데 사용.

 

package Collection_Framework;
import java.util.*;
public class comparator1 {
 public static void main(String []arge) {
  String[] strArr = {"cat","dog", "lion","tiger"};
  
  Arrays.sort(strArr);
  System.out.println("strArr=" + Arrays.toString(strArr));
  
  Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER);
  System.out.println("strArr=" + Arrays.toString(strArr));
  
  Arrays.sort(strArr, new Descending());
  System.out.println("strArr=" + Arrays.toString(strArr));
  
 }
}

class Descending implements Comparator{
 public int compare(Object o1, Object o2) {
  if(o1 instanceof Comparable && o2 instanceof Comparable) {
   Comparable c1 = (Comparable)o1;
   Comparable c2 = (Comparable)o2;
   return c1.compareTo(c2)*-1;
  }
  return -1;
 }
}

 

 

출력결과 :

strArr=[cat, dog, lion, tiger]
strArr=[cat, dog, lion, tiger]
strArr=[tiger, lion, dog, cat]

 

 

* String의 Comparable 구현은 문자열이 사전순으로 정렬됨. 오름차순 정력은 공백, 숫자, 대문자, 소문자 순으로 정렬됨.

즉, 유니코드 순서가 작은값에서 큰값으로 정렬됨.

 

* 대소문자를 구분하지 않고 비교하는 Comparator를 상수의 형태로 제공.

public static final Comparator CASE_INSENSITIE_ORDER

 

> Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); 사용시 대소문자 구분없이 정렬가능.

 

* 내림차순 정렬

String에 구현된 compareTo()의 결과에 -1을 곱하기만 하면 된다. 비교하는 객체의 위치를 바꿔서 c2.compareTo(c1)과 같이 해도 된다.

 

매개변수가 Object타입이기 때문에, compareTo()를 바로 호출 할수 없으므로 Comparable로 형변환 해야 한다.

 

class Descending() 참고.

 

 

1.6 Arrays

 

* Arrays 클래스 : 배열을 다루는데 유용한 메서드가 정의되어 있음. 아래 정의된 toString(), 모든 기본형 배열, 참조형 배열 별로 하나씩 정의됨.

 

static String toString(boolean[ ]a)

static String toString(byte[ ] a)

static String toString(char[ ] a)

static String toString(short[ ] a)

static String toString(int[ ] a)

static String toString(long[ ] a)

static String toString(float[ ] a)

static String toString(double[ ] a)

static String toString(object[ ] a)

 

------------------------------------------------------------------------------------------------------------------------------------------------------------

 

* 배열의 복사

- copyOf() : 배열 전체 복사

- copyOfRange() : 배열의 일부를 복사

하여 새로운 배열을 만들어 반환.

 

int[ ] arr = {0,1,2,3,4,};

int[ ] arr2 = Arrays.copyOf(arr, arr.length);

int[ ] arr3 = Arrays.copyOf(arr, 3);

int[ ] arr4 = Arrays.copyOf(arr, 7);

 

int[ ] arr5 = Arrays.copyOfRange(arr,2,4);

int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

 

 

// 배열의 복사

package Collection_Framework;
import java.util.*;
public class Arrays1 {
 public static void main(String[]arge) {

  int[ ] arr = {0,1,2,3,4,};
  int[ ] arr2 = Arrays.copyOf(arr, arr.length);
  int[ ] arr3 = Arrays.copyOf(arr, 3);
  int[ ] arr4 = Arrays.copyOf(arr, 7);

  int[ ] arr5 = Arrays.copyOfRange(arr,2,4);
  int[ ] arr6 = Arrays.copyOfRange(arr,0,7);

  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.toString(arr2));
  System.out.println(Arrays.toString(arr3));
  System.out.println(Arrays.toString(arr4));
  System.out.println(Arrays.toString(arr5));
  System.out.println(Arrays.toString(arr6));
 }
}

 

출력결과 :

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2]
[0, 1, 2, 3, 4, 0, 0]
[2, 3]
[0, 1, 2, 3, 4, 0, 0]

 

* 배열 채우기

- fil() : 배열의 모든 요소를 지정된 값으로 채운다.

- setAll() : 배열을 채우는데 사용할 함수형 인터페이스를 매겨변수로 받는다.

 

package Collection_Framework;
import java.util.*;
public class Arrays2 {

 public static void main(String[] args) {

  int[]arr = new int[5];
  Arrays.fill(arr, 9);
  Arrays.setAll(arr, () -> (int)(Math.random()*5)+1); // 람다식을 지정해야 함.

 System.out.println(Arrays.toString(arr));
 }

}

 

출력 결과 :

[9, 9, 9, 9, 9]

* 배열의 정렬과 검색

- sort() : 배열을 정렬할 때 사용

- binarySearch() : 저장된 요소를 검색 할 때 사용, 배열에서 지정된 값이 저장된 위치(index)를 찾아서 반환하는데, 반드시 배열이 정렬된 상태이어야 올바른 결과를 얻음.

 

package Collection_Framework;
import java.util.*;
public class Arrays3 {

 public static void main(String[] args) {
  int[] arr = {3,2,0,1,4};
  int idx = Arrays.binarySearch(arr, 2);
  System.out.println(Arrays.toString(arr));
 
  Arrays.sort(arr);
  System.out.println(Arrays.toString(arr));
  int idx2 = Arrays.binarySearch(arr,2);
 
  
 }

}

 

출력 결과 :

[3, 2, 0, 1, 4]
[0, 1, 2, 3, 4] <- 올바른 결과.
 

 

 

* 문자열의 비교와 출력

- equals() : 두 배열에 저장된 모든 요소를 비교해서 같으면 true, 다르면 false를 반환. 일차원 배열에서만 사용가능

- toString() : 일차원 배열에서 문자열로 편하게 출력함.

 

다차원 배열에서

- deepToString(), deepToEquals() 사용

 

package Collection_Framework;
import java.util.*;
public class Arrays4 {

 public static void main(String[] args) {
  int[] arr = {0,1,2,3,4};
  int[] [] arr2D = {{11,12},{21,22}};
  
  System.out.println(Arrays.toString(arr));
  System.out.println(Arrays.deepToString(arr2D));
  
  String[] [] str2D = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  String[] [] str2D2 = new String [] [] {{"aaa","bbb"},{"AAA","BBB"}};
  System.out.println(Arrays.equals(str2D, str2D2));
  System.out.println(Arrays.deepEquals(str2D, str2D2));
 }

}

출력결과 :

[0, 1, 2, 3, 4]
[[11, 12], [21, 22]]
false
true

* 배열을 List로 변환 // 이해가 잘 안감...

- asList(Object... a)

 

package Collection_Framework;
import java.util.*;
public class Arrays5 {

 public static void main(String[] args) {
  List list = Arrays.asList(new Integer[] {1,2,3,4,5,});
  List<Integer> list = Arrays.asList(1,2,3,4,5);
  list.add(6);
  
 }

}

 

 

* parallel로 시작하는 메서드(), spliterator(), tream()등등

 

 

 

1.5 lterator, Listlterator, Enumeration

 

lterator, Listlterator, Enumeration 모두 컬렉션에 저장된 요소를 접근하는데 사용하는 인터페이스 이다.

 

Enumeration은 Iterator의 구버전이다. ListIterator은 Iterator의 기능을 향상 시킨 것이다.

 

* Iterator  

 

- interface 메서드
 public interface Iterator {
  boolean hasNext(); // 읽어 올 요소가 남아 있는지 확인 한다. 있으면 true, 없으면 false.
  Object next(); // 다음 요소를 읽어 온다. next()를 호출 하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전.
  void remove(); // next()로 읽어 온 요소를 삭제한다. next()를 호출한 다음에 remove()를 호출해야 한다.(선택적)
 }
  public interface Collection{
  public Iterator iterator();
 }

-------------------------------------------------------------------------------------------------------------------------------------------------

 

package Collection_Framework;
import java.util.*;
public class Iterator1 {

 public static void main(String[] args) {

  ArrayList<String> list = new ArrayList<String>();
  
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  Iterator<String> iter = list.iterator();
  
  while(iter.hasNext()) {
   Object obj = iter.next();
   System.out.println(obj);
  }
 }
}

 

출력 결과 :

1
2
3
4
5

 

===========================================================================================

* ListIterator

 : 양방향으로 이동하기 때문에 각 요소간의 이동이 자유롭다.

다만 이동하기 전에 반드시 hasNext() 나 hasPrevious()를 호출하여 이동할 수 있는지 확인해야 한다.

 

- interface 메서드

void add(Object o) // 컬렉션에 새로운 객체 o를 추가한다.

boolean hasNext() // 읽어 올 다음 요소가 남아있는지 확인한다. 있으면 true, 없으면 false를 반환

boolean hasPrevious() // 읽어 올 이전 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false를 반환

Object next() //다음 요소를 읽어 온다. next()를 호출하기 전에 hasNext()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

Object previous() // 이전 요소를 읽어온다. previous()를 초훌하기 전에 hasPrevious()를 호출해서 읽어 올 요소가 있는지 확인하는 것이 안전한다.

int nextindex() // 다음 요소의 index를 반환한다.

int previousindex() // 이전 요소의 index를 반환한다.

void remove() // next() 또는 previous()로 읽어 온 요소를 삭제한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야 한다.

void set(Object o) // next()또는 previous()로 읽어 온 요소를 지정된 객체(o)로 변경한다. 반드시 next()나 previous()를 먼저 호출한 다음에 이 메서드를 호출해야한다.

 

예제.

package Collection_Framework;
import java.util.*;
public class listlterator1 {
 public static void main(String[]args) {
  ArrayList<String> list = new ArrayList<String>();
  list.add("1");
  list.add("2");
  list.add("3");
  list.add("4");
  list.add("5"); 
  
  ListIterator<String> iter = list.listIterator();
  
  while (iter.hasNext()) {
   System.out.print(iter.next());
  }
  System.out.println();
  
  while(iter.hasPrevious()) {
   System.out.print(iter.previous());
  }
  System.out.println();
 }
}

 

 

출력 결과 :

12345
54321

 

* Enumeration

- interface 메서드

boolean hasMoreElements() // 읽어 올 요소가 남아 있는지 확인한다. 있으면 true, 없으면 false 반환. Iterator의 hasNext()와 같음

Object nextElement() // 다음 요소를 읽어 온다. nextElement()를 호출하기 전에 hasMoreElements()를 호출해서 읽어올 요소가 남아 있는지 확인하는 것이 안전한다. Iterator의 next()와 같다.