[Java] Collection Exercise

🧩 컬렉션을 이용하여 Joy Restaurant의 메뉴관리 프로그램 만들기

💁‍ WELCOME !
Joy Restaurant의 chef들을 위한 메뉴관리 프로그램을 만들어주세요!
메뉴가 자주 바뀌고 추가되는 Joy Restaurant의 특성상, Dish의 추가, 전체 조회, 정렬 조회, 검색, 수정, 삭제의 기능이 있어야합니다.
또한 Course로도 정렬 및 검색이 되었으면 좋겠네요.

◼ DishDTO Class

public class DishDTO {

	// 필드
	private String course;
	private String dishName;
	
	// 생성자
	public DishDTO() {}
	
	public DishDTO(String course, String dishName) {
		this.course = course;
		this.dishName = dishName;
	}

	// getter & setter
	public String getCourse() {
		return course;
	}

	public void setCourse(String course) {
		this.course = course;
	}
	
	public String getDishName() {
		return dishName;
	}

	public void setDishName(String dishName) {
		this.dishName = dishName;
	}

	// 메소드
	>>> toString() : 등록된 각 리스트의 16진수 해쉬코드가 문자열로 반환되게끔 하는 메소드 (없으면 주소값이 반환됨)
	@Override
	public String toString() {
		return "DishDTO [Course : " + course + " | DishName : " + dishName + "]";
	}
}

◼ DishController Class

public class DishController { // 정보의 추가, 저장, 수정, 삭제를 담당 (ArrayList)

	// Dish 목록을 저장해두기 위한 리스트 (DishDTO만 저장)
	private List<DishDTO> dishList = new ArrayList<>();
	
	// '[1] Dish 추가'를 위한 메소드
	public void addList(DishDTO dish) {
		dishList.add(dish);
	}
	
	// '[2] Dish 전체 조회'를 위한 메소드
	public List<DishDTO> selecetList() { // Q1. List<DishDTO>가 왜 여기에 반환형으로 있을까요? RestaurantMenu 클래스에서 SelectList()를 호출하여 Dish 목록을 리턴해줄 때 List<DishDTO>에서참조해와야하기때문 (반환형)
		return dishList; 
		// 위에서 저장해둔 Dish 목록을 리턴해줌
	}
	
	// '[4] Dish명으로 검색'을 위한 메소드
	public List<DishDTO> searchDish(String dishName) {
		// Dish명을 검색해서 해당 키워드가 포함되는 Dish들을 리턴 받기 위한 리스트 생성
		List<DishDTO> searchList = new ArrayList<>();
		
		for(DishDTO dishV : dishList) { // 저장된 Dish 목록에 접근
			
			if(dishV.getDishName().contains(dishName)); {
			// 매개변수로 들어온 dishName이 DishDTO의 DishName에 포함되어 있는지의 여부
				searchList.add(dishV);
				// 해당 키워드가 포함되어있는 요리들만, searchList에 추가 
			}
		}	
		return searchList;
		// 추가 완료된 searchList 리턴
	}
	
	// '[5] Course명으로 검색'을 위한 메소드
	public List<DishDTO> searchCourse(String course) {
		// Course명을 검색해서 해당 키워드가 포함되는 Course들을 리턴 받기 위한 리스트 생성
		List<DishDTO> searchList = new ArrayList<>();
		
		for(DishDTO courseV : dishList) { // 저장된 Dish 목록에 접근
			
			if(courseV.getCourse().contains(course)) {
				// 매개변수로 들어온 course가 DishDTO의 Course에 포함되어 있는지의 여부
				searchList.add(courseV);
				// 해당 키워드가 포함되어있는 코스들만, searchList에 추가 
			}
		}
		return searchList;
		// 추가 완료된 searchList 리턴
	}
	
	// '[6] Dish 정보 수정'을 위한 메소드
	public int editDish(String oldDishname, DishDTO editDish) { // : (수정할 Dish명, 새로운 Course명 및 Dish명)
		
		DishDTO old = null;
		
		for(int i = 0; i < dishList.size(); i++) { // : Dish 목록이 저장되어 있는 dishList에 하나씩 접근
			
			if(dishList.get(i).getDishName().equals(oldDishname)) { // : 접근한 목록 중 수정할 Dish명과 완벽히 일치하는 것이 있다면,
				
				old = dishList.set(i, editDish); // : 해당하는 위치(i)에 있는 Dish명을 old에 반환한 뒤 RestaurantMenu 클래스의 editDish 메소드에서 온 editDish로 수정
			}
		}
		// set() 메소드는 수정 전, old의 값을 반환하고 수정됨. 따라서 반환이 된 경우는 수정이 되었다는 의미.
		// old의 값이 반환된 경우 1 리턴, 반환되지 않은 경우 0 리턴
		return old != null ? 1 : 0;
		// : old 이제 null 아니지? 응 = 1, 아니 = 0
	}	
	
	// '[7] Dish 삭제'를 위한 메소드
	public int removeDish(String dishname) { // : (삭제할 Dish명)
		
		DishDTO old = null;
		
		for(int i = 0; i < dishList.size(); i++) { // : Dish 목록이 저장되어 있는 dishList에 하나씩 접근
			
			if(dishList.get(i).getDishName().equals(dishname)) { // : 접근한 목록 중 삭제할 Dish명과 완벽히 일치하는 것이 있다면,
				
				old = dishList.remove(i); // : 해당하는 위치(i)에 있는 Dish명을 old에 반환한 뒤 삭제
			}
		}
		// remove() 메소드는 삭제 전, old의 값을 반환하고 수정됨. 따라서 반환이 된 경우는 삭제가 되었다는 의미.
		// old의 값이 반환된 경우 1 리턴, 반환되지 않은 경우 0 리턴
		return old != null ? 1 : 0;
		// : old 이제 null 아니지? 응 = 1, 아니 = 0
	}
}

◼ 3 Classes implements Comparator<DishDTO>

public class AscCourse implements Comparator<DishDTO> {
	
	// 정렬 중, '[2] Course별 오름차순 정렬'을 위한 메소드 (기준)
	@Override
	public int compare(DishDTO o1, DishDTO o2) {
		return o1.getCourse().compareTo(o2.getCourse());
	}
}

public class DescDishName implements Comparator<DishDTO> {

	// 정렬 중, '[3] Dish명 내림차순 정렬'을 위한 메소드 (기준)
	@Override
	public int compare(DishDTO o1, DishDTO o2) {
		return o2.getDishName().compareTo(o1.getDishName());
	}
}

public class DescCourse implements Comparator<DishDTO>{
	
	// 정렬 중, '[4] Course별 내림차순 정렬'을 위한 메소드 (기준)
	@Override
	public int compare(DishDTO o1, DishDTO o2) {
		return o2.getCourse().compareTo(o1.getCourse());
	}
}

◼ Application Class

public class RestaurantMenu { // 사용자에게 보여주는 것들을 출력해주는 것 담당

	// DishController 객체 생성
	private DishController dishController = new DishController();
	
	Scanner sc = new Scanner(System.in);
	
	public void mainView() {
		
		XXX :
		while(true) {			
			System.out.println("");
			System.out.println("======= Menu =======");
			System.out.println("[1] Dish 추가");
			System.out.println("[2] Dish 전체 조회");
			System.out.println("[3] 정렬하여 조회");
			System.out.println("[4] Dish명으로 검색");
			System.out.println("[5] Course명으로 검색");
			System.out.println("[6] Dish 정보 수정");
			System.out.println("[7] Dish 삭제");
			System.out.println("[0] 프로그램 종료");
			
			System.out.print("Menu 선택 : ");
			int menu = sc.nextInt();
			
			switch(menu) {
			case 1: addList();
				break;
			case 2: selectList();
				break;
			case 3: sortList();
				break;
			case 4 : searchDish();
				break;
			case 5 : searchCourse();
				break;
			case 6 : editDish();
				break;
			case 7 : removeDish();
				break;
			case 0 : System.out.println("프로그램을 종료합니다 :) ");
				break XXX; // while문 종료
			default : System.out.println("올바르지 않은 번호입니다. 다시 입력해주세요 :( ");
				break;
			}
		}
	}
	
	// '[1] Dish 추가'를 위한 메소드
	public void addList() {
		System.out.println("================= Dish 추가 =================");
		System.out.println(" Appetizer | Soup | Entree | Main | Dessert");
		System.out.println("============================================");		
		sc.nextLine();
		
		System.out.print("Course 입력 : ");
		String course = sc.nextLine();
		System.out.print("Dish 입력 : ");
		String dish = sc.nextLine();
		
		dishController.addList(new DishDTO(course, dish));
	}
	
	// '[2] Dish 전체 조회'를 위한 메소드
	public void selectList() {		
		System.out.println("=============== Dish 전체 조회 ===============");
		// 위에서 생성한 dishcontroller 참조 변수로 DishController의 selectList() 호출
		List<DishDTO> dishList = dishController.selectList(); // selectList()로 부터 dishList 리턴받음 
		
		if (!dishList.isEmpty()) { // : dishList가 비어있지 않을 경우,
			for (DishDTO dish : dishList) {
				System.out.println(dish); // dishList 목록 출력
			}
		} else {
			System.out.println("등록된 Dish가 없습니다 :("); // dishList가 비어있을 경우의 출력문
		}
	}
	
	// '[3] 정렬하여 조회'를 위한 메소드
	public void sortList() {
		System.out.println("================ 정렬 방식 선택 ================");
		System.out.println("[1] Dish명 오름차순 정렬");
		System.out.println("[2] Course별 오름차순 정렬");
		System.out.println("[3] Dish명 내림차순 정렬");
		System.out.println("[4] Course별 내림차순 정렬");
		
		System.out.print("Menu 선택 : ");
		int menu = sc.nextInt();
		
		ascDesc(menu);
	}
	
	// 정렬 중, '[1] Dish명 오름차순 정렬'및 3가지 정렬기준 메소드를 호출하기 위한 메소드
	public void ascDesc(int menu) {
		System.out.println("============== 선택된 정렬로 조회 ==============");
		// 위에서 생성한 dishcontroller 참조 변수로 DishController의 selectList() 호출
		List<DishDTO> dishList = dishController.selcetList(); // selcetList()로 부터 dishList 리턴받음
		
		// 정렬 시 원본 데이터를 변경하므로 사본 데이터를 별도로 생성
		List<DishDTO> sortList = new ArrayList<>();
		sortList.addAll(dishList); // sortList는 dishList의 사본
		// addAll : Collection 타입 인스턴스를 리스트에 추가
		
		if(menu == 1) {
			
			// 익명 클래스 사용
			sortList.sort(new Comparator<DishDTO>() {
				
				@Override
				public int compare(DishDTO o1, DishDTO o2) {
					return o1.getDishName().compareTo(o2.getDishName());
				}
			});
			
		// Comparator를 상속한 클래스(정렬기준)를 사용
		} else if (menu == 2) {
			sortList.sort(new AscCourse()); //'[2] Course별 오름차순 정렬'의 기준 메소드
		
		} else if (menu == 3) {
			sortList.sort(new DescDishName()); //'[3] Dish명 내림차순 정렬'의 기준 메소드
		
		} else {
			sortList.sort(new DescCourse()); //'[4] Course별 내림차순 정렬'의 기준 메소드
		}
		
		for(int i = 0; i < sortList.size(); i++) {
			System.out.println(sortList.get(i)); // : sortList 인덱스의 요소를 가져옴
		}
	}

	// '[4] Dish명으로 검색'을 위한 메소드
	public void searchDish() {
		System.out.println("============== Dish명으로 검색 ==============");
		sc.nextLine();
		System.out.print("Dish명 입력 : ");
		List<DishDTO> searchList = dishController.searchDish(sc.nextLine()); // 입력받은 값을 바로 매개변수로 보냄
	
		if(!searchList.isEmpty()) { // : searchList가 비어있지 않을 경우,
			for(int i = 0; i < searchList.size(); i++) {
				System.out.println(searchList.get(i)); // : searchList 인덱스의 요소를 가져옴
			}
		} else {
			System.out.println("검색 결과가 없습니다 :(");
		}
	}
	
	// '[5] Course명으로 검색'을 위한 메소드
	public void searchCourse() {
		System.out.println("============== Course별로 검색 ==============");
		System.out.println(" Appetizer | Soup | Entree | Main | Dessert");
		System.out.println("============================================");	
		sc.nextLine();
		System.out.print("Course 입력 : ");
		List<DishDTO> searchList = dishController.searchCourse(sc.nextLine()); // 입력받은 값을 바로 매개변수로 보냄
	
		if(!searchList.isEmpty()) {
			for(int i = 0; i < searchList.size(); i++) {
				System.out.println(searchList.get(i)); // : searchList 인덱스의 요소를 가져옴
			}
		} else {
			System.out.println("검색 결과가 없습니다 :(");
		}
	}
	
	// '[6] Dish 정보 수정'을 위한 메소드
	public void editDish() {
		System.out.println("============== Dish 정보 수정 ==============");
		sc.nextLine();
		System.out.print("수정할 Dish명 : ");
		String oldDishName = sc.nextLine();
		System.out.println("============================================");
		System.out.println(" Appetizer | Soup | Entree | Main | Dessert");
		System.out.println("============================================");
		System.out.print("새로운 Dish의 Course : ");
		String newCourseName = sc.nextLine();
		System.out.print("새로운 Dish명 : ");
		String newDishName = sc.nextLine();
		
		DishDTO editDish = new DishDTO(newCourseName, newDishName); // editDish : 새로운 Dish명 및 Dish명 
		int result = dishController.editDish(oldDishName, editDish); // DishController 클래스의 editDish 메소드에 (수정할 Dish명, 새로운 Course명 및 Dish명) 매개변수로 전달
		
		// DishController 클래스의 editDish 메소드 실행된 후, 리턴받은 result의 값은 0또는 1 
		if(result > 0) {
			System.out.println("수정이 완료되었습니다 :)");
		} else {
			System.out.println("수정할 Dish를 찾지 못했습니다 :(");
		}
	}
	
	// '[7] Dish 삭제'를 위한 메소드
	public void removeDish() {
		System.out.println("================ Dish 삭제 ================");
		sc.nextLine();
		System.out.print("삭제할 Dish명 : ");
		int result = dishController.removeDish(sc.nextLine()); // DishController 클래스의 editDish 메소드에 (삭제할 Dish명) 매개변수로 전달
		
		// DishController 클래스의 removeDish 메소드 실행된 후, 리턴받은 result의 값은 0또는 1 
		if (result > 0) {
			System.out.println("삭제가 완료되었습니다 :)");
		} else {
			System.out.println("삭제할 Dish를 찾지 못했습니다 :(");
		}
	}
}

◼ Application Class

public class Application {

	public static void main(String[] args) {
		
		RestaurantMenu rm = new RestaurantMenu();
		
		rm.mainView();
	}
}