[수강일지_20]

2026-06-08

---

• Java 3 

java 3생성 < 맨위의 창에서 표모양 클릭 < open perspectiva 에서 java 선택  자바 프로젝트 53 모듈해제 < Java SE - 17 설정 java 2 에서 address book 프로젝트 복사 < java 3으로 붙여넣기 < 프로젝트 생성란 마우스 우클릭  < import < existing < browser < 파일선택 <finish

 

Sample  53

StringMainClass

package Sample53;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class MainClass {
public static void main(String[] args) {
	/*
	 ArrayList: 검색, 대입(배열) 
	 배열 = 정해진 크기 안에서 사용할 때 
	 배열리스트 = 크기가 자유자재로 필요할 때 
	 
	 LInkedList : 실시간 추가/삭제에 적합 -> 게임 
	 
	 */
	
	List<String> list = new ArrayList<String>();   // List <자료형> 변수명 = new ArrayList<자료형> ();
	
	list.add("Giants");
	list.add(new String("tigers"));
	list.add("Twins");
	
	//linkeList 기본형식 
	//LinkedList<String> linkedList = new LinkedList<String>();
	
	//if 실시간이 필요해진다면? 
	LinkedList<String> linkedList = new LinkedList<String>(list);
	linkedList.add("Landers");
	for (String str : linkedList) {
		System.out.println(str);
	}

	//Linked list 에만 있는 기능 
	
	//0번찌에 추가하는 기능
	//addFirst -> 현재 있는 배열의 맨 앞에 삽입
	linkedList.addFirst("Eagles"); 
	
	//addLast -> 현재 있는 배열의 마지막에 사용
	linkedList.addLast("Bears");
	
	
	for(String str : linkedList) {
		System.out.println(str);
	}
	

	//일반 list에는 다음과 같에 add first, addlast기능을 사용할 수 없다 
	//List.addFirst("Eagles"); 
	//List.addLast("Bears");
	
	// list, linkedList 둘 다 존재하는 기능
	//isEnpty -> list 의 boolean 기능에 해당한다
	if(list.isEmpty()) {
		
	}
	
	/*
	 interator : 반복자 == 포인터 (주소) -> 76f231  이렇게 6자리가 있을 때  총 24 비트 
	                                                          2진수로 표현하면? f = 1111
	 ArrayLIst 에서 사용방법                                                         
	 list.get(index)          
	index        [0] -> [1] -> [2]					
	iterator    0x01 0x02  0x03            
	 
	                              
	 */
	
	//  for 문을 돌려서 이렇게 사용하는 방법이 있고 
	for (int i = 0; i < linkedList.size(); i++) {
		String str = linkedList.get(i);
		System.out.print(str);
		
	}
	
	// foreach 문으로 iterator 과 함께 사용하는 방법이 있다 
	Iterator<String> iter = linkedList.iterator(); //제일 첫번째 주소 
	while(iter.hasNext()) {   //hasNex -> 다음을 가지고 있니?? 라는 뜻 boolean의 뜻 
		String value = iter.next();   //next 는 Value 를 Return 해 준다 
	 System.out.println("value :" + value);
	}
	
	//linked list 와 array list 는 거의 차이가 없으나 기능의 존재 여부가 다르다 
}
}

Sample 53 - 출력결과

Giants tigers Twins Landers Eagles Giants tigers Twins Landers Bears EaglesGiantstigersTwinsLandersBearsvalue :Eagles value :Giants value :tigers value :Twins value :Landers value :Bears

---

Sample 54

MainClass

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class MainClass {

	public static void main(String[] args) {
		/*
		 Collection
		 
		 Map :interface
		 
		 HashMap : Class <-  index 를 사용하는 것이 아니다. 순서를 매기는 것이 아니기 때문에  숫자가 아닌 Key 로 접근해야 함 
		                     사전의 역할  = key 값을 넣어주면 value 값이 나온다. 
		                       예)                   key    :   value           -> Json 
		                                          "apple" : "사과"  
		                     Tree 구조로 구성되어 있다. 
		                     key 값은 중복을 허용하지 않는다. 
		 TreeMap  : Class
		 				     HashMap  + Sorting(Key)
		 				     HastMap 에 비해서 효율은 떨어진다 ( 무겁기 때문 ) 
		 
		 */
		
		//형식 1
	   //	HashMap<String, String> hMap = new HashMap<String, String>();
		
		//형식 2 : 실무 사용률 높음 
		Map<String, String> hMap =  new HashMap<String, String>();
		
			//추가 
		   hMap.put("apple", "사과"); // <- 한쌍으로 관리된다 
		   hMap.put("pear" , "배");
		   hMap.put("banana", "바나나");
		   
		   //map의 크기 
		   System.out.println(hMap.size());
		   
		   //key 로 value를 취득 
		   String _value = hMap.get("pear");
		   System.out.println(_value);
		   
		   Iterator<String> iter = hMap.keySet().iterator(); // 형식 Iterator<key 값의 자료형> 변수 =  ? . keyset().iterator();
		   
		   while (iter.hasNext()) {
			String key =  iter.next();
			String value = hMap.get(key);
			
			System.out.println("key: " +key + "value" + value);
			
		}
		   //삭제 
		   hMap.remove("pear");
		   _value= hMap.remove("pear");
		   System.out.println("삭제된 데이터는 " + _value + "입니다. ");
		   
		   //수정 -> 동일한  키에 값을 새로 추가하면 수정된다 
		   hMap.put("apple", "능금");
		   
		   hMap.put("grape", "포도");
		   hMap.put("pear", "배");
		   hMap.put("orange", "오렌지");
		   
		   iter = hMap.keySet().iterator(); 
		   
		   while (iter.hasNext()) {
			String key =  iter.next();
			String value = hMap.get(key);
			
			System.out.println("key:  " +key + " value: " + value);
			
		}
		   //수정 
		   _value = hMap.replace("apple", "사과");
		   System.out.println("변경된 값: " + _value);
		   
		   _value = hMap.get("apple");
		   System.out.println("변경된 값: " +(_value));
		   
		   //검색
		   
		  boolean b =  hMap.containsKey("apple");
		   System.out.println(b);
		
		   
		if(hMap.containsKey("banana")) {
			String value = hMap.get("banana");
			System.out.println(value);
		}
		
		//TreeMapl 을 이용해서 정렬
		//hashMap  -> treeMap
		TreeMap<String, String> tMap = new TreeMap<String, String>( hMap); //hmap 을 생성자 () 안에 넣기 
		
		//오름차순 정렬
		Iterator<String> it = tMap.keySet().iterator();
		
		while(it.hasNext()) {
			String key = it.next();
			String value = tMap.get(key);
			
		    System.out.println("ket : " +  key + " value : " + value);
			
		}
		
		//내림차순 정렬
		Iterator<String> it_1 = tMap.descendingKeySet().iterator();
		
		while(it_1.hasNext()) {
			String key = it_1.next();
			String value = tMap.get(key);
			
		    System.out.println("ket : " +  key + " value : " + value);
			
		}
		
		
		
		
		//가장 많이 쓰는 hash Map 예시 
		// 1. 리스트 생성 
		List<String> list = new ArrayList<String>();
		list.add("메모");
		list.add("내용입니다");
		
		//2. hasymap <key, value> 변수 그릇 이름 = new  hasymap <key, value>(); 세팅 
		//key 값에 들어갈 수 있는 것들 -> String, List<>, Integer, studentDto, AddressDto
		HashMap<String, Object> dataMap = new HashMap<String, Object>();

	
		//3.  2번에서 설정한 변수 그릇에 원하는 String ,  object 집어넣기 
		//현재 dataMap 에다가 object로 문자열도 집어넣고 숫자열도 집어넣고 list 도 집어넣은 상황 
		dataMap.put("학생", "홍길동");
		dataMap.put("번호", 1001);
		dataMap.put("내용", list);  
		
		//4. 출력 결과 확인 -> {내용=[메모, 내용입니다], 번호=1001, 학생=홍길동}
		System.out.println(dataMap);
		
		}
}

Sample 54 -출력결과

3 배 key: bananavalue바나나 key: applevalue사과 key: pearvalue배 삭제된 데이터는 null입니다. key: banana value: 바나나 key: orange value: 오렌지 key: apple value: 능금 key: pear value: 배 key: grape value: 포도 변경된 값: 능금 변경된 값: 사과 true 바나나 ket : apple value : 사과 ket : banana value : 바나나 ket : grape value : 포도 ket : orange value : 오렌지 ket : pear value : 배 ket : pear value : 배 ket : orange value : 오렌지 ket : grape value : 포도 ket : banana value : 바나나 ket : apple value : 사과 {내용=[메모, 내용입니다], 번호=1001, 학생=홍길동}

Sample 54 -활용해보기

	
		Map<Integer, String> map = new HashMap<Integer, String>();

		//CRUD
		// 추가 = 생성
		map.put(4567, "홍길동");
		map.put(4568, "일지매");
		map.put(4569, "성춘향");
		map.put(4570, "박흥부");

		System.out.println("수감된 죄수는" + map.size() + " 명 입니다.");

		//죄수번호 4567을 입력하면 죄수 이름 홍길동이 나오게끔 설정함
		String bad_people = map.get(4567);
		System.out.println(bad_people);

		//Map에 있는 Key 값을 죄수번호를 뽑아 Set(집합) 상자에 담아 보여주기
		// map과 key 는 연결되어 있다
		Iterator<Integer> num = map.keySet().iterator();

		/*
		keyset 이란?

		keySet()은 Map의 Key들을 꺼내서 for문을 돌리거나,
		특정 Key가 존재하는지 확인할 때(contains) 주로 사용합니다.
		원본 Map과 실시간으로 연동되어 있는 '거울' 같은 존재라고 기억하기.

		*/

		//num(Iterator)에 다음에 꺼낼 데이터(Key)가 남아있는 동안 계속 반복하기
		while (num.hasNext()) {
		// num에는 지금 map에서 꺼낸 key 값 죄수번호가 들어있다. num을 꺼내서 number 변수에 저장하면 number에는 죄수번호가 담기게 된다
		Integer number = num.next();
		//죄수번호를 호출하면 죄수 이름을 꺼내게 위에서 세팅했음 따라서 number를 get으로 호출해서 name 에 담으면 죄수 이름이 담긴다
		String name = map.get(number);

		/*
		hash next 와 next 차이

		hasNext(): "내 바로 다음에 데이터가 있어?" 하고 손을 뻗어 확인만 합니다. 있으면 true, 없으면 false.
		next(): 확인했으면 다음 칸으로 점프하면서 그 칸에 있던 실제 데이터(주소값)를 숑 뽑아서 전달해 줍니다.

		*/

		System.out.println(" 죄수번호 : " + number + " 죄수 이름 :" + name);

		}

		//검색 = 조회

		// 죄수 번호 그릇인 number_2 에 4567 을 포함하고 있으면 number_2 를 출력했을 때 참거짓 판별기인 boolean을 활용해 true, false 를 나오게 출력한다
		boolean number_2 = map.containsKey(4567); // 주의 key 값을 초기에 어떤 자료형으로 설정했느냐에 따라 () 안에 잘 입력해야 한다
		// 만약 숫자형 integer 로 잡았다면 따옴표 없이 숫자형 기입방식 따를 것

		System.out.println(number_2); // number_2 에 죄수번호 4567 포함하고 있는 상태

		if(map.containsKey(4567)) { //() 안에 key 값 담기
		String name = map.get(4567); // //() 안에 key 값 담기
		System.out.println(name);
		}
		
		
		//삭제
		 //Map.remove(4567); ->  주석 해제 하면 왜 null 이 나올까??
		bad_people = map.remove(4569);
		System.out.println(" [ " + bad_people + " ]석방, 죄수 목록에서 삭제를 진행한다");
		
		// 수정
				map.put(4570,"박놀부");   //바꾸려는 키값을 입력후 , 데이터 넣기 
				num=map.keySet().iterator();
				
				while(num.hasNext()) {
					Integer number = num.next();
					String name =  map.get(number);
					
					System.out.println("번호 : " + number + "  죄수이름 : " + name);
				}
				
		
		
		
		
		
		
		
		
	}	
	}​

Sample 54 -활용해보기 출력결과

수감된 죄수는4 명 입니다. 홍길동 죄수번호 : 4567 죄수 이름 :홍길동 죄수번호 : 4568 죄수 이름 :일지매 죄수번호 : 4569 죄수 이름 :성춘향 죄수번호 : 4570 죄수 이름 :박흥부 true 홍길동 [ 성춘향 ]석방, 죄수 목록에서 삭제를 진행한다 번호 : 4567 죄수이름 : 홍길동 번호 : 4568 죄수이름 : 일지매 번호 : 4570 죄수이름 : 박놀부

 

 

---

sample 55 -singleton

싱글 턴 전재조건 

A 클래스와  B 클래스가 서로 소통해야 된다 -> getter setter 

싱글턴에 공통으로 사용하는 변수를 몰아넣어야 한다 

 

왜 사용하나?

하나의 인스턴스를 만들어 두고 언제 어디서나  싱글턴을 통해  어느 클래스든 자유롭게 접근이 가능하게 만들기 위해 

MainClass

package main;

import cls.Animal;
import cls.Human;
import single.SingtonClass;

public class MainClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Human human = new Human("성춘향");
	    Animal animal = new Animal(1001);
	    
//	    String name = human.getName();
//	    animal.setName(name);
	    
  animal.info();	    
	    
	    //생성이 불가능 
	    //SingtonClass sc = new singtonClass();
	    /*
	    SingtonClass sc = SingtonClass.getInstance();
	    System.out.println(sc);
	    
	    sc = SingtonClas.getinstance();
	    System.out.println(null);
	    
	    */
	    
	    
	    
	}

}

class Human

package cls;

import single.SingtonClass;

public class Human {
	// 1.  private 으로 변수 생성
	private String name;

	//싱글턴에 값 넘기기 
	public Human(String name) {
		super();
		this.name = name;
		
		SingtonClass sc = SingtonClass.getInstance();
		sc.name = this.name; //싱글턴 클래스 안에 있는 네임 변수 안에 휴먼 클래스 네임 변수 값 넘겨줌
		
	}

//	public String getName() {
//		return name;
//	}

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


	
	
}

class Animal

package cls;

import single.SingtonClass;

public class Animal {
	// 2. private 으로 변수 생성
	private int number;
	private String name;

	public Animal(int number) {
		super();
		this.number = number;
	}

	public int getNumber() {
		return number;
	}

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

// 싱글턴으로 넘겨진 값 받기 
	public void info() {
		SingtonClass sc = SingtonClass.getInstance();
		this.name = sc.name;
		System.out.println("name:" +name);
	}


	
}

 

SingtonClass

package single;

public class SingtonClass {

	//1. 싱글턴 클래스의 첫번째 형태 
	private static SingtonClass sc = null;
	public String name;
	
	// 싱글턴 클래스는 private 으로 생성자 생성 가능 
	private SingtonClass() {
		
	}
	
	public static SingtonClass getInstance () { //
		if(sc == null) {
			sc = new SingtonClass(); // 여기서 딱 한 번만 객체가 생성된다 
		}
		return sc;  // 
	}
		
}

출력결과

name:성춘향

---

AddressBook_ 싱글턴 이용해서 생성하기 

class Main

package com.mbc.addr.main;

import java.util.Scanner;

import com.mbc.addr.dao.AddressBookDao;
import com.mbc.addr.dao.AddressBookDaoImpl;

public class Main {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		AddressBookDao dao = new AddressBookDaoImpl();

		while(true) {
			// menu
			System.out.println("<<< 주소록 >>>");
			System.out.println("1.데이터 추가");
			System.out.println("2.데이터 삭제");
			
			System.out.println("3.데이터 이름 검색");
			System.out.println("4.데이터 메모 검색");
			
			System.out.println("5.데이터 수정");
			System.out.println("6.모두 출력");
			System.out.println("7.데이터 저장");
			
			System.out.print("번호 입력 >> ");
			int work = sc.nextInt();
			
			switch(work) {
				// 1.추가
				case 1:
					dao.insert();
					break;
				// 2.삭제
				case 2:
					dao.delete();
					break;
				// 3.검색 - 이름
				case 3:
					dao.selectName();
					break;
				// 4.검색 - 주소 or 메모
				case 4:
					dao.selectMemo();
					break;
				// 5.수정
				case 5:
					dao.update();
					break;
				// 6.모두출력
				case 6:
					dao.allprint();
					break;
				// 7.데이터 저장
				case 7:
					dao.fileSave();
					break;
			}		
		}
	}
}

class AddressBookDto

package com.mbc.addr.dto;

public class AddressBookDto {

	// column(항목)	
	private String name;
	private int age;
	private String phone;
	private String address;
	private String memo;
	
	public AddressBookDto() {
	}

	public AddressBookDto(String name, int age, String phone, String address, String memo) {
		super();
		this.name = name;
		this.age = age;
		this.phone = phone;
		this.address = address;
		this.memo = memo;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getPhone() {
		return phone;
	}

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

	public String getAddress() {
		return address;
	}

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

	public String getMemo() {
		return memo;
	}

	public void setMemo(String memo) {
		this.memo = memo;
	}

	@Override
	public String toString() {
		return name + "-" + age + "-" + phone + "-" + address + "-" + memo;
	}
	
	public void info() {
		System.out.println(		"이름:" + name + " "
							+ 	"나이:" + age + " "
							+ 	"전화번호:" + phone + " "
							+ 	"주소:" + address + " "
							+ 	"메모:" + memo);
	}
	
}

interface AddressBookDao

package com.mbc.addr.dao;

public interface AddressBookDao {

	void insert();
	void delete();
	void update();
	
	void selectName();
	void selectMemo();
	
	int search(String name);	
	void allprint();
	
	void fileSave();
	//void fileLoad();
}

class AddressBookDaoImpl implements AddressBookDao

package com.mbc.addr.dao;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

import com.mbc.addr.dto.AddressBookDto;
import com.mbc.addr.file.FileProc;
import com.mbc.addr.singleton.Singleton;

public class AddressBookDaoImpl implements AddressBookDao{
	
	Scanner sc = new Scanner(System.in);
	
//	private List<AddressBookDto> list = new ArrayList<AddressBookDto>();
//	private List<AddressBookDto> list;
	
	private FileProc fproc;

	// CRUD
	public AddressBookDaoImpl() {
		
		fproc = new FileProc("addressBook");
		
		fproc.load();
	//	fileLoad();
		
//		list.add(new AddressBookDto("홍길동", 24, "123", "부평시", "대학친구"));
//		list.add(new AddressBookDto("성춘향", 15, "234", "부천시", "후배"));
//		list.add(new AddressBookDto("일지매", 22, "345", "서울시", "교회친구"));	
//		list.add(new AddressBookDto("홍길동", 26, "456", "부산시", "사촌형"));
	}
	
	@Override
	public void insert() {
		// TODO 추가
		System.out.println("데이터 추가입니다");
		
		AddressBookDto dto = new AddressBookDto();
		
		System.out.print("이름 = ");
		dto.setName(sc.next());
		
		System.out.print("나이 = ");
		dto.setAge(sc.nextInt());
		
		System.out.print("전화번호 = ");
		dto.setPhone(sc.next());
		
		System.out.print("주소 = ");
		dto.setAddress(sc.next());
		
		System.out.print("메모 = ");
		dto.setMemo(sc.next());
		
		Singleton single = Singleton.getInstance();		
		boolean isS = single.list.add(dto);
		if(!isS) {
			System.out.println("추가되지 않았습니다");
		}
		
		System.out.println("정상적으로 추가되었습니다");
	}

	@Override
	public void delete() {
		// TODO 삭제
		System.out.println("데이터 삭제입니다");
		
		System.out.print("이름 = ");		
		String name = sc.next();
		
		int index = search(name);		
		if(index == -1) {
			System.out.println("데이터를 찾을 수 없습니다");
			return;
		}
		
		Singleton single = Singleton.getInstance();	
		AddressBookDto deleteDto = single.list.remove(index);		
		deleteDto.info();
		System.out.println("데이터를 삭제하였습니다");
	}

	@Override
	public void update() {
		// TODO 수정
		System.out.println("데이터 수정입니다");
		
		System.out.print("이름 = ");		
		String name = sc.next();
		
		int index = search(name);		
		if(index == -1) {
			System.out.println("데이터를 찾을 수 없습니다");
			return;
		}
		
		System.out.print("수정할 주소 입력 = ");
		String address = sc.next();
		
		Singleton single = Singleton.getInstance();	
		AddressBookDto updateDto = single.list.get(index);
		updateDto.setAddress(address);
		
		System.out.println("수정되었습니다");
	}

	@Override
	public void selectName() {
		// TODO 이름 검색
		System.out.println("이름 검색입니다");
		
		System.out.print("이름 = ");		
		String name = sc.next();
		
		List<AddressBookDto> findList = new ArrayList<AddressBookDto>();
		
		Singleton single = Singleton.getInstance();	
		for (AddressBookDto addr : single.list) {
			if(name.equals(addr.getName())) {
				findList.add(addr);
			}
		}
		
		if(findList.size() == 0) {
			System.out.println("데이터를 찾을 수 없습니다");
			return;
		}
		
		for (AddressBookDto addr : findList) {
			addr.info();		
		}
	}

	@Override
	public void selectMemo() {
		// TODO 메모 검색
		System.out.println("메모 검색입니다");
		
		System.out.print("메모 = ");		
		String memo = sc.next();
		
		List<AddressBookDto> findList = new ArrayList<AddressBookDto>();
		
		Singleton single = Singleton.getInstance();	
		for (AddressBookDto addr : single.list) {
			if(addr.getMemo().contains(memo)) {
				findList.add(addr);
			}			
		}
		
		if(findList.size() == 0) {
			System.out.println("데이터를 찾을 수 없습니다");
			return;
		}
		
		for (AddressBookDto addr : findList) {
			addr.info();
		}		
	}

	@Override
	public int search(String name) {
		// TODO 써치
		int index = -1;
		
		Singleton single = Singleton.getInstance();	
		for (int i = 0; i < single.list.size(); i++) {
			AddressBookDto dto = single.list.get(i);			
			if(name.equals(dto.getName())) {
				index = i;
				break;
			}
		}		
		
		return index;
	}

	@Override
	public void allprint() {
		Singleton single = Singleton.getInstance();	
		for (AddressBookDto addr : single.list) {
			addr.info();
		}				
	}

	@Override
	public void fileSave() {		
		// 홍길동-24-1234-부평구-친구
		/*
		String arr[] = new String[list.size()];
		
		for (int i = 0; i < list.size(); i++) {
			AddressBookDto dto = list.get(i);
			arr[i] = dto.toString(); 
		}
		
		System.out.println(Arrays.toString(arr));		
		
		fproc.save(arr);*/	
		
		fproc.save();		
	}

	/*
	@Override
	public void fileLoad() {		
		//list = new ArrayList<AddressBookDto>();
		
		String arr[] = fproc.load();
		
		// arr[0] ->  홍길동-24-123-부평시-고교친구		
		//String str[] = arr[0].split("-");
					
		for (int i = 0; i < arr.length; i++) {
			
			String str[] = arr[i].split("-");			
			AddressBookDto dto = new AddressBookDto(str[0], // 이름
													Integer.parseInt(str[1]), // 나이 
													str[2], // 전화번호
													str[3], // 주소
													str[4]); // 메모
			list.add(dto);
		}		
	}	*/
}

class Singleton

package com.mbc.addr.singleton;

import java.util.ArrayList;
import java.util.List;

import com.mbc.addr.dto.AddressBookDto;

public class Singleton {
	
	private static Singleton sc = null;
	public List<AddressBookDto> list;
	
	private Singleton() {
		list = new ArrayList<AddressBookDto>();
	}
	
	public static Singleton getInstance() {
		if(sc == null) {
			sc = new Singleton();
		}
		return sc;
	}

}

class FileProc

package com.mbc.addr.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import com.mbc.addr.dto.AddressBookDto;
import com.mbc.addr.singleton.Singleton;

public class FileProc {

	private File file;
	
	public FileProc(String filename) {
		file = new File("C:/tmp/" + filename + ".txt");
		
		try {
			if(file.createNewFile()) {
				System.out.println("파일 생성 성공");
			}
		} catch (IOException e) {			
			e.printStackTrace();
		}
	}
	
	// 데이터 저장
	public void save() {	
		try {
			PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
		
			Singleton single = Singleton.getInstance();
			
//			for (String str : arr) {
	//			pw.println(str);
	//		}
			for(AddressBookDto dto : single.list) {
				pw.println(dto.toString());				
			}			

			pw.close();
		
		} catch (IOException e) {			
			e.printStackTrace();
		}		
	}
	
	// 데이터 불러오기
	public void load() {
		
		//List<String> strlist = new ArrayList<String>();				
		
		try {
			BufferedReader br = new BufferedReader(new FileReader(file));
							
			Singleton single = Singleton.getInstance();
			
			String str = "";	
			while((str = br.readLine()) != null) {
				
				String arr[] = str.split("-");
				
				AddressBookDto dto = new AddressBookDto(arr[0], 
														Integer.parseInt(arr[1]), 
														arr[2], 
														arr[3], 
														arr[4]);
				single.list.add(dto);				
			}			
			br.close();			
			
		} catch (FileNotFoundException e) {			
			e.printStackTrace();
		} catch (IOException e) {			
			e.printStackTrace();
		}
		
//		String array[] = new String[strlist.size()];
//		for (int i = 0; i < strlist.size(); i++) {
//			array[i] = strlist.get(i);
//		}
//		
//		return array;
	}
}

---