우당탕탕 히온이네

BufferedReader, StringTokenizer 는 문자열로 활용하기 위하여 사용되며 Scanner를 사용하는 것보다 빠르다.

BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] s = br.readLine().split(" ");
// 1 2 3 4 5 6 7 8 9 10 11 12 한줄로 입력
// Integer.parseInt(s[0]) => 1 s[0] = 1

StringTokenizer

• BufferedReader는 잘라서 배열과 같이 인덱스를 사용하여 접근하여 사용한다.
• StringTokenizer는 공백이 있다면 뒤에 문자열이 공백 자리를 땡겨 채우도록 한다.
• StringTokenizer가 BufferedReader보다 빠르게 사용될 수 있다.
• 문자열을 자르게 위해 split을 사용할땐, split은 정규식을 기반으로 자르는 로직으로서 내부는 복잡하다. 그에 비해 StringTokenizer의 nextToken()메소드는 단순히 공백 자리를 땡겨 채우는 것이다. 그렇기 때문에 속도 차이가 날 수 밖에 없다.
• 정규식이나 인덱스 접근과 같은 처리가 필요없다면 StringTokenizer를 사용하는 것이 효율적이다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in);
StringTokenizer st = new StringTokenizer(br.readLine());

// AB CDD EFFF GH 입력

st.nextToken() // AB
st.nextToken() // CDD
st.nextToken() // EFFF
st.nextToken() // GH


String str = "this%%is%%my%%string"; 
   StringTokenizer st = new StringTokenizer(str,"%%"); 

   while(st.hasMoreTokens()) { 
       System.out.println(st.nextToken()); 
   }
// this is my string

Server 부분

package Chat;

import java.io.*;
import java.net.*;
import java.util.*;

public class TcpMultiChatServer {

	HashMap clients;
	ServerSocket ss = null; // socket 1
	Socket s = null; // socket 2

	public TcpMultiChatServer() {
		clients = new HashMap(); // 객체생성
		Collections.synchronizedMap(clients); // 동기화
	}

	public void start() {
		try {
			ss = new ServerSocket(8000);
			System.out.println("서버 시작되었습니다. 챗 준비 완료");

			while (true) {
				s = ss.accept(); // 응답대기, 클라이언트 소켓
				System.out.println("[" + s.getInetAddress() + ":" + s.getPort() + "] 에서 접속하셨습니다.");
				ServerReceiver thread = new ServerReceiver(s); // user class
				thread.start(); // run() method 유도된다
			}
//		} catch (Exception e) {  e.printStackTrace(); }
		} catch (Exception e) {
			System.out.println("서버 접속 실패!!");
		}
	} // start() end

	public void sendToAll(String msg) {
		Iterator it = clients.keySet().iterator(); // key 값 출력

		while (it.hasNext()) {
			try {
				DataOutputStream dos = (DataOutputStream) clients.get(it.next());
				dos.writeUTF(msg);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	} // sendToAll( ) end

	class ServerReceiver extends Thread { // inner class
		Socket s; // 클라이언트 소켓
		DataInputStream dis;
		DataOutputStream dos;
		String name = "";

		public ServerReceiver(Socket s) {
			// 생성자함수
			this.s = s;
			try {
				dis = new DataInputStream(s.getInputStream()); // 네트워크를 통해서 읽기
				dos = new DataOutputStream(s.getOutputStream()); // 네트워크를 통해서 쓰기
			} catch (Exception e) {
				System.out.println("서버 리시브 실패");
			}
		} // constructor end

		@Override
		public void run() { //thread 실행부
			try {
				name = dis.readUTF();
				sendToAll("#" + name + " 님이 입장하셨습니다."); // user method
				clients.put(name, dos);
				System.out.println("현재 서버 접속자 수는 : " + clients.size() + "입니다.");
				
				while (dis != null) {
					sendToAll(dis.readUTF());
				}
				
				
			} catch (Exception e) {
				e.printStackTrace();
			} fianlly {
				sendToAll("#" + name + "님이 나가셨습니다.");
				clients.remove(name); // 접속자수 제거
				System.out.println("["+s.getInetAddress()+":"+s.getPort()+"] 에서 접속 종료 하셨습니다.");
				System.out.println("현재 서버 접속자 수는 : " + clients.size() + "입니다.");
			}
		}
	} // end ServerReceiver class

	public static void main(String[] args) {
		new TcpMultiChatServer().start();

	}

}

Client 부분

package Chat;

import java.io.*;
import java.net.*;
import java.util.*;

public class TcpMultiChatClient {
	public static void main(String[] args) {
		if (args.length != 1) {
			System.out.println("USAGE : java TcpMultiChatClient nicName ");
			System.exit(0);
		}
		try {
			String ip = "211.200.90.77"; // 127.0.0.1
			Socket s = new Socket(ip, 8000);
			System.out.println("서버에 연결 되었습니다. ");

			Thread send = new Thread(new ClientSender(s, args[0])); // inner class
			Thread reciever = new Thread(new ClientReciever(s)); //

			send.start();
			reciever.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	} // end main

	static class ClientSender extends Thread { // inner class
		Socket s;
		DataOutputStream dos;
		String name;

		public ClientSender(Socket s, String name) { // 매개변수 2개 생성자함수
			this.s = s;
			try {
				dos = new DataOutputStream(s.getOutputStream());
				this.name = name;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		@Override
		public void run() {
			Scanner sc = new Scanner(System.in); // 키보드로부터 입력 받기
			try {
				if (dos != null)
					dos.writeUTF(name);
				while (dos != null)
					dos.writeUTF("[" + name + "] " + sc.nextLine());
			} catch (Exception e) {
				e.printStackTrace();
			}
		} // run() end
	} // end ClientSender

	static class ClientReciever extends Thread { // inner class
		Socket s;
		DataInputStream dis;

		public ClientReciever(Socket s) {
			this.s = s;
			try {
				dis = new DataInputStream(s.getInputStream());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		@Override
		public void run() {
			while (dis != null) {
				try {
					System.out.println(dis.readUTF());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		} // run() end
	} // end ClientReciever

}

🔎 문제

✔ 풀이

map.getOrDefault(key, defaultValue)

• key : 값을 가져와야 하는 요소의 키입니다.
• defaultValue : 지정된 키로 매핑된 값이 없는 경우 반환되어야 하는 기본값입니다.

반환 값 : 찾는 key가 존재하면 해당 key에 매핑되어 있는 값을 반환하고, 그렇지 않으면 디폴트 값이 반환됩니다.

✔ HashMap

HashMap은 Map 인터페이스를 구현한 대표적인 Map 컬렉션입니다. Map 인터페이스를 상속하고 있기에 Map의 성질을 그대로 가지고 있습니다. Map은 키와 값으로 구성된 Entry객체를 저장하는 구조를 가지고 있는 자료구조입니다. 여기서 키와 값은 모두 객체입니다. 값은 중복 저장될 수 있지만 키는 중복 저장될 수 없습니다. 만약 기존에 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대치됩니다. HashMap은 이름 그대로 해싱(Hashing)을 사용하기 때문에 많은 양의 데이터를 검색하는 데 있어서 뛰어난 성능을 보입니다.

선언

HashMap<String,String> map1 = new HashMap<String,String>();//HashMap생성
HashMap<String,String> map2 = new HashMap<>();//new에서 타입 파라미터 생략가능
HashMap<String,String> map3 = new HashMap<>(map1);//map1의 모든 값을 가진 HashMap생성
HashMap<String,String> map4 = new HashMap<>(10);//초기 용량(capacity)지정
HashMap<String,String> map5 = new HashMap<>(10, 0.7f);//초기 capacity,load factor지정
HashMap<String,String> map6 = new HashMap<String,String>(){{//초기값 지정
    put("a","b");
}};

추가 - put

HashMap<Integer,String> map = new HashMap<>();//new에서 타입 파라미터 생략가능
map.put(1,"사과"); //값 추가
map.put(2,"바나나");
map.put(3,"포도");

삭제

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
map.remove(1); //key값 1 제거
map.clear(); //모든 값 제거

값 출력

HashMap을 출력하는 방법에는 다양한 방법이 있습니다. 그냥 print하게 되면 {}로 묶어 Map의 전체 key값, value가 출력됩니다. 특정 key값의 value를 가져오고싶다면 get(key)를 사용하면 되고 전체를 출력하려면 entrySet()이나 keySet()메소드를 활용하여 Map의 객체를 반환받은 후 출력하면 됩니다. entrySet()은 key와 value 모두가 필요할 경우 사용하며 keySet()은 key 값만 필요할 경우 사용하는데 key값만 받아서 get(key)를 활용하여 value도 출력할 수도 있기에 어떤 메소드를 선택하든지 간에 큰 상관이 없어 대부분 코드가 간단한 keySet을 활용하시던데 key값을 이용해서 value를 찾는 과정에서 시간이 많이 소모되므로 많은 양의 데이터를 가져와야 한다면 entrySet()이 좋습니다.(약 20%~200% 성능 저하가 있음)

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
		
System.out.println(map); //전체 출력 : {1=사과, 2=바나나, 3=포도}
System.out.println(map.get(1));//key값 1의 value얻기 : 사과
		
//entrySet() 활용
for (Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}
/* [Key]:1 [Value]:사과
[Key]:2 [Value]:바나나
[Key]:3 [Value]:포도 */

//KeySet() 활용
for(Integer i : map.keySet()){ //저장된 key값 확인
    System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}
/* [Key]:1 [Value]:사과
[Key]:2 [Value]:바나나
[Key]:3 [Value]:포도 */

Iterator를 사용하여 값 출력

HashMap<Integer,String> map = new HashMap<Integer,String>(){{//초기값 지정
    put(1,"사과");
    put(2,"바나나");
    put(3,"포도");
}};
		
//entrySet().iterator()
Iterator<Entry<Integer, String>> entries = map.entrySet().iterator();
while(entries.hasNext()){
    Map.Entry<Integer, String> entry = entries.next();
    System.out.println("[Key]:" + entry.getKey() + " [Value]:" +  entry.getValue());
}
/*[Key]:1 [Value]:사과
[Key]:2 [Value]:바나나
[Key]:3 [Value]:포도*/
		
//keySet().iterator()
Iterator<Integer> keys = map.keySet().iterator();
while(keys.hasNext()){
    int key = keys.next();
    System.out.println("[Key]:" + key + " [Value]:" +  map.get(key));
}
/*[Key]:1 [Value]:사과
[Key]:2 [Value]:바나나
[Key]:3 [Value]:포도*/

✔ HashSet

HashSet은 Set 인터페이스의 구현 클래스입니다. 그렇기에 Set의 성질을 그대로 상속받습니다. Set은 객체를 중복해서 저장할 수 없고 하나의 null 값만 저장할 수 있습니다. 또한 저장 순서가 유지되지 않습니다. 만약 요소의 저장 순서를 유지해야 한다면 JDK 1.4부터 제공하는 LinkedHashSet 클래스를 사용하면 됩니다. Set 인터페이스를 구현한 클래스로는 HashSet과 TreeSet이 있는데 HashSet의 경우 정렬을 해주지 않고 TreeSet의 경우 자동정렬을 해준다는 차이점이 있습니다. Set의 가장 큰 장점은 중복을 자동으로 제거해준다는 점입니다. 

선언

HashSet<Integer> set1 = new HashSet<Integer>();//HashSet생성
HashSet<Integer> set2 = new HashSet<>();//new에서 타입 파라미터 생략가능
HashSet<Integer> set3 = new HashSet<Integer>(set1);//set1의 모든 값을 가진 HashSet생성
HashSet<Integer> set4 = new HashSet<Integer>(10);//초기 용량(capacity)지정
HashSet<Integer> set5 = new HashSet<Integer>(10, 0.7f);//초기 capacity,load factor지정
HashSet<Integer> set6 = new HashSet<Integer>(Arrays.asList(1,2,3));//초기값 지정

추가

HashSet<Integer> set = new HashSet<Integer>();//HashSet생성
set.add(1); //값 추가
set.add(2);
set.add(3);

삭제

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3)); // HashSet생성
set.remove(1); // 값 1 제거
set.clear(); // 모든 값 제거

값 출력

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성

System.out.println(set); //전체출력 [1,2,3]
		
Iterator iter = set.iterator();	// Iterator 사용
while(iter.hasNext()) {//값이 있으면 true 없으면 false
    System.out.println(iter.next());
}

Set컬렉션을 그냥 print하게 되면 대괄호 [ ]로 묶여서 set의 전체 값이 출력됩니다. Set에는 인덱스로 객체를 가져오는 get(index) 메소드가 없습니다. 대신 전체 객체를 대상으로 한 번씩 반복해서 가져오는 반복자(Iterator)를 제공합니다. 반복자 이터레이터 인터페이스를 구현한 객체를 말하는데 iterator() 메소드를 호출하면 얻을 수 있습니다. Iterator에서 하나의 객체를 가져올 때는 next() 메소드를 사용합니다. next() 메소드를 사용하기 전에 먼저 가져올 객체가 있는지 확인하는 것이 좋습니다. hasNext() 메소드는 가져올 객체가 있으면 true를 리턴하고 없으면 false를 리턴합니다.

값 검색

HashSet<Integer> set = new HashSet<Integer>(Arrays.asList(1,2,3));//HashSet생성
System.out.println(set.contains(1)); //set내부에 값 1이 있는지 check : true

✔ TreeSet

JDK 1.2부터 제공되고 있는 TreeSet은 HashSet과 마찬가지로 Set 인터페이스를 구현한 클래스로써 객체를 중복해서 저장할 수 없고 저장 순서가 유지되지 않는다는 Set의 성질을 그대로 가지고 있습니다. 하지만 HashSet과는 달리 TreeSet은 이진 탐색 트리(BinarySearchTree) 구조로 이루어져 있습니다. 이진 탐색 트리는 추가와 삭제에는 시간이 조금 더 걸리지만 정렬, 검색에 높은 성능을 보이는 자료구조입니다. 

선언

reeSet<Integer> set1 = new TreeSet<Integer>();//TreeSet생성
TreeSet<Integer> set2 = new TreeSet<>();//new에서 타입 파라미터 생략가능
TreeSet<Integer> set3 = new TreeSet<Integer>(set1);//set1의 모든 값을 가진 TreeSet생성
TreeSet<Integer> set4 = new TreeSet<Integer>(Arrays.asList(1,2,3));//초기값 지정

추가

TreeSet<Integer> set = new TreeSet<Integer>();//TreeSet생성
set.add(7); //값추가
set.add(4);
set.add(9);
set.add(1);
set.add(5);

삭제

TreeSet<Integer> set = new TreeSet<Integer>();//TreeSet생성
set.remove(1);//값 1 제거
set.clear();//모든 값 제거

값 출력

TreeSet<Integer> set = new TreeSet<Integer>(Arrays.asList(4,2,3));//초기값 지정
System.out.println(set); //전체출력 [2,3,4]
System.out.println(set.first());//최소값 출력
System.out.println(set.last());//최대값 출력
System.out.println(set.higher(3));//입력값보다 큰 데이터중 최소값 출력 없으면 null
System.out.println(set.lower(3));//입력값보다 작은 데이터중 최대값 출력 없으면 null
		
Iterator iter = set.iterator();	// Iterator 사용
while(iter.hasNext()) {//값이 있으면 true 없으면 false
    System.out.println(iter.next());
}

✔ ArrayList

ArrayList는 List 인터페이스를 상속받은 클래스로 크기가 가변적으로 변하는 선형리스트입니다. 한번 생성되면 크기가 변하지 않는 배열과는 달리 ArrayList는 객체들이 추가되어 저장 용량(capacity)을 초과한다면 자동으로 부족한 크기만큼 저장 용량(capacity)이 늘어난다는 특징을 가지고 있습니다.

선언

ArrayList list = new ArrayList();//타입 미설정 Object로 선언된다.
ArrayList<Student> members = new ArrayList<Student>();//타입설정 Student객체만 사용가능
ArrayList<Integer> num = new ArrayList<Integer>();//타입설정 int타입만 사용가능
ArrayList<Integer> num2 = new ArrayList<>();//new에서 타입 파라미터 생략가능
ArrayList<Integer> num3 = new ArrayList<Integer>(10);//초기 용량(capacity)지정
ArrayList<Integer> list2 = new ArrayList<Integer>(Arrays.asList(1,2,3));//생성시 값추가

추가

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3); //값 추가
list.add(null); //null값도 add가능
list.add(1,10); //index 1에 10 삽입

ArrayList<Student> members = new ArrayList<Student>();
Student student = new Student(name,age);
members.add(student);
members.add(new Member("홍길동",15));

삭제

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));
list.remove(1);  //index 1 제거
list.clear();  //모든 값 제거

값 출력

ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3));

// 0번째 index 출력
System.out.println(list.get(0));
		
// for문을 통한 전체출력        
for(Integer i : list) { 
    System.out.println(i);
}

//Iterator 선언 
Iterator iter = list.iterator();  
while(iter.hasNext()){ //다음값이 있는지 체크
    System.out.println(iter.next()); //값 출력
}

값 검색

System.out.println(list.contains(1)); //list에 1이 있는지 검색 : true
System.out.println(list.indexOf(1)); //1이 있는 index반환 없으면 -1

🔎 Collection Framework 란?

자바는 배열의 문제점을 해결하기 위해, 널리 알려져 있는 자료구조를 바탕으로 객체나 데이터들을 효율적으로 관리할 수 있는 자료구조들을 만들어 놓았습니다. 이러한 자료구조들이 있는 라이브러리를 컬렉션 프레임워크라고 합니다. 대표적으로는 List, Set, Map, Stack, Queue 등이 있습니다.

✔ List Collection

List컬렉션은 객체 자체를 저장하는 것이 아니라 위와 같이 객체의 번지를 참조합니다. 동일한 객체를 중복 저장할 수 있는데 이 경우 동일한 번지가 참조됩니다. null도 저장이 가능한데 이 경우 해당 인덱스는 객체를 참조하지 않습니다. List 컬렉션을 구현하는 대표적인 클래스들은 ArrayList, LinkedList, Vector가 있으며 이 3가지 클래스는 List 인터페이스를 같이 상속하고 있으므로 공통적으로 사용할 수 있는 메서드들이 많습니다. 기본적인 List의 메서드는 아래와 같습니다.

✔ Set Collection

앞서 살펴본 List 컬렉션은 선형구조를 가지고 있으므로 추가한 순서대로 저장이 되어 순서를 유지하였지만 Set컬렉션의 경우에는 저장 순서가 유지되지 않습니다. 그렇기에 Set컬렉션은 순서 자체가 없으므로 인덱스로 객체를 검색해서 가져오는 get(index) 메서드도 존재하지 않습니다. 대신 전체 객체를 대상으로 한 번씩 반복해서 가져오는 반복자(Iterator)를 제공합니다. 반복자(Iterator)는 iterator() 메서드를 호출하면 얻을 수 있습니다.

또한 Set은 객체를 중복해서 저장할 수 없고 하나의 중복 저장이 안 되기에 null값도 하나만 저장할 수 있습니다. Set컬렉션은 수학의 집합에 비유될 수 있습니다. 집합은 순서와 상관없고 중복이 허용되지 않기 때문입니다. Set 컬렉션을 구현하는 대표적인 클래스들은 HashSet과 TreeSet이 있습니다. 기본적인 Set의 메서드는 아래와 같습니다.

✔ Map Collection

Map 컬렉션은 키(key)와 값(value)으로 구성된 객체를 저장하는 구조를 가지고 있는 자료구조입니다. 키는 중복으로 저장할 수 없고 값은 중복으로 저장할 수 있으며 중복된 key값이 들어온다면 기존의 값은 없어지고 새로운 값으로 대치됩니다.

Map은 Key와 Value라는 것을 한 쌍으로 갖는 자료형입니다. Map은 리스트나 배열처럼 순차적으로(sequential) 해당 요소 값을 구하지 않고 key를 통해 value를 얻습니다. 맵(Map)의 가장 큰 특징이라면 key로 value를 얻어낸다는 점입니다. 따라서 Map 컬렉션은 키(key)로 데이터를 관리합니다. Map 컬렉션을 구현하는 대표적인 클래스들은 HashMap, Hashtable, LinkedHashMap, TreeMap 등이 있습니다.  이 클래스들은 Map 인터페이스를 같이 상속하고 있으므로 공통적으로 사용할 수 있는 메서드들이 존재합니다. 기본적인 Map의 메서드는 아래와 같습니다.

// Customer 클래스

package Quiz;

class Customer {
	String name;
	String address;
	String phone;

	public Customer(String name, String address, String phone) {
		super();
		this.name = name;
		this.address = address;
		this.phone = phone;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	@Override
	public String toString() {
		return "[ 고객이름: " + name + " , 주소: " + address + " , 번호: " + phone + " ]";
	}

}

// Main 클래스

package Quiz;

import java.util.*;

public class MainEntry {

	public static void main(String[] args) {
		ArrayList<Customer> customers = new ArrayList<Customer>();
		// Customer customer = new Customer();
		Scanner sc = new Scanner(System.in);
		int n = 0;

		Boolean flag = true;
		while (flag) {
			System.out.println("------------------------------------------------------------------");
			System.out.println("1. 고객 추가   |   2. 고객 삭제   |   3. 고객리스트   |   4. 고객 정보 수정   |   5. 종료");
			System.out.println("------------------------------------------------------------------");
			System.out.print("실행할 번호를 입력하세요:");
			n = sc.nextInt();

			switch (n) {
			case 1: // 추가
				System.out.println();
				System.out.println("추가할 고객의 정보를 입력하세요.");
				System.out.println("---------------------");
				System.out.print("이름: ");
				String name = sc.next();
				System.out.print("주소: ");
				String address = sc.next();
				System.out.print("번호: ");
				String phone = sc.next();
				customers.add(new Customer(name, address, phone));
				System.out.println("추가 되었습니다!");
				break;

			case 2: // 삭제
				System.out.println();
				System.out.println("삭제할 고객의 이름을 입력하세요.");
				System.out.println("---------------------");
				System.out.print("이름: ");
				name = sc.next();
				for (int i = 0; i < customers.size(); i++) {
					if (name.equals(customers.get(i).getName())) {
						customers.remove(i);
						System.out.println("삭제되었습니다!");
					} else
						System.out.println("회원이 존재하지 않습니다.");
				}
				break;

			case 3: // 리스트 출력
				System.out.println();
				for (Customer customer : customers)
					System.out.println(customer);

			case 4: // 수정
				System.out.println();
				System.out.print("수정할 고객의 이름을 입력하세요.");
				name = sc.next();
				for (int i = 0; i < customers.size(); i++) {
					if (name.equals(customers.get(i).getName())) {

						System.out.print("수정하실 항목을 선택하세요. (1)이름     (2)주소     (3)번호");
						n = sc.nextInt();
						System.out.println();

						switch (n) {
						case 1:
							System.out.print("이름을 새로 입력하세요.");
							name = sc.next();
							customers.get(i).setName(name);
							break;
						case 2:
							System.out.print("주소를 새로 입력하세요.");
							address = sc.next();
							customers.get(i).setAddress(address);
							break;
						case 3:
							System.out.print("번호를 새로 입력하세요.");
							phone = sc.next();
							customers.get(i).setPhone(phone);
							break;
						}
						System.out.println("수정되었습니다!");

					} else
						System.out.println("잘못된 정보입니다.");
				}

				break;

			case 5:
				flag = false;
				System.out.println("시스템이 종료되었습니다.");
				break;

			default:
				System.out.println("1 ~ 5 까지의 숫자만 입력하세요.");
				break;

			}

		}

	}

}