9차시 컬렉션 프레임워크 활용

학습목표

컬렉션 프레임워크를 이해하고 프로그래밍에 적용할 수 있다.

List 인터페이스 관련 컬렉션 클래스에 대하여 이해하고 프로그래밍에 활용할 수 있다.

Set/Map 인터페이스 관련 컬렉션 클래스에 대하여 이해하고 프로그래밍에 활용할 수 있다.

 

컬렉션 프레임워크(collection framework)

자료구조를 효율적으로 사용하고, 일관성 있게 접근하기 위한 툴

패키지 : java.util

• 컬렉션 인터페이스 : 자료구조의 추가, 수정, 삭제, 검색을 위한 인터페이스
  • Collection : Queue, List, Set
  • Map
• 컬렉션 클래스 : 컬렉션 인터페이스를 구현한 클래스
  • LinkedList --> Queue
  • LinkedList, Array List, Vector, Stack  --> List
  • HashSet, TreeSet  --> Set
  • HashMap, Hashtable, TreeMap, Properties  --> Map

Collection 인터페이스

• 컬렉션 프레임워크의 최상위 인터페이스
• 객체를 추가, 삭제, 검색 등을 할 수 있는 일반적인 자료구조의 기능을 정의

기능	주요 메소드	설명
객체 추가	boolean add(E o)	컬렉션에 객체 추가
객체 삭제	boolean remove(Object o)	컬렉션에 객체 삭제
	void clear()	컬렉션의 모든 객체를 삭제
객체 검색	boolean contains(Object o)	컬렉션에 객체가 존재하는 여부
	int size()	컬렉션에 저장된 객체의 개수
	boolean isEmpty()	컬렉션이 비워져 있는지 여부 검사
	Iterator<E> iterator()	반복자 객체 반환
기타	Object[] toArray()	컬렉션에 있는 객체를 배열로 변환하여 반환

 

List 인터페이스

• Collection 인터페이스의 하위 인터페이스
• Collection 인터페이스의 모든 메소드를 상속함
• 객체의 추가, 삭제, 검색, 수정이 가능
• 순서가 있는 자료 구조로 배열과 같이 인덱스로 관리
• 동일한 객체의 중복 저장 가능
• List 인터페이스를 구현한 컬렉션 클래스
  • ArrayList
  • LinkedList
  • Vector
  • Stack

기능	주요 메소드	설명
객체 검색	ListIterator<E> listIterator()	List 반복자 객체 반환
	E get(int index)	index 위치의 객체 반환
	int indexOf(Object o)	객체의 index 값을 반환
객체 수정	E set(int index, E element)	index 위치의 객체를 주어진 객체로 변경

보통 제네릭은 다음과 같은 타입들이 많이 쓰인다.

타입	설명
<T>	Type
<E>	Element
<K>	Key
<V>	Value
<N>	Number

 

ArrayList 클래스

• List 인터페이스를 구현한 대표적인 컬렉션 리스트
• 모든 종류의 객체를 저장할 수 있는 자료 구조
• 한 종류의 객체만 저장할 수 있는 자료 구조

// 모든 종류의 객체를 저장할 수 있는 자료 구조
ArrayList list = new ArrayList();
// List 인터페이스 참조 변수로 객체 참조
List list = new ArrayList();

// 한 종류의 객체만 저장할 수 있는 자료 구조(제네릭)
ArrayList<String> list = new ArrayList<String>();
List<String> list = new ArrayList<String>();

제네릭(Generic)

우리가 어떤 자료구조를 배포하려고 한다. 그런데 String 타입도 지원하고 싶고 Integer 타입도 지원하고 싶고 많은 타입을 지원하고 싶다. 그럴때마다 하나하나 타입을 만드는 것은 비효율적이기 때문에 제네릭을 사용한다.

제네릭은 클래스 내부에서 지정하는 것이 아닌 외부에서 사용자에 의해 지정되는 것을 의미한다. 한마디로 특정(Specific) 타입을 미리 지정해주는 것이 아닌 필요에 의해 지정할 수 있도록 하는 일반(Generic) 타입이라는 것이다.

제네릭을 사용하면 잘못된 타입이 들어올 수 있는 것을 컴파일 단계에서 방지할 수 있고, 클래스 외부에서 타입을 지정해주기 때문에 따로 타입을 체크하고 변환해줄 필요가 없다.

반복자 인터페이스

• 컬렉션에 저장된 객체를 순차적으로 접근하기 위한 인터페이스
• 컬렉션 클래스에 구현되어 있음

인터페이스	주요 메소드	설명
Enumeration	boolean hasMoreElements()	컬렉션에서 읽어올 다음 객체가 있는지 여부
	E nextElement()	다음 객체를 반환
Iterator	boolean hasNext()	컬렉션에서 읽어올 다음 객체가 있는지 여부
	E next()	다음 객체를 반환
	void remove()	객체 삭제
ListIterator	boolean hasNext()	컬렉션에서 읽어올 다음 객체가 있는지 여부
	E next()	다음 객체를 반환
	void remove()	객체 삭제
	void add(E e)	객체 추가
	void add(E e)	객체 변경
	boolean hasPrevious()	컬렉션에 읽어올 이전 객체가 있는지 여부
	E previous()	이전 객체를 반환

// ArrayList 클래스의 객체를 생성하여 List 인터페이스의 참조 변수로 참조함
List list = new ArrayList();
list.add("AAA");
list.add("BBB");
// list 참조 변수의 iterator() 메소드를 이용하여 Iterator 반복자 객체 생성
Iterator it = list.iterator();

while(it.hasNext()) {  // 가져올 객체가 있으면 true, 없으면 false
    System.out.println(it.next());
}

갑자기 생성자 왜 써야돼... 하면서 검색하다 본 글
https://procogif.tistory.com/17

List랑 ArrayList가 그래서 어떻게 다른겨,,? 하다 본 글
https://yoon-dailylife.tistory.com/7

ArrayList와 반복자 실습

package arraylist;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ArrayListClass {
	int x;
	// 생성자 메소드
	ArrayListClass(){
		x = 10;
	}
	// 메소드 오버라이딩
	public String toString() {
		return "[ArrayListClass] x= "+x;
	}
	public void toPrint(Iterator<String> it) {
		System.out.print("[ ");
		while(it.hasNext())
			System.out.print(it.next()+" ");
		System.out.println("]");
	}	

	public static void main(String[] args) {
		
		ArrayListClass als = new ArrayListClass();
		
		System.out.println("[모든 객체를 저장할 수 있는 ArrayList]");
		ArrayList list = new ArrayList();
		
		list.add(new String("AAAA"));
		list.add(123);
		list.add(100.45);
		list.add(als);
		
		System.out.println("< 반복자 없이 출력 >");
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		System.out.println(" < Iterator 반복자 사용>");
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		System.out.println("[String 객체만 저장할 수 있는 ArrayList]");
		ArrayList<String> list1 = new ArrayList<String>();
		list1.add(new String("AA"));  // 추가
		list1.add(new String("BB"));
		list1.add(new String("DD"));
		list1.add(new String("EE"));
		als.toPrint(list1.iterator());
		
		System.out.println("add(2,CC)");  // 끼워넣기
		list1.add(2, new String("CC"));
		als.toPrint(list1.iterator());
		
		System.out.println("set(1,ZZ)");  // 수정하기
		list1.set(1, new String("ZZ"));
		als.toPrint(list1.iterator());
		
		System.out.println("remove(ZZ)");  // 삭제하기
		list1.remove("ZZ");
		als.toPrint(list1.iterator());
		
		System.out.println("contains(EE) : "+list1.contains("EE"));
		System.out.println("get(3) : "+list1.get(3));
		System.out.println("indexOf(CC) : "+list1.indexOf("CC"));
		System.out.println("size() : "+list1.size());
		System.out.println("isEmpty() : "+list1.isEmpty());
		
        // list형을 Array형으로 변경(toArray())
		Object[] arr = list1.toArray();
		System.out.print("toArray() : ");
		for(int i=0; i<arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		
        // 이전(previous) 객체 반환
		System.out.println("[ListIterator] Previous");
		ListIterator<String> lit = list1.listIterator();
		while(lit.hasNext()) lit.next();
		while(lit.hasPrevious()) {
			System.out.print(lit.previous()+" ");
		}
		System.out.println();
		
        // 객체 비우기
		list1.clear();
		System.out.println("clear() + isEmpty() : "+list1.isEmpty());
	}	

}

[모든 객체를 저장할 수 있는 ArrayList]
< 반복자 없이 출력 >
AAAA
123
100.45
[ArrayListClass] x= 10
 < Iterator 반복자 사용>
AAAA
123
100.45
[ArrayListClass] x= 10
[String 객체만 저장할 수 있는 ArrayList]
[ AA BB DD EE ]
add(2,CC)
[ AA BB CC DD EE ]
set(1,ZZ)
[ AA ZZ CC DD EE ]
remove(ZZ)
[ AA CC DD EE ]
contains(EE) : true
get(3) : EE
indexOf(CC) : 1
size() : 4
isEmpty() : false
toArray() : AA CC DD EE 
[ListIterator] Previous
EE DD CC AA 
clear() + isEmpty() : true

LinkedList 클래스

• List 인터페이스와 Queue 인터페이스를 구현
• LinkedList 자료 구조와 Queue 자료 구조 사용
• 인접한 노드와의 참조 링크를 이용한 체인과 같은 구조
• ArrayList 클래스와 동일하게 사용

Queue 자료 구조

• FIFO(First In First Out) 구조
  • 먼저 추가된 객체가 먼저 나오는 파이프와 같은 구조
  • offer() : 객체를 추가 (IN)
  • peek() : 처음 추가된 객체를 가져옴(가져온 객체는 삭제되지 않음)
  • poll() : 처음 추가된 객체를 가져옴(가져온 객체는 삭제됨) (OUT)

LinkedList 클래스 실습

package LinkedList;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListClass {
	
	public void toPrint(ListIterator<String> it) {
		System.out.print("[ ");
		while(it.hasNext())
			System.out.print(it.next()+" ");
		System.out.println("]");
	}

	public static void main(String[] args) {
		LinkedListClass llc = new LinkedListClass();
		LinkedList<String> list = new LinkedList<String>();
		
		System.out.println("[LinkedList 자료 구현]");
		list.add(new String("AAA"));
		list.add(new String("BBB"));
		list.add(new String("CCC"));
		list.add(new String("DDD"));
		llc.toPrint(list.listIterator());
		
		System.out.print("add(2, EEE) : ");
		list.add(2, new String("EEE"));
		llc.toPrint(list.listIterator());
		
		System.out.print("set(1, ZZZ) : ");
		list.set(1, new String("ZZZ"));
		llc.toPrint(list.listIterator());
		
		System.out.print("remove(ZZZ) : ");
		list.remove("ZZZ");
		llc.toPrint(list.listIterator());
		
		System.out.println("contains(EEE) : "+list.contains("EEE"));
		System.out.println("get(3) : "+list.get(3));
		System.out.println("indexOf(CCC) : "+list.indexOf("CCC"));
		System.out.println("size() : "+list.size());
		System.out.println("isEmpty() : "+list.isEmpty());
		
		System.out.println("[Queue 자료 구조 구현]");
		
		LinkedList<String> qlist = new LinkedList<String>();
		
		qlist.offer(new String("AAA"));
		qlist.offer(new String("BBB"));
		qlist.offer(new String("CCC"));
		qlist.offer(new String("DDD"));
		llc.toPrint(qlist.listIterator());
		
		System.out.println("peek() : "+qlist.peek());
		System.out.println("peek() : "+qlist.peek());
		llc.toPrint(qlist.listIterator());
		System.out.println("poll() : "+qlist.poll());
		llc.toPrint(qlist.listIterator());
		System.out.println("poll() : "+qlist.poll());
		llc.toPrint(qlist.listIterator());
		System.out.println("poll() : "+qlist.poll());
		llc.toPrint(qlist.listIterator());
		System.out.println("poll() : "+qlist.poll());
		llc.toPrint(qlist.listIterator());
	}

}

[LinkedList 자료 구현]
[ AAA BBB CCC DDD ]
add(2, EEE) : [ AAA BBB EEE CCC DDD ]
set(1, ZZZ) : [ AAA ZZZ EEE CCC DDD ]
remove(ZZZ) : [ AAA EEE CCC DDD ]
contains(EEE) : true
get(3) : DDD
indexOf(CCC) : 2
size() : 4
isEmpty() : false
[Queue 자료 구조 구현]
[ AAA BBB CCC DDD ]
peek() : AAA
peek() : AAA
[ AAA BBB CCC DDD ]
poll() : AAA
[ BBB CCC DDD ]
poll() : BBB
[ CCC DDD ]
poll() : CCC
[ DDD ]
poll() : DDD
[ ]

Vector 클래스

• ArrayList와 동일한 구조와 사용 방법
• 다양한 메소드 제공
• 기본 용량 : 10개

구분	주요 메소드	설명
생성자 메소드	Vector()	기본 용량 10개 생성
	Vector(int size)	size 만큼 용량 생성
	Vector(int size, int inc)	size 만큼 용량 생성, inc 만큼 용량 증가
멤버 메소드	int capacity()	용량 반환
	int size()	저장된 객체의 개수 반환
	void setSize(int size)	size 크기로 용량 설정
	void trimToSize()	저장된 객체의 개수만큼 용량을 설정

Stack 클래스

• Vector 클래스의 하위 클래스
• LIFO(Last In First Out) 구조
  • 마지막에 추가된 객체가 먼저 나오는 항아리와 같은 구조
  • push() : 객체를 추가 (IN)
  • peek() : 마지막에 추가된 객체를 가져옴(가져온 객체는 삭제되지 않음)
  • pop() : 마지막에 추가된 객체를 가져옴(가져온 객체는 삭제됨) (OUT)

Vector와 Stack 클래스 실습

package vectorstack;

import java.util.ListIterator;
import java.util.Stack;
import java.util.Vector;

public class VectorStack {
	
	public void toPrint(ListIterator<String> it) {
		System.out.print("[ ");
		while(it.hasNext())
			System.out.print(it.next()+" ");
		System.out.println("]");
	}
	
	public static void main(String[] args) {
		VectorStack vs = new VectorStack();
		Vector<String> v = new Vector<String>();
		
		System.out.println("[Vector 자료 구현]");
		v.add(new String("AAA"));
		v.add(new String("BBB"));
		v.add(new String("CCC"));
		v.add(new String("DDD"));
		vs.toPrint(v.listIterator());
		
		System.out.print("add(2, EEE) : ");
		v.add(2, new String("EEE"));
		vs.toPrint(v.listIterator());
		
		System.out.print("set(1, ZZZ) : ");
		v.set(1, new String("ZZZ"));
		vs.toPrint(v.listIterator());
		
		System.out.print("remove(ZZZ) : ");
		v.remove("ZZZ");
		vs.toPrint(v.listIterator());
		
		System.out.println("contains(EEE) : "+v.contains("EEE"));
		System.out.println("get(3) : "+v.get(3));
		System.out.println("indexOf(CCC) : "+v.indexOf("CCC"));
		System.out.println("isEmpty() : "+v.isEmpty());
		
		System.out.println("[Vector 용량]");
		Vector v1 = v;
		Vector v2 = new Vector(5);
		Vector v3 = new Vector(3, 2); // 처음엔 3개 용량으로 시작하고, 가득 차면 2개씩 늘어나라
		System.out.println("v1 : capacity() : "+v1.capacity());
		System.out.println("v1 : size() : "+v1.size()); // 개수
		System.out.println("v1 : trimToSize() : capacity() : "+v1.capacity());
		System.out.println("v1 : trimToSize() : size() : "+v1.size());
		
		System.out.println("v2 : capacity() : "+v2.capacity());
		v2.setSize(25);
		System.out.println("v2 : setSize(25) : capacity() : "+v2.capacity());
		

		System.out.println("v3 : capacity() : "+v3.capacity());
		System.out.println("v3 : size() : "+v3.size());
		v3.add("111");
		v3.add("222");
		v3.add("333");
		v3.add("444");  // v3 용량이 차서 용량 2개를 추가하여 5개가 됨
		System.out.println("v3 : capacity() : "+v3.capacity());
		System.out.println("v3 : size() : "+v3.size());
		
		System.out.println("[Stack 자료 구조 구현]");
		Stack<String> st = new Stack<String>();
		st.push(new String("AAA"));
		st.push(new String("BBB"));
		st.push(new String("CCC"));
		st.push(new String("DDD"));
		vs.toPrint(st.listIterator());
		
		System.out.println("peek() : "+st.peek());
		System.out.println("peek() : "+st.peek());
		
		vs.toPrint(st.listIterator());
		System.out.println("pop() : "+st.pop());
		vs.toPrint(st.listIterator());
		System.out.println("pop() : "+st.pop());
		vs.toPrint(st.listIterator());
		System.out.println("pop() : "+st.pop());
		vs.toPrint(st.listIterator());
		System.out.println("pop() : "+st.pop());
        vs.toPrint(st.listIterator());
	}

}

[Vector 자료 구현]
[ AAA BBB CCC DDD ]
add(2, EEE) : [ AAA BBB EEE CCC DDD ]
set(1, ZZZ) : [ AAA ZZZ EEE CCC DDD ]
remove(ZZZ) : [ AAA EEE CCC DDD ]
contains(EEE) : true
get(3) : DDD
indexOf(CCC) : 2
isEmpty() : false
[Vector 용량]
v1 : capacity() : 10
v1 : size() : 4
v1 : trimToSize() : capacity() : 10
v1 : trimToSize() : size() : 4
v2 : capacity() : 5
v2 : setSize(25) : capacity() : 25
v3 : capacity() : 3
v3 : size() : 0
v3 : capacity() : 5
v3 : size() : 4
[Stack 자료 구조 구현]
[ AAA BBB CCC DDD ]
peek() : DDD
peek() : DDD
[ AAA BBB CCC DDD ]
pop() : DDD
[ AAA BBB CCC ]
pop() : CCC
[ AAA BBB ]
pop() : BBB
[ AAA ]
pop() : AAA
[ ]

Set 인터페이스

• Collection 인터페이스의 하위 인터페이스
• 객체의 추가, 삭제, 검색, 수정이 가능
• 순서가 없는 자료 구조
• 동일한 객체의 중복 저장 불가
• 주요 메소드 : List 컬렉션과 동일

HashSet 클래스

• Set 인터페이스를 구현한 컬렉션 클래스

Map 인터페이스

• 키(key)와 값(value)의 쌍으로 이루어진 구조를 정의
• 순서가 없는 자료 구조
• 키(key)는 중복 불가
• 값(value)은 중복 가능

HashMap 클래스

• Map 인터페이스를 구현한 컬렉션 클래스

HashSet과 HashMap 클래스 실습

package setmap;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class SetMap {

	public static void main(String[] args) {
		
		System.out.println("[HashSet 클래스 실습]");
		Set<String> s = new HashSet<String>();
		s.add(new String("Java"));
		s.add(new String("Program"));
		s.add(new String("Eclipse"));
		s.add(new String("Java"));  // 중복 저장 안됨
		
		System.out.println("size() : "+s.size());
		Iterator<String> it = s.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		s.remove("Eclipse");
		System.out.println("remove(Eclipse), size() : "+s.size());
		it = s.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		System.out.println("contains(Java) : "+s.contains("Java"));
		System.out.println("isEmpty() : "+s.isEmpty());
		
		System.out.println("[HashMap 클래스 실습]");
		Map<Character, String> m = new HashMap<Character, String>();
		m.put('A', "Apple");
		m.put('B', "Banana");
		m.put('M', "Melon");
		m.put('O', "Orange");
		System.out.println("size() : "+m.size());
		
		Set<Character> set = m.keySet();
		Iterator<Character> sit = set.iterator();
		while(sit.hasNext()) {
			Character key = sit.next();
			String value = m.get(key);
			System.out.println("K="+key+" V="+value);
		}
		
		m.remove('M');
		System.out.println("remove(M), size() : "+m.size());
		System.out.println("containsKey(B) : "+m.containsKey('B'));
		System.out.println("containsValue(Orange) : "+m.containsValue("Orange"));
		System.out.println("isEmpty() : "+m.isEmpty());
	}	

}

[HashSet 클래스 실습]
size() : 3
Java
Program
Eclipse
remove(Eclipse), size() : 2
Java
Program
contains(Java) : true
isEmpty() : false
[HashMap 클래스 실습]
size() : 4
K=A V=Apple
K=B V=Banana
K=M V=Melon
K=O V=Orange
remove(M), size() : 3
containsKey(B) : true
containsValue(Orange) : true
isEmpty() : false

적용하기

1) 입력 메뉴 : ID와 암호를 입력 받아서 컬렉션에 저장한다.
2) 로그인 메뉴 : ID와 암호를 입력 받아서 로그인한다.
3) 목록 메뉴 : 등록된 ID와 암호를 화면에 출력한다.

(내 답)

package setmap;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class menu {
	
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		
		System.out.print("신규 아이디를 입력하세요 : ");
		String id = s.nextLine();
		System.out.print("신규 비밀번호를 입력하세요 : ");
		String password = s.nextLine();
		
		List<String> list = new ArrayList<String>();
		list.add(id);
		list.add(password);
		
		String id2;
		String password2;
		while(true) {
			System.out.println("로그인 하려는 아이디를 입력하세요 : ");
			id2 = s.nextLine();
			System.out.println("로그인 하려는 비밀번호를 입력하세요 : ");
			password2 = s.nextLine();
			
			if(list.contains(id2) && list.contains(password2)) {
				System.out.println("ID = "+id2);
				System.out.println("ID = "+password2);
				System.out.println("로그인에 성공하였습니다.");
				break;
			} else {
				System.out.println("다시 아이디와 비밀번호를 입력하세요");
			}
		
		}
	}

}

신규 아이디를 입력하세요 : cat
신규 비밀번호를 입력하세요 : 123
로그인 하려는 아이디를 입력하세요 : 
batman
로그인 하려는 비밀번호를 입력하세요 : 
123
다시 아이디와 비밀번호를 입력하세요
로그인 하려는 아이디를 입력하세요 : 
cat
로그인 하려는 비밀번호를 입력하세요 : 
123
ID = cat
ID = 123
로그인에 성공하였습니다.

ㅋㅋㅋㅋ머릿속에서는 입력, 로그인, 메뉴 함수 만들어서 main에서는 객체 만들고 함수를 쓰고 싶은데 응용을 못해서 냅다 main에 노가다로 쭉 쓰기만 한다 ㅠ 실행은 되지만..? 유연성은 개나 줘버린...

 

아이디랑 패스워드니까 Map에 저장해야 하나?

 

(해설)

package setmap;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Login {
	Map<String, String> map;
	
	public Login() {
		map = new HashMap<String, String>();
	}
	public boolean input(String id, String pw) {
		if(map.containsKey(id)) {  // 동일한 ID가 있는지 검사
			return false;
		} else {
			map.put(id,  pw);  // 동일한 ID가 없으면 저장
			return true;
		}
	}
	public boolean login(String id, String pw) {
		String match = map.get(id);  // id에 대한 암호 가져오기
		if (match != null) {  // id가 없으면 null
			if(match.equals(pw)) return true;
		}
		return false;
	}	
	public String toString() {  // HashMap 자료 전체 출력
		String result = "";
		Set<String> set = map.keySet();
		Iterator<String> it = set.iterator();
		while(it.hasNext()) {
			String id = it.next();
			String pw = map.get(id);
			result += "ID=["+id+"] PW=["+pw+"]\n";
		}
		return result;
	}
	
	public static void main(String[] args) {
		
		Login lo = new Login();
		int menu = 0;
		Scanner kbd = new Scanner(System.in);
		String id="";
		String pw="";
		
		do {
			System.out.print("[1:입력][2:목록][3:로그인][4:종료]: ");
			menu = kbd.nextInt();
			kbd.nextLine();  // 엔터값 처리
			
			switch(menu) {
			case 1:
				System.out.print("ID를 입력하세요 : ");
				id = kbd.nextLine();
				System.out.print("암호를 입력하세요 : ");
				pw = kbd.nextLine();
				if(lo.input(id, pw))
					System.out.println("등록 성공!!");
				else System.out.println("ID 중복으로 등록 실패!!");
				break;
				
			case 2:
				System.out.println(lo.toString());
				break;
				
			case 3:
				System.out.print("ID : ");
				id = kbd.nextLine();
				System.out.print("PW : ");
				pw = kbd.nextLine();
				if(lo.login(id, pw))
					System.out.println("로그인 성공!!");
				else System.out.println("로그인 실패!!");
				break;
				
			case 4:
				System.exit(0);  // 프로그램 종료
			}
		} while(true);
	}

}

[1:입력][2:목록][3:로그인][4:종료]: 1
ID를 입력하세요 : cat
암호를 입력하세요 : 123
등록 성공!!
[1:입력][2:목록][3:로그인][4:종료]: 1
ID를 입력하세요 : cat
암호를 입력하세요 : 111
ID 중복으로 등록 실패!!
[1:입력][2:목록][3:로그인][4:종료]: 2
ID=[cat] PW=[123]

[1:입력][2:목록][3:로그인][4:종료]: 3
ID : cat
PW : 123
로그인 성공!!
[1:입력][2:목록][3:로그인][4:종료]: 3
ID : cat
PW : 111
로그인 실패!!
[1:입력][2:목록][3:로그인][4:종료]: 4

 

강의 한참 남았는데 내일 개강 실화냐 ㅎ..