[Day24] Java 24 - 컬렉션 프레임워크(JCF), ArrayList, Vector, Iterator/enumerator, LinkedList, Stack, Queue

[Day24] Java 24 [9/13]

 

컬렉션 프레임워크 (JCF)

<1> 컬렉션 프레임워크

  ㄱ. 컬렉션( collection )

    데이터 집합 

  ㄴ. 프레임워크 ( framework ) 

    틀( 규범 ) / 복잡한 문제를 해결하기 위한 뼈대 역할 구조 / 표준화된 프로그래밍 방식의 의미

 

-> 데이터 군(집합)을 저장(다루는)하는 클래스들을 표준화한 설계

-> 표준화 체계( 뼈대, 틀, 설계 )

 

<2>   배열 - 데이터 집합 + 개발자 직접 구현

 

<3>   컬레션 프레임워크 구성 - 핵심 인터페이스 ( 3가지 ) 이해

Collection 인터페이스                                  Map 인터페이스

p580 [표 11-2] 15 추상메서드                    키(key)+값(value)  쌍 -> 데이터 집합

데이터 집합 - 데 추(add, addAll)                엔트리 (Entry = key + value)

                     데 제( clear,remove)             순서 X, 키 중복 X, 값 중복 O

                        ↑

List 인터페이스                Set 인터페이스                 

            부모 - 15 추상메서드

순서 O                              순서 X

중복 O                               중복 X 

         

<4>

List 구현한 클래스 : [ArrayList] Ex08_02.java, LinkedList, Stack, Vector 등등

Set        "             : HashSet, TreeSet 등등

Map      "             : HashMap, TreeMap, Hashtable, Properties 등등   

 

---

ArrayList 컬렉션 클래스

1) 가장 많이 사용되는 컬렉션 클래스이다. 

2) Collection 인터 ->  List 인페를 구현한 클래스

특징 :  순서 O, 중복 허용 O

 

정수 데이터의 집합 - 배열 사용

배열 문제점(단점)                                                          ArrayList

1) 100 ->  자동으로 배열크기 증가 X                       ==>  크기 자동 증가

2) 데이터 처리하는 작업(  추가, 수정 , 삽입, 삭제 )  등등

 

// <E> 제네릭 X
// ArrayList list = new ArrayList(   );  // 10 초기 용량
ArrayList list = new ArrayList( 10 );  // 10 초기 용량
			
// Object e :  모든 타입 매개변수 사용 가능
// e  == [e]lement == 요소

// 1) list.add()
list.add( 10 );  // int -> 오토박싱  Integer -> Object  매개변수 다형성
	
// 10개 넘게 저장가능
for (int i = 0; i < 10  ; i++) {
    list.add(   Rnd.getRand(1, 100) );	
}
// list.add(index , element );
list.add( 2, 100);  // 삽입

// 2) list.size()
System.out.println(  list.size() );  // 크기		

// 3) list.get()
System.out.println(  list.get(3) );

// foreach 문 == 확장 for문          편리하네.
/*
for (Object   n :  list) {
	System.out.printf( "[%d]",   n  );
}
*/
		
// 4) list.clear(); = 모든 요소 삭제
// 5-1) list.remove( index );
// 5-2) list.remove( 요소 );

// 6. list.clone()
ArrayList  list1 = new ArrayList();
list1.add( new Integer(4) );
list1.add( 5 );
list1.add(2);
list1.add(3);
list1.add(1);	
ArrayList li = (ArrayList) list1.clone();

String 배열 -> ArrayList 

String [] names = { "김가율", "이재민", "허정연", "임희진", "정민지"}  ;
		
List  l = Arrays.asList( names );  // T...a 가변 인자       ( 문제 )
ArrayList  list = new ArrayList(l);

정렬

list1.sort( new Comparator() {
	@Override
	public int compare(Object o1, Object o2) {
		int a = (int) o1;
		int b = (int) o2;
		return b - a;  // a-b
	}
} );

java.util.Iterator(반복자) 인터페이스 & Enumerator(열거자)

// 모든 요소(element)를 출력. - 반복자(iterator) 사용
// java.util.Iterator 인터페이스
Iterator  ir = list.iterator();  // iterator() 메서드 		
// boolean hasNext() 
while (ir.hasNext()) {
	// next()
	String name = (String) ir.next();
	System.out.println( name );
}

// 열거자
Enumeration  en = list.elements();
while (en.hasMoreElements()) {
	int n = (int) en.nextElement();
	System.out.println( n );
}

// 반복자
Iterator  ir = list.iterator();
	while (ir.hasNext()) {
	int n = (int) ir.next();
	System.out.println( n );
}

 

String 정렬

list.sort( new Comparator() {  //  익명(무명) 클래스 
	@Override
	public int compare(Object o1, Object o2) {
	    String s1=	(String)o1;
	    String s2=	(String)o2;
	    // String 메서드 설명
		// return s1.compareTo(s2);   // 0    양수   음수
	    return s2.compareTo(s1);
	}
} );

// 람다표현식   -> 람다연산자
list.sort(   (o1,o2) -> ((String)o1).compareTo(((String)o2))  );  
		 
// Collections.sort(list);  // 오름차순 정렬
// Collections.sort(list , Collections.reverseOrder() ); // 내림차순 정렬

ArrayList & Vector - List 인터페이스구현

- 100% 동일한 컬렉션 클래스

- 차이점)  멀티 스레드 안전성 ( Vector 동기화 처리 O )

Vector  list = new Vector(10);		
System.out.println( list.capacity() +" / " + list.size() );  // 초기 용량 : 10
		
list.add(1);
list.add(2);
list.add(3);

System.out.println( list.capacity() +" / " + list.size() );  // 초기 용량 : 10, 3
		
// list.add(1, 500);  // insert 삽입
// list.set(1, 500);  // 수정
// list.setElementAt(500, 1); // 수정
		
System.out.println(  list );
		
// 용량을 확장하는 메서드
// list.ensureCapacity( 16 );
	 
list.setSize(5);

// list.firstElement() == list.get(0) == list.elementAt(0)
// list.lastElement()  == list.get( list.size() - 1 )
		
//list.removeElement(list);
//list.removeElementAt(0)
		
// list.subList(0, 0);

 

LinkedList

순서 유지 O, 중복 허용  O, 비순차적으로 삽입/삭제  - 성능 우수

단방향             링크드리스트

양방향(더블)           "

환형                        "

더블 환형                "

 

개념

Node n1 = new Node();
n1.value = 10; 
Node n2 = new Node();
n2.value = 20; 		
Node n3 = new Node();
n3.value = 30; 
Node n4 = new Node();
n4.value = 40;
		
n1.next = n2;
		
Node n100 = new Node();
n100.value = 100;

n2.next = n3;
		
n3.next = n4;
n4.next = null;
		
Node n5 = new Node();
n5.value = 50;
		
n4.next = n5;
n5.next = null;
		
n2.next = null;
Node node = n1;
		
while(  node != null ) {		
	System.out.println( node.value );
	node = node.next;
}

class Node{
	Node next;  // 다음 요소(노드)의 주소값을 저장할 참조 변수
	Node prev;  // 이전 요소(노드)의 주소값을 저장할 참조 변수
	int value;     // 저장할 값
}

// ArrayList, Vector () + 10 용량
LinkedList   list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);		
list.addFirst(40);
					
//System.out.println( list.get(2) ); 
list.getFirst();
list.getLast(); // 노드(node)
		
// list.remove();
// 문제)   요소(노드)의 값이 20보다 큰 노드는 모두 제거하자. 
// 로직	
// [ 10, 30]
//    0    1    
// 삭제를 하더라도   다음 노드(요소)의 인덱스가 변경이 되지 않도록 하기 위해 뒤에 요소부터 체크하고 삭제하자..
for (int i = list.size()-1; i >=0; i--) {
	if(   (int)list.get(i) >  20  )  list.remove(i);
}

list.removeIf(  new Predicate() {
	@Override
	public boolean test(Object t) {
		int n = (int) t;  // 다운캐스팅 + 언박싱 ( Object -> Integer -> int )
		return   n > 20 ;
	}  // 익명클래스
	
}  );

//list.removeIf(  t ->  (int)t > 20 );
//System.out.println(  list );
		
Iterator  ir	= list.descendingIterator();
while (ir.hasNext()) {
	int n = (int) ir.next();
	System.out.println( n );
} // while

// list.clear();
// System.out.println(list.isEmpty());

* 결론1)  순차적으로 추가/삭제                     ArrayList  >  LinkedList 성능 우수
* 결론2) 비순차적으로 추가/삭제                  ArrayList  < LinkedList 성능 우수

 

Stack & Queue

// stack 구조( LIFO )   push()          peek()               pop()
// queue 구조( FIFO)   offer()         peek()                poll()
//                               isEmpty() / empty()
//                                size(), remove(), element(), search() 등등 메서드

 

스택 구조 : LIFO( Last In  First Out )

Stack => Vector => List

add()
push()
pop()
peek()

Stack s  = new Stack();
s.push("박예린");
s.push("조민경");
s.push("노용준");
						
// 요소를 제거하지 않고 마지막 요소 읽기
System.out.println( s.peek() );  
		
// 요소를 제거하고  마지막 요소 읽기
System.out.println( s.pop() );  
System.out.println( s.pop() );  
System.out.println(  s.size() );

while(  s.size() != 0) {
	System.out.println( s.pop() );  
}

while( ! s.empty() ) {
	System.out.println( s.pop() );  
}

int index = s.search("조민경");
System.out.println(index );

 

큐 구조 : FIFO( First In First Out )

Queue q = new LinkedList();
q.offer("임종윤");
q.offer("황수빈");
q.offer("김가율");
		
System.out.println( q );
		
// System.out.println(  q.poll() );
// System.out.println(  q.peek() );
		
while (  !q.isEmpty()) {
	System.out.println( q.poll() );	
}

스택활용 : 괄호체크

Stack  s = new Stack();
String expression ;
System.out.print("> 표현식 입력 ? ");
expression = new Scanner(System.in).nextLine();
		
for (int i = 0; i < expression.length(); i++) {		
	char one = expression.charAt(i);	
	if(   one == '(' ) {
		s.push(one);  // '('   -> "("
	}else if(one == ')' ) {
		s.pop();
	}
}// for
	
System.out.println(  s.size() );
		
if (  s.empty() ) {
	System.out.println("괄호가 일치한다.");
} else {
	System.out.println("괄호가 일치하지 않는다.");
}