수업내용/Java
[2022.10.06.목] List 실습, Map<K, V> 인터페이스
주니어주니
2022. 10. 6. 20:57
1. List<E> 실습
- Product 객체
public class Product {
private int no;
private String name;
private int price;
private int discountPrice;
private int stock;
public Product() {}
public Product(int no, String name, int price, int discountPrice, int stock) {
super();
this.no = no;
this.name = name;
this.price = price;
this.discountPrice = discountPrice;
this.stock = stock;
}
public int getNo() {
return no;
}
public String getName() {
return name;
}
public int getPrice() {
return price;
}
public int getDiscountPrice() {
return discountPrice;
}
public int getStock() {
return stock;
}
public void setNo(int no) {
this.no = no;
}
public void setName(String name) {
this.name = name;
}
public void setPrice(int price) {
this.price = price;
}
public void setDiscountPrice(int discountPrice) {
this.discountPrice = discountPrice;
}
public void setStock(int stock) {
this.stock = stock;
}
}
-Order 객체
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class Order {
private static final double DEPOSIT_POINT_RATE= 0.02; // 포인트적립률은 항상 똑같음
private int no; // 주문번호
private Date date; // 주문날짜
private String customerId; // 주문고객 아이디
private String customerName; // 주문고객 이름
private List<Item> items = new ArrayList<>(); // 주문아이템 목록
public Order() {}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public String getCustomerId() {
return customerId;
}
public void setCustomerId(String customerId) {
this.customerId = customerId;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public List<Item> getItems() {
return items;
}
public void addItem(Item item) { // setitem을 이렇게 변경
items.add(item);
}
// 얘네를 이 객체에서 구현해야 덜 복잡함
public int getTotalQuantity() { // 얘네를 만들고 변수, setter를 지움
int totalQuantity = 0;
for(Item item : items) {
totalQuantity += item.getQuantity();
}
return totalQuantity;
}
public int getTotalOrderPrice() {
int totalOrderPrice = 0;
for(Item item : items) {
int price = item.getPrice();
int quantity = item.getQuantity();
int orderPrice = price*quantity;
totalOrderPrice += orderPrice;
}
return totalOrderPrice;
}
public int getDepositPoint() {
int depositOrderPrice=0; // 총 구매금액에 대한 포인트
int totalOrderPrice = getTotalOrderPrice();
depositOrderPrice = (int)(totalOrderPrice*DEPOSIT_POINT_RATE);
return depositOrderPrice;
}
}
- Item 객체
public class Item {
private int no; // 구입한 상품번호
private String name; // 구입한 상품이름
private int price; // 구입한 상품가격 (할인가격 기준)
private int quantity; // 구입한 상품수량
public Item() {}
public int getNo() {
return no;
}
public String getName() {
return name;
}
public int getPrice() {
return price;
}
public int getQuantity() {
return quantity;
}
public void setNo(int no) {
this.no = no;
}
public void setName(String name) {
this.name = name;
}
public void setPrice(int price) {
this.price = price;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
}
-Customer 객체
public class Customer {
private String id;
private String name;
private String email;
private int point;
public Customer() {}
public Customer(String id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public String getEmail() {
return email;
}
public int getPoint() {
return point;
}
public void setId(String id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setEmail(String email) {
this.email = email;
}
public void setPoint(int point) {
this.point = point;
}
}
-Store 실행객체
import day23.collection.app1.controller.StoreController;
import day23.collection.app1.service.StoreService;
import utils.KeyboardReader;
public class Store {
public static void main(String[] args) {
// 1. 상점 애플리케이션을 구성하는 객체 생성하기
// KeyboardReader, StoreService, StoreController 생성
KeyboardReader keyboard = new KeyboardReader();
StoreService service = new StoreService();
// 2. 객체 조립하기
// StoreController 객체의 메머변수(private KeyboardReader keyboard, private StoreService service)에
// KeyboardReader 객체와 StoreService 객체의 주소값을 생성자 메소드로 전달
StoreController controller = new StoreController(keyboard, service);
// 3. 프로그램 실행
controller.실행();
}
}
-StoreController 객체
import java.util.ArrayList;
import java.util.List;
import day23.collection.app1.service.StoreService;
import day23.collection.app1.vo.Customer;
import day23.collection.app1.vo.Item;
import day23.collection.app1.vo.Order;
import day23.collection.app1.vo.Product;
import utils.KeyboardReader;
import utils.StringUtils;
public class StoreController {
/**
* 키보드 입력을 읽어오는 객체
*/
private KeyboardReader keyboard; // 잭만 만들어놓기, 생성자메소드를 통해 객체를 만들면서 입력받을거야
/**
* 상점관련 업무로직이 구현된 객체
*/
private StoreService service;
/**
* StoreController 객체의 생성자 메소드
* <p>StoreController의 실행에 필요한 KeyboardReader객체와 StoreService객체를 전달받아서 멤버변수에 대입
* @param keyboard 키보드 입력을 읽어오는 객체
* @param service 상점관련 업무로직이 구현된 객체
*/
public StoreController(KeyboardReader keyboard, StoreService service) {
this.keyboard = keyboard;
this.service = service;
}
public void 실행() {
메뉴();
}
private void 메뉴() {
while (true) {
System.out.println("--------------------------------------------------------------------------");
System.out.println("1.고객 2.상품 3.주문 0.종료");
System.out.println("--------------------------------------------------------------------------");
System.out.println();
System.out.print("# 메뉴선택: ");
int mainMenuNo = keyboard.getInt();
if (mainMenuNo == 1) {
System.out.println();
System.out.println("--------------------------------------------------------------------------");
System.out.println("1.고객조회 2.고객등록");
System.out.println("--------------------------------------------------------------------------");
System.out.println();
System.out.print("# 고객메뉴 선택: ");
int menuNo = keyboard.getInt();
System.out.println();
if (menuNo == 1) {
고객정보출력();
} else if (menuNo == 2) {
신규고객등록();
}
System.out.println();
} else if (mainMenuNo == 2) {
System.out.println();
System.out.println("--------------------------------------------------------------------------");
System.out.println("1.상품목록 2.상품상세 3.상품입고");
System.out.println("--------------------------------------------------------------------------");
System.out.println();
System.out.print("# 상품메뉴 선택: ");
int menuNo = keyboard.getInt();
System.out.println();
if (menuNo == 1) {
전체상품리스트출력();
} else if (menuNo == 2) {
상품상세정보출력();
} else if (menuNo == 3) {
상품입고();
}
System.out.println();
} else if (mainMenuNo == 3) {
System.out.println();
System.out.println("--------------------------------------------------------------------------");
System.out.println("1.주문 2.전체주문내역 3.고객별주문내역 4.주문상세");
System.out.println("--------------------------------------------------------------------------");
System.out.println();
System.out.print("# 주문메뉴 선택: ");
int menuNo = keyboard.getInt();
System.out.println();
if (menuNo == 1) {
주문하기();
} else if (menuNo == 2) {
전체주문내역출력();
} else if (menuNo == 3) {
고객별주문내역출력();
} else if (menuNo == 4) {
주문상세정보출력();
}
System.out.println();
} else if (mainMenuNo == 0) {
System.out.println("### 프로그램 종료");
System.exit(0);
}
System.out.println();
}
}
private void 전체상품리스트출력() {
System.out.println("<< 전체 상품 목록 출력 >>");
List<Product> products = service.getAllProducts();
System.out.println("상품번호\t상품명\t가격");
for(Product product : products) {
System.out.print(product.getNo() + "\t"); // 배열에서는 5개중 4개만 담으면 null이 있어서 유효성검사를 꼭 해야했는데, 얘는 안해도돼
System.out.print(product.getName() + "\t");
System.out.println(product.getDiscountPrice() + "\t");
}
}
private void 상품입고() {
System.out.println("<< 상품 입고 >>");
System.out.print("## 상품번호 입력: ");
int productNo = keyboard.getInt();
System.out.print("## 입고수량 입력: ");
int amount = keyboard.getInt();
boolean isSuccess = service.updateProductStock(productNo, amount);
if(isSuccess) {
System.out.println("[성공] 재고수량이 변경되었습니다.");
} else {
System.out.println("[오류] 상품정보가 존재하지 않습니다.");
}
}
private void 상품상세정보출력() {
System.out.println("<< 상품 상세정보 출력 >>");
System.out.print("## 상품번호 입력: ");
int productNo = keyboard.getInt();
Product product = service.getProductDetail(productNo);
if(product == null) {
System.out.println("[오류] 상품정보가 존재하지 않습니다.");
return;
}
System.out.println("=== 상품 상세 정보 ===");
System.out.println("상품번호: " + product.getNo());
System.out.println("상품이름: " + product.getName());
System.out.println("상품가격: " + product.getPrice());
System.out.println("할인가격: " + product.getDiscountPrice());
System.out.println("재고수량: " + product.getStock());
}
private void 신규고객등록() {
System.out.println("<< 신규 고객 등록 >>");
System.out.print("## 고객 아이디 입력: ");
String customerId = keyboard.getString();
System.out.print("## 고객 이름 입력: ");
String customerName = keyboard.getString();
System.out.print("## 고객 이메일 입력: ");
String customerEmail = keyboard.getString();
Customer customer = new Customer(); // 값이 여러개일때는 객체로 만들어서 줘야돼
customer.setId(customerId);
customer.setName(customerName);
customer.setEmail(customerEmail);
boolean isSuccess = service.addCustomer(customer);
if(isSuccess) {
System.out.println("[성공] 고객정보가 등록되었습니다.");
} else {
System.out.println("[오류] 이미 사용중인 아이디입니다.");
}
}
private void 고객정보출력() {
System.out.println("<< 고객 상세정보 출력 >>");
System.out.print("## 고객 아이디 입력: ");
String customerId = keyboard.getString();
Customer customer = service.getCustomerById(customerId);
if(customer == null) {
System.out.println("[오류] 사용자정보가 존재하지 않습니다.");
return;
}
System.out.println("=== 사용자 상세정보 ===");
System.out.println("아이디: " + customer.getId());
System.out.println("이름: " + customer.getName());
System.out.println("이메일: " + customer.getEmail());
System.out.println("포인트: " + customer.getPoint());
}
private void 주문하기() {
System.out.println("<< 주문하기 >>");
System.out.print("## 고객 아이디 입력: ");
String customerId = keyboard.getString();
List<Integer> productNoList = new ArrayList<>();
List<Integer> quantityList = new ArrayList<>();
while(true) { // 상품번호, 구매수량은 여러번 입력 -> while, arraylist
System.out.print("## 상품번호 입력: ");
int productNo = keyboard.getInt();
System.out.print("## 구매수량 입력: ");
int quantity = keyboard.getInt();
productNoList.add(productNo);
quantityList.add(quantity);
System.out.print("## 계속 구매하시겠습니까? (y/n) ");
String confirm = keyboard.getString();
if("n".equals(confirm)) {
break;
}
System.out.println();
}
boolean isSuccess = service.order(customerId, productNoList, quantityList);
if(isSuccess) {
System.out.println("[성공] 모든 주문이 완료되었습니다.");
} else {
System.out.println("[오류] 일부 혹은 모든 주문이 완료되지 않았습니다.");
}
}
private void 전체주문내역출력() {
System.out.println("<< 전체 주문 내역 출력 >>");
List<Order> orderList = service.getAllOrders();
if(orderList.isEmpty()) {
System.out.println("[안내] 주문내역이 존재하지 않습니다."); // 오류는 x. 그냥 주문을 아직 한번도 안한것
} else {
System.out.println("주문번호\t고객명\t총 구매금액");
for(Order order : orderList) {
System.out.print(order.getNo()+"\t");
System.out.print(order.getCustomerName()+"\t");
System.out.println(StringUtils.numberToString(order.getTotalOrderPrice()));
}
}
}
private void 고객별주문내역출력() {
System.out.println("<< 고객별 주문 내역 >>");
System.out.print("## 고객 아이디 입력: ");
String customerId = keyboard.getString();
List<Order> orderList = service.getOrderByCustomerId(customerId);
if(orderList.isEmpty()) {
System.out.println("[안내] 주문내역이 존재하지 않습니다.");
} else {
System.out.println("주문번호\t주문날짜\t\t총구매금액");
for(Order order : orderList) {
System.out.print(order.getNo()+"\t");
System.out.print(StringUtils.dateToString(order.getDate())+"\t");
System.out.println(StringUtils.numberToString(order.getTotalOrderPrice()));
}
}
}
private void 주문상세정보출력() {
System.out.println("<< 주문 상세 정보 >>");
System.out.print("## 주문 번호 입력: ");
int orderNo = keyboard.getInt();
Order order = service.getOrderDetail(orderNo);
if(order == null) {
System.out.println("[안내] 주문정보가 존재하지 않습니다.");
} else {
System.out.println("=== 주문 고객 정보 ===");
System.out.println("주문번호: " + order.getNo());
System.out.println("주문날짜: " + StringUtils.dateToString(order.getDate()));
System.out.println("주문자 아이디: " + order.getCustomerId());
System.out.println("주문자 이름: " + order.getCustomerName());
System.out.println();
List<Item> items = order.getItems();
System.out.println("=== 주문 상품 정보 ===");
System.out.println("상품번호\t상품이름\t상품가격\t구매수량\t구매가격");
for(Item item : items) {
System.out.print(item.getNo()+"\t");
System.out.print(item.getName()+"\t");
System.out.print(StringUtils.numberToString(item.getPrice())+"원\t");
System.out.print(item.getQuantity()+"\t");
System.out.println(StringUtils.numberToString(item.getPrice()*item.getQuantity())+"원");
}
}
}
}
-StoreService 객체
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import day23.collection.app1.vo.Customer;
import day23.collection.app1.vo.Item;
import day23.collection.app1.vo.Order;
import day23.collection.app1.vo.Product;
public class StoreService {
private static AtomicInteger atom = new AtomicInteger(1001); // atom.getAndIncrement() -> 1001에서 1 증가됨
/**
* 상품정보 객체를 저장하는 ArrayList 객체
*/
private List<Product> productList = new ArrayList<>();
/**
* 고객정보 객체를 저장하는 ArrayList 객체
*/
private List<Customer> customerList = new ArrayList<>();
/**
* 주문정보 객체를 저장하는 ArrayList 객체
*/
private List<Order> orderList = new ArrayList<>();
public StoreService() { // 기본 생성자로 먼저 상품을 리스트에 등록
customerList.add(new Customer("kim", "김유신", "kim@naver.com"));
customerList.add(new Customer("kang", "강감찬", "kang@naver.com"));
customerList.add(new Customer("ahn", "안중근", "ahn@naver.com"));
customerList.add(new Customer("ryou", "류관순", "ryou@naver.com"));
productList.add(new Product(atom.getAndIncrement(), "삼각김밥", 3000, 2700, 100));
productList.add(new Product(atom.getAndIncrement(), "하얀우유", 1200, 1100, 10));
productList.add(new Product(atom.getAndIncrement(), "도시락", 5000, 4700, 20));
productList.add(new Product(atom.getAndIncrement(), "샐러드", 4000, 3700, 20));
productList.add(new Product(atom.getAndIncrement(), "딸기우유", 1200, 1000, 10));
productList.add(new Product(atom.getAndIncrement(), "하리보", 1500, 1350, 5));
productList.add(new Product(atom.getAndIncrement(), "오레오", 1200, 1050, 5));
productList.add(new Product(atom.getAndIncrement(), "컵라면", 2000, 1900, 50));
productList.add(new Product(atom.getAndIncrement(), "캔커피", 2500, 2250, 20));
productList.add(new Product(atom.getAndIncrement(), "캔음료", 2000, 1800, 20));
}
// 신규 고객 등록하기
/*
* 반환타입: boolean
* 메소드명: addCustomer
* 매개변수: Customer 고객정보
*/
public boolean addCustomer(Customer customer) {
Customer savedCustomer = getCustomerById(customer.getId());
if(savedCustomer != null) { //신규를 등록할거니까, 입력한 아이디와 일치하는 아이디가 있으면 안됨
return false;
}
customerList.add(customer);
return true;
}
// 고객 상세정보 제공하기
/*
* 반환타입: Customer
* 메소드명: getCustomerById
* 매개변수: String 고객아이디
*/
public Customer getCustomerById(String customerId) {
for(Customer customer : customerList) {
if(customer.getId().equals(customerId)) {
return customer;
}
}
return null;
}
// 상품 전체목록 제공하기
/*
* 반환타입: List<Product> (상품들이 여기에 들어가있으니까)
* 메소드명: getAllProducts
* 매개변수: 없음
*/
public List<Product> getAllProducts(){
return productList; // Product가 여러개 들어있는 List의 주소값
}
// 상품 입고하기 (새 상품추가 없이 기준 상품의 재고량을 증가시킴)
/*
* 반환타입: boolean (성공했는지 여부를 알기 위해)
* 메소드명: updateProductStock
* 매개변수: int 상품번호, int 입고수량
*/
public boolean updateProductStock(int productNo, int amount) {
Product product = getProductDetail(productNo);
if(product == null) {
return false;
}
int stock = product.getStock()+amount;
product.setStock(stock);
return true;
}
// 상품 상세정보 제공하기
/*
* 반환타입: Product (이 안에 상품의 상세정보 변수가 있고, 내용은 ProductList에 있음)
* 메소드명: getProductDetail
* 매개변수: int 상품번호
*/
public Product getProductDetail(int productNo) {
for(Product product : productList) {
if(product.getNo() == productNo) {
return product;
}
}
return null; // 상품번호와 일치하는 상품이 없으면 null 반환
}
// 상품 주문하기
/*
* 반환타입: boolean (성공여부)
* 메소드명: order
* 매개변수: String 고객아이디, List<Integer> 상품번호, List<Integer> 구매수량 (여러개 주문하니까 int[]인데, 배열 안쓰기로 했으니까 -> 여러개는 무조건 List<>)
*/
public boolean order(String customerId, List<Integer> productsNos, List<Integer> quantities) {
Customer savedCustomer = getCustomerById(customerId); // 1) 일치하는 아이디의 고객객체 얻기
if(savedCustomer==null) {
return false;
}
Order order = new Order(); // 2) Order객체에 정보 넣기
order.setNo(atom.getAndIncrement());
order.setDate(new Date());
order.setCustomerId(customerId);
order.setCustomerName(savedCustomer.getName());
int size = productsNos.size(); // 3) 키보드로 입력한 상품번호, 수량을 각각 index로 묶음
for(int index=0; index<size; index++) {
int productNo = productsNos.get(index);
int quantity = quantities.get(index);
Product savedProduct = getProductDetail(productNo); // 4) 인덱스에 맞는 상품상세정보 얻기
if(savedProduct == null) {
continue; // 종료가 아니라 다음 반복문을 뛰어넘음
}
if(savedProduct.getStock() < quantity) {
continue;
}
Item item = new Item(); // 5) 주문한 item 객체에 정보 넣기
item.setNo(productNo);
item.setName(savedProduct.getName());
item.setPrice(savedProduct.getDiscountPrice());
item.setQuantity(quantity);
order.addItem(item); // 6) Order객체의 item리스트에 방금 얻은 item객체 추가
int stock = savedProduct.getStock()-quantity; // 7) 재고 변경
savedProduct.setStock(stock);
}
int point = savedCustomer.getPoint() + order.getDepositPoint();
savedCustomer.setPoint(point);
orderList.add(order); // 8) 만든 Order객체를 orderList에 추가
// 3) ~ 8) 과정을 반복
return true;
}
// 전체 주문내역 보기
/*
* 반환타입: List<Order> (Order가 여러개 담겨있는 리스트)
* 메소드명: getAllOrders
* 매개변수: 없음
*/
public List<Order> getAllOrders(){
return orderList;
}
// 고객별 주문내역 보기
/*
* 반환타입: List<Order> (한 고객이 주문을 여러개 했을 수도 있으니까 List)
* 메소드명: getOrderByCustomerId
* 매개변수: String 고객아이디
*/
public List<Order> getOrderByCustomerId(String customerId){
List<Order> customerOrderList = new ArrayList<>(); // 반환타입이 list일때는 반환값을 담을 arraylist객체를 일단 만듦 (반환이 null일 수 없음)
for(Order order : orderList) {
if(order.getCustomerId().equals(customerId)) {
customerOrderList.add(order);
}
}
return customerOrderList;
}
// 주문별 상세정보 보기
/*
* 반환타입: Order
* 메소드명: getOrderDetail
* 매개변수: int 주문번호
*/
public Order getOrderDetail(int orderNo) {
Order foundOrder = null; // 한개만 반환할때는 이렇게 (1개이거나 못찾으면 null)
for(Order order : orderList) {
if(order.getNo()==orderNo) {
foundOrder = order;
break;
}
}
return foundOrder;
}
}
-출력
--------------------------------------------------------------------------
1.고객 2.상품 3.주문 0.종료
--------------------------------------------------------------------------
# 메뉴선택: 1
--------------------------------------------------------------------------
1.고객조회 2.고객등록
--------------------------------------------------------------------------
# 고객메뉴 선택: 1
<< 고객 상세정보 출력 >>
## 고객 아이디 입력: kim
=== 사용자 상세정보 ===
아이디: kim
이름: 김유신
이메일: kim@naver.com
포인트: 0
--------------------------------------------------------------------------
1.고객 2.상품 3.주문 0.종료
--------------------------------------------------------------------------
# 메뉴선택: 2
--------------------------------------------------------------------------
1.상품목록 2.상품상세 3.상품입고
--------------------------------------------------------------------------
# 상품메뉴 선택: 1
<< 전체 상품 목록 출력 >>
상품번호 상품명 가격
1001 삼각김밥 2700
1002 하얀우유 1100
1003 도시락 4700
1004 샐러드 3700
1005 딸기우유 1000
1006 하리보 1350
1007 오레오 1050
1008 컵라면 1900
1009 캔커피 2250
1010 캔음료 1800
--------------------------------------------------------------------------
1.고객 2.상품 3.주문 0.종료
--------------------------------------------------------------------------
# 메뉴선택: 3
--------------------------------------------------------------------------
1.주문 2.전체주문내역 3.고객별주문내역 4.주문상세
--------------------------------------------------------------------------
# 주문메뉴 선택: 1
<< 주문하기 >>
## 고객 아이디 입력: kim
## 상품번호 입력: 1002
## 구매수량 입력: 5
## 계속 구매하시겠습니까? (y/n) y
## 상품번호 입력: 1005
## 구매수량 입력: 3
## 계속 구매하시겠습니까? (y/n) n
[성공] 모든 주문이 완료되었습니다.
--------------------------------------------------------------------------
1.고객 2.상품 3.주문 0.종료
--------------------------------------------------------------------------
# 메뉴선택: 3
--------------------------------------------------------------------------
1.주문 2.전체주문내역 3.고객별주문내역 4.주문상세
--------------------------------------------------------------------------
# 주문메뉴 선택: 2
<< 전체 주문 내역 출력 >>
주문번호 고객명 총 구매금액
1011 김유신 8,500
--------------------------------------------------------------------------
1.고객 2.상품 3.주문 0.종료
--------------------------------------------------------------------------
# 메뉴선택: 3
--------------------------------------------------------------------------
1.주문 2.전체주문내역 3.고객별주문내역 4.주문상세
--------------------------------------------------------------------------
# 주문메뉴 선택: 4
<< 주문 상세 정보 >>
## 주문 번호 입력: 1011
=== 주문 고객 정보 ===
주문번호: 1011
주문날짜: 2022-10-06
주문자 아이디: kim
주문자 이름: 김유신
=== 주문 상품 정보 ===
상품번호 상품이름 상품가격 구매수량 구매가격
1002 하얀우유 1,100원 5 5,500원
1005 딸기우유 1,000원 3 3,000원
- Order 주문 한번에 대한 흐름
멤버변수는 항상 기본값으로 초기화되어있음
지역변수는 쓰레기값이 들어있음
-> point를 입력받아오는데 초기화하지 않아도 0부터 시작하는 이유
1-2. Controller와 Service 객체의 커뮤니케이션 (메소드 호출)
Controller -> Servce : 메소드 실행 요청 ( 매개변수 인자: 기본자료형, VO객체, List<VO> )
Service -> Controller : 반환값 ( 반환값: 기본자료형, VO객체, List<VO> )
- 매개변수 타입 결정
- 기본자료형
- 인자로 전달할 값의 개수가 적은 경우 사용
- 값들이 서로 독립적인 경우 사용
- getProductDetail(int productNo)
changePassword(String userId, String perPwd, String pwd)
- VO 객체
- 인자로 전달할 값의 개수가 3개 이상
- 인자로 전달하는 값들이 하나의 정보를 구성하는 값
- registerUser(User user)
User는 id, password, name, email, tel 등의 값을 가지고 있는 객체
- 콜렉션 (List<VO>, List<Wrapper>)
- 인자로 전달하는 값이 같은 정보가 여러개 있는 경우
- deleteProducts(List<Integer> productNos) : 한번에 여러 개의 상품번호를 전달해서 삭제
insertJobs(List<Job> jobs) : 이력서 정보를 등록할 때 자신의 경력사항 정보를 여러개 입력
- 기본자료형
- 반환타입 결정
- 기본자료형
- 반환값이 1개 (정수 1개, 실수 1개)
- int getTotalPrice()
- VO객체
- 반환할 정보가 1개 (고객정보 1개, 상품정보 1개)
- Customer getCustomerById(String id)
Product getProductByNo(int no)
- 콜렉션 ( List<VO> )
- 반환할 정보가 여러 개
- 각각의 정보는 같은 종류의 정보
- List<Book> searchBook(String keyword)
List<Order> getMyOrder(String userId)
- 기본자료형
2. Map<K, V> 인터페이스
* Set<E> : 중복 불가 ( HashSet<E>, TreeSet<E> )
* List<E> : 순서 보장 ( ArrayList<E>, Vector<E>, Stack<E>, LinkedList<E> )
* Queue<E> : 선입선출 ( LinkedList<E> )
* Map<K, V> : Key, Value의 쌍으로 객체 저장 ( HashMap<K, V>, HashTable<K, V> )
* 나머지는 객체 1개씩 저장되는 거라 <E> 하나뿐
Map은 객체 2개씩 저장됨 (Key, Value)
* 사용빈도
: ArrayList<E> > HashSet<E> > HashMap<K,V>
2-1. Map<K, V> 인터페이스
- Map<K, V>는 데이터를 Key와 Value의 쌍으로 연결지어서 저장하는 객체다.
- Key와 Value의 쌍을 표현하는 객체는 Entry<K, V>다.
* 텅 비어있는 공간에 key와 value가 담긴 Entry 객체가 생기는 것 - Map<K, V>객체는 Entry<K, V>객체를 여러 개 저장하는 객체다.
- Key는 값을 대표하는 값이다. Key는 중복될 수 없다. Key의 타입은 보통 String, Integer, Long 타입이 주로 사용된다.
- Value는 실제로 Map에 저장할 정보를 가지고 있는 객체다.
- Key와 Value의 예
| Key | Value | Map<K, V> |
| 학번 | 학생객체 | Map<Integer, Student> |
| 주문번호 | 주문정보객체 | Map<Long, Order> |
| 사용자아이디 | 사용자정보객체 | Map<String, User> |
| 상품번호 | 상품정보객체 | Map<Integer, Product> |
- 주요 메소드
- V put(K key, V value)
- Map객체에 key, value의 쌍으로 객체를 저장한다.
key객체는 중복을 허용하지 않는다. 같은 key객체로 여러번 저장하면 맨 마지막에 저장된 것만 유지된다.
- Map객체에 key, value의 쌍으로 객체를 저장한다.
- V get(Object key)
- Map객체에서 지정된 key와 쌍으로 저장된 value를 반환한다.
key가 존재하지 않으면 null 반환한다.
- Map객체에서 지정된 key와 쌍으로 저장된 value를 반환한다.
- V remove(Object key)
- Map객체에서 지정된 key를 가지는 Entry객체(key, value의 쌍)를 삭제한다.
- boolean containsKey(Object key)
- Map객체에 지정된 key가 포함되어 있으면 true를 반환한다.
- boolean isEmpty()
- Map객체에 Entry객체가 존재하지 않으면 true를 반환한다.
- int size()
- Map객체에 저장된 Entry객체의 개수(Key,value쌍의 개수)를 반환한다.
- void clear()
- Map객체에 저장된 모든 Entry객체(key, value의 쌍)를 삭제한다.
- boolean containsValue(Object value)
- Map객체에 지정된 value가 포함되어 있는지 여부를 반환한다.
- Set<Key> keySet()
- Map객체의 모든 key 객체를 Set객체에 담아서 반환한다. (key객체의 집합 봔환)
- Collection<V> values()
- Map객체의 모든 value를 Collection객체에 담아서 반환한다.
- Set<Map.Entry<K, V>> entrySet()
- Map객체에 저장된 모든 Entry<K, V>를 Set에 담아서 반환한다. (Entry객체의 집합 반환)
- V put(K key, V value)
- 주요 구현 클래스
- HashMap
- 가장 많이 사용하는 Map인터페이스 구현 클래스다.
- HashTable
- HashMap과 사용법은 동일하지만, 멀티스레드환경에서 안전하다.
- HashMap
* Map<K, V> 인터페이스의 특징
- index 몇번째인지 기억할 필요없이, key의 이름만 알고있으면 값을 알 수 있음
- 한번에 저장할 수 있다는 점은 좋지만, 꺼낼때는 for문 못씀. -> 무조건 key를 통해서 하나씩 꺼내야 함
-> key를 알고 있어야 함
- key값에 적을 때 무조건 복붙으로 하기 ! (오타나도 빨간줄이 안뜸)
- VO객체의 대체재 (다양한 값, 객체를 이름을 붙여서 사용)
- Map<K, V> 에서 K와 V의 타입
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapApp1 {
public static void main(String[] args) {
Map<String, String> map1 = new HashMap<>();
map1.put("name", "홍길동");
map1.put("email", "hong@gmail.com");
map1.put("tel", "010-1111-1111");
map1.put("address", "서울특별시 종로구 봉익동");
Map<String, Integer> map2 = new HashMap<>();
map2.put("kor", 100);
map2.put("eng", 90);
map2.put("math", 70);
map2.put("history", 90);
map2.put("sci", 80);
Map<String, Object> map3 = new HashMap<>(); // value의 타입이 다 다른 경우 -> Object
map3.put("no", 100);
map3.put("dept", "영업1팀");
map3.put("name", "홍길동");
map3.put("position", "차장");
map3.put("salary", 600);
map3.put("commission", 0.35);
map3.put("projects", List.of("삼성전자 차세대 프로젝트", "서울시청 인사정보 시스템 프로젝트", "우리은행 신용평가시스템"));
Map<String, List<String>> map4 = new HashMap<>();
map4.put("hyndai", List.of("황민경", "고예림", "야스민", "이다현", "양효진", "김다인", "김연경"));
map4.put("hipass", List.of("카타리나", "전새얀", "박정아", "문정원", "배유나", "이윤정", "임명옥"));
}
}
2-2. Map<K, V>의 활용
- Map을 활용하면 if ~ else if ~ else if 문을 제거할 수 있다. (조건식 제거)
- 조건식에서 비교대상으로 사용되는 값을 Map의 key로, 연산에 사용되는 값을 Map의 value로 저장
- 범위가 있는 경우는 if문으로 써야하는데, 항목이 미리 정해져있고 이 항목이 변경될 수 있는 경우는 Map으로
- 입력값(등급)에 따라서 Map에 해당되는 등급을 가져와서 연산에 활용할 수 있다.
1) 고객 등급과 구매금액을 입력받아서 적립포인트를 출력하는 프로그램
-Map을 안 썼을 때
import utils.KeyboardReader;
import utils.StringUtils;
public class MapApp3 { // Map을 사용하지 않았을 때
public static void main(String[] args) {
// 고객 등급과 구매금액을 입력하면 적립포인트를 출력하는 프로그램
// 고객등급: 일반(0.4%적립), 로얄(1%적립), 골드(2%적립), 플래티넘(5%적립)
KeyboardReader keyboard = new KeyboardReader();
System.out.print("## 등급입력(일반, 로얄, 골드, 플래티넘): ");
String grade = keyboard.getString();
System.out.print("## 구매금액 입력: ");
int orderPrice = keyboard.getInt();
int point = 0;
if("플래티넘".equals(grade)) {
point = (int)(orderPrice*0.05);
} else if("골드".equals(grade)) {
point = (int)(orderPrice*0.02);
} else if("로얄".equals(grade)) {
point = (int)(orderPrice*0.01);
} else if("일반".equals(grade)) {
point = (int)(orderPrice*0.004);
}
System.out.println("고객등급: " + grade);
System.out.println("주문금액: " + StringUtils.numberToString(orderPrice) + "원");
System.out.println("포인트: " + StringUtils.numberToString(point) + "점");
}
}
## 등급입력(일반, 로얄, 골드, 플래티넘): 로얄
## 구매금액 입력: 3500000
고객등급: 로얄
주문금액: 3,500,000원
포인트: 35,000점
-Map을 활용
import java.util.HashMap;
import java.util.Map;
import utils.KeyboardReader;
import utils.StringUtils;
public class MapApp3 { // Map을 사용하지 않았을 때
public static void main(String[] args) {
// 고객 등급과 구매금액을 입력하면 적립포인트를 출력하는 프로그램
// 고객등급: 일반(0.4%적립), 로얄(1%적립), 골드(2%적립), 플래티넘(5%적립)
Map<String, Double> depositRateMap = new HashMap<>();
depositRateMap.put("일반", 0.004);
depositRateMap.put("로얄", 0.01);
depositRateMap.put("골드", 0.02);
depositRateMap.put("플래티넘", 0.05);
KeyboardReader keyboard = new KeyboardReader();
System.out.print("## 등급입력(일반, 로얄, 골드, 플래티넘): ");
String grade = keyboard.getString();
System.out.print("## 구매금액 입력: ");
int orderPrice = keyboard.getInt();
double depositRate = depositRateMap.get(grade);
int point = (int)(orderPrice*depositRate);
System.out.println("고객등급: " + grade);
System.out.println("주문금액: " + StringUtils.numberToString(orderPrice) + "원");
System.out.println("포인트: " + StringUtils.numberToString(point) + "점");
}
}
## 등급입력(일반, 로얄, 골드, 플래티넘): 플래티넘
## 구매금액 입력: 3500000
고객등급: 플래티넘
주문금액: 3,500,000원
포인트: 175,000점
2) 이용하는 메신저에 따라 다른 메세지 전송하는 프로그램
- MessengerMap 이라는 Map인터페이스의 타입은 <String, Messenger>
( 타입이 Messenger면 그 하위 객체도 담을 수 있음 )
- key -> String , value -> Messenger
- sms, kakao, app Messenger 객체가 모두 생성됨
- 얘네는 모두 Messenger 인터페이스를 구현하고 있음
- Messenger 인터페이스의 send 메소드를 각각 재정의하고 있음
for(User user : users) {
String messageType = user.getMessageType();
Messenger m = messengerMap.get(messageType);
m.send("홍보팀", user.getName(), "세일");
-users에서 하나 뽑아서 그 유저의 메세지 타입을 저장
메세지Map에서 메세지 타입의 키에 맞는 값을 m에 저장
String이 "sms"일 때는 Sms객체가 재정의한 메세지를 출력
=> 추상화, 인터페이스, 형변환, 다형성, 재정의, Map 등이 다 쓰임
public interface Messenger {
void send(String from, String to, String content);
}
public class SmsMessenger implements Messenger {
@Override
public void send(String from, String to, String content) {
System.out.println("<< 문자 메세지로 발송 >>");
System.out.println("발신자 : " + from);
System.out.println("수신자 : " + to);
System.out.println("내용 : " + content);
}
}
public class KakaoTalkMessenger implements Messenger {
@Override
public void send(String from, String to, String content) {
System.out.println("<< 카카오톡 메세지로 발송 >>");
System.out.println("발신자 : " + from);
System.out.println("수신자 : " + to);
System.out.println("내용 : " + content);
}
}
public class AppMessenger implements Messenger {
@Override
public void send(String from, String to, String content) {
System.out.println("<< 스마트폰 앱 푸시로 메세지로 발송 >>");
System.out.println("발신자 : " + from);
System.out.println("수신자 : " + to);
System.out.println("내용 : " + content);
}
}
public class User {
private String name;
private String messageType;
public User(String name, String messageType) {
this.name = name;
this.messageType = messageType;
}
public String getName() {
return name;
}
public String getMessageType() {
return messageType;
}
}
-Map을 안썼을 때
public class MessengerApp {
public static void main(String[] args) {
SmsMessenger smsMessenger = new SmsMessenger();
KakaoTalkMessenger kakaoTalkMessenger = new KakaoTalkMessenger();
AppMessenger appMessenger = new AppMessenger();
for(User user : users) {
String messageType = user.getMessageType();
if("sms".equals(messageType)) {
smsMessenger.send("홍보팀", user.getName(), "세일을 시작합니다.");
} else if("kakao".equals(messageType)) {
kakaoTalkMessenger.send("홍보팀", user.getName(), "세일을 시작합니다.");
} else if("app".equals(messageType)) {
appMessenger.send("홍보팀", user.getName(), "세일을 시작합니다.");
}
}
}
}
-Map 을 썼을 때
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MessengerApp {
public static void main(String[] args) {
// Messenger 인터페이스를 구현한 객체 생성 (메신저 종류)
SmsMessenger smsMessenger = new SmsMessenger();
KakaoTalkMessenger kakaoTalkMessenger = new KakaoTalkMessenger();
AppMessenger appMessenger = new AppMessenger();
// Map<String, Messenger>에 위에서 생성한 Messenger 구현객체 저장
// Map<String, Messenger>에서 key에 메신저타입, value에 메신저종류를 저장
// 클래스 형변환이 일어나서 Entry의 V에는 실제 생성한 객체의 부모타입 Messenger객체의 주소값 저장
Map<String, Messenger> messengerMap = new HashMap<>(); // 타입이 Messenger 상위객체면 그 하위객체도 다 가능
messengerMap.put("sms", smsMessenger);
messengerMap.put("kakao", kakaoTalkMessenger);
messengerMap.put("app", appMessenger);
// 사용자 리스트
List<User> users = new ArrayList<>();
users.add(new User("홍길동", "sms"));
users.add(new User("김유신", "app"));
users.add(new User("강감찬", "sms"));
users.add(new User("이순신", "kakao"));
users.add(new User("류관순", "app"));
// 사용자 리스트에서 사용자정보를 하나씩 조회해서 해당 사용자정보의 messageType을 확인하고,
// messageType에 맞는 Messenger 구현객체를 Map<String, Messenger> 객체에서 조회한다
for(User user : users) {
// 사용자의 메세지타입 조회하기 ("sms, "kakao", "app" 중 하나)
String messageType = user.getMessageType();
// Map<String, Messenger> 맵객체에서 messageType의 결과에 해당하는 key값을 통해 value를 조회한다
// messenger 참조변수는 SmsMessenger객체, KakaoTalkMessenger, AppMessenger 객체 중에서
// Map<String, Messenger> 맵객체에서 조회된 Messenger 구현객체의 상위객체 Messenger를 참조한다
Messenger messenger = messengerMap.get(messageType);
// Map<String, Messenger> 맵객체에서 조회한 Messenger 구현객체로 메세지 발송하기
// messenger.send()메소드를 실행시켜서 메세지를 발송하게 하는데,
// messenger 참조변수가 참조하는 Messenger 구현객체에 따라서 메세지 전송방식이 달라진다.
// => *다형성 - 사용방법은 동일하지만 실제로 사용하는 객체가 달라지면(참조변수가 참조하는 객체에 따라서) 실행결과도 달라진다.
messenger.send("홍보팀", user.getName(), "세일해요");
}
}
}
<< 문자 메세지로 발송 >>
발신자 : 홍보팀
수신자 : 홍길동
내용 : 세일해요
<< 스마트폰 앱 푸시로 메세지로 발송 >>
발신자 : 홍보팀
수신자 : 김유신
내용 : 세일해요
<< 문자 메세지로 발송 >>
발신자 : 홍보팀
수신자 : 강감찬
내용 : 세일해요
<< 카카오톡 메세지로 발송 >>
발신자 : 홍보팀
수신자 : 이순신
내용 : 세일해요
<< 스마트폰 앱 푸시로 메세지로 발송 >>
발신자 : 홍보팀
수신자 : 류관순
내용 : 세일해요
3) Map<K, V>에서 V의 타입이 매우 다양한 경우, V의 타입을 Object로 지정
- 이 경우, 모두 Object로 형변환되어서 저장됨
- V에서 꺼낼 때는 다시 원래의 타입으로 강제 형변환 해야 함
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapApp4 {
public static void main(String[] args) {
// Map<K, V>에서 V의 타입이 매우 다양한 경우, V의 타입을 Object로 지정
Map<String, Object> map = new HashMap<>();
// Map<String, Object> 객체에 key, value 저장하기
map.put("no", 10000);
map.put("title", "와칸다 포에버");
map.put("openDate", new Date());
map.put("runningTime", 120);
map.put("director", "라이언 쿠글러");
map.put("actors", List.of("레티티아 라이드", "다나이 구리라", "루피타 뇽"));
// Map<String, Object> 객체에서 key를 통해 value 조회하기(꺼내기)
// 지금 다 Object 타입이기 때문에 강제 형변환 필요
int 번호 = (Integer) map.get("no"); // Integer 객체에 넣어야 함 (오토언박싱)
String 제목 = (String) map.get("title");
Date 개봉일 = (Date) map.get("openDate");
int 상영시간 = (Integer) map.get("runningTime");
String 감독 = (String) map.get("director");
@SuppressWarnings("unchecked") // 이거 String 맞으니까 컴파일 니가 확인 안해도돼
List<String> 출연진 = (List<String>) map.get("actors");
System.out.println(번호);
System.out.println(제목);
System.out.println(개봉일);
System.out.println(상영시간);
System.out.println(감독);
System.out.println(출연진);
}
}
10000
와칸다 포에버
Fri Oct 07 11:33:18 KST 2022
120
라이언 쿠글러
[레티티아 라이드, 다나이 구리라, 루피타 뇽]
4) Map<K, V> 의 메소드 사용하기
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapApp5 {
public static void main(String[] args) {
Map<Integer, String> depts = new HashMap<>();
// V put(K k, V v)로 맵객체에 객체 저장하기
depts.put(1001, "국어국문학과");
depts.put(1002, "영어영문학과");
depts.put(1003, "경영학과");
depts.put(1004, "전자공학과");
depts.put(1005, "기계공학과");
// boolean containsKey(Object key)로 Map객체에 지정된 key가 존재하는지 확인하기
boolean isContains = depts.containsKey(1000);
System.out.println("키의 존재여부: " + isContains);
// 동일한 key로 value를 중복저장하는 경우 (덮어써짐)
// V put(K k, V v)는 Map객체에 동일한 key가 존재하지 않으면 key, value를 추가하고,
// 동일한 key가 존재하면 value를 덮어쓴다.
depts.put(1004, "컴퓨터공학과");
System.out.println(depts);
// V remove(Object key)로 Map객체에서 지정된 key로 저장된 key, value 삭제하기
depts.remove(1002);
System.out.println(depts);
// boolean isEmpty()로 Map객체가 비어있는지 확인하기
boolean isEmpty = depts.isEmpty();
System.out.println("비어있는가? " + isEmpty);
// int size()로 Map 객체에 저장된 key, value의 개수 조회하기
int size = depts.size();
System.out.println("저장된 개수: " + size);
// Set<K> keySet()로 Map객체의 모든 key값이 저장된 Set객체 조회하기
Set<Integer> keys = depts.keySet();
System.out.println("키 집합: " + keys);
for(int key : keys) {
System.out.println("["+key+"]" + depts.get(key));
}
// void clear()로 Map객체에 저장된 모든 key, value 삭제하기
depts.clear();
System.out.println(depts);
}
}
키의 존재여부: false
{1001=국어국문학과, 1002=영어영문학과, 1003=경영학과, 1004=컴퓨터공학과, 1005=기계공학과}
{1001=국어국문학과, 1003=경영학과, 1004=컴퓨터공학과, 1005=기계공학과}
비어있는가? false
저장된 개수: 4
키 집합: [1001, 1003, 1004, 1005]
[1001]국어국문학과
[1003]경영학과
[1004]컴퓨터공학과
[1005]기계공학과
{}
5) Map<K, V>을 이용해서 문장에서 글자가 몇번씩 나오는지 확인하기
import java.util.Arrays;
import java.util.Map;
import java.util.TreeMap;
import javax.swing.tree.TreePath;
public class MapApp6 { // 문장에서 글자가 몇번씩 나오는지 확인하기 (Map을 이용해서 분류하기)
public static void main(String[] args) {
String text = "Learn programming with free online courses from real college courses from Harvard, MIT, and more of the world's leading universities.";
text = text.toLowerCase();
Map<Character, Integer> map = new TreeMap<>(); // 'a'가 n개 있다는 것을 확인
int len = text.length();
for(int index=0; index<len; index++) {
char ch = text.charAt(index); // 'l','e','a','r','n'
int code = ch; // 이걸 숫자로 변환
if(code >= 97 && code <= 122) { // 97~122까지만 알파벳소문자. 특수문자 제외, 알파벳에 대해서만 실행
if(map.containsKey(ch)) {
int count = map.get(ch);
map.put(ch, count + 1);
} else {
map.put(ch, 1);
}
}
}
System.out.println(map);
}
}
{a=7, c=3, d=4, e=14, f=4, g=4, h=3, i=8, l=7, m=6, n=7, o=10, p=1, r=14, s=7, t=4, u=3, v=2, w=2}
6) Map<K, V>을 이용해서 부서별로 사원정보 분류하기
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import utils.StringUtils;
public class MapApp7 {
public static void main(String[] args) { // 메인메소드에서 내부클래스 호출
List<Employee> employeeList = Arrays.asList(new Employee("홍보부","유재석",300),
new Employee("홍보부","지석진",400),
new Employee("인사부","김종국",500),
new Employee("인사부","하하",200),
new Employee("인사부","송지효",350),
new Employee("총무부","양세찬",550),
new Employee("총무부","전소민",200),
new Employee("총무부","리지",600),
new Employee("총무부","송중기",450),
new Employee("연구소","개리",700),
new Employee("연구소","이광수",800),
new Employee("연구소","홍길동",650));
// 부서별로 사원정보 분류하기
// 일단 비어있는 Map에서 key가 없으면 그때부터 추가
Map<String, List<Employee>> map1 = new HashMap<>(); //key-부서명(String), value-Employee리스트
for(Employee emp : employeeList) {
// 소속부서 조회
String dept = emp.getDept(); // 부서를 먼저 알아내
// Map 객체에 해당 소속부서로 저장된 key가 있는지 확인
if(map1.containsKey(dept)) { // 그 부서를 포함하고있으면
List<Employee> list = map1.get(dept);
list.add(emp);
} else { // 그 key가 존재하지 않으면
// Map 객체에 해당 소속부서의 key가 존재하지 않으면
// 한 부서의 사원정보를 여러개 저장할 수 있는 List객체 생성
// List객체에 지금 조회된 사원정보 객체를 저장
// Map 객체에 해당 소속부서를 key로 List객체를 저장
List<Employee> list = new ArrayList<>(); // 객체를 새로 만들어서
list.add(emp); // 사원정보 객체를 리스트에 넣을거야
map1.put(dept, list);
}
}
// Map<String, List<Employee>> 객체의 key를 전부 조회하기
Set<String> keys = map1.keySet();
// 부서별 인원 수 출력하기
// key인 "홍보부"꺼내서 처리, "인사부"꺼내서 처리
System.out.println("### 부서별 인원수 출력");
for(String key : keys) {
List<Employee> employees = map1.get(key);
int count = employees.size();
System.out.println("["+key+"] " + count + " 명");
}
System.out.println();
// 부서별 총 급여 출력하기
System.out.println("### 부서별 총 급여 출력");
for(String key : keys) {
List<Employee> employees = map1.get(key);
int totalSalary = 0;
int averageSalary = 0;
for(Employee emp : employees) {
totalSalary += emp.getSalary();
}
averageSalary = totalSalary/employees.size();
System.out.println("부서명: " + key);
System.out.println("총 급여: " + StringUtils.numberToString(totalSalary) + "원");
System.out.println("평균 급여: " + StringUtils.numberToString(averageSalary) + "원");
System.out.println();
}
}
// 정적 내부 클래스 (static 메인 클래스에서 호출하려면 정적클래스여야 해서) -설계도는1개지만 실행파일은2개
static class Employee{
private String dept;
private String name;
private int salary;
public Employee(String dept, String name, int salary) {
this.dept = dept;
this.name = name;
this.salary = salary;
}
public String getDept() {
return dept;
}
public String getName() {
return name;
}
public int getSalary() {
return salary;
}
public void setDept(String dept) {
this.dept = dept;
}
public void setName(String name) {
this.name = name;
}
public void setSalary(int salary) {
this.salary = salary;
}
}
}
### 부서별 인원수 출력
[총무부] 4 명
[홍보부] 2 명
[인사부] 3 명
[연구소] 3 명
### 부서별 총 급여 출력
부서명: 총무부
총 급여: 1,800원
평균 급여: 450원
부서명: 홍보부
총 급여: 700원
평균 급여: 350원
부서명: 인사부
총 급여: 1,050원
평균 급여: 350원
부서명: 연구소
총 급여: 2,150원
평균 급여: 716원
List<Employee> list = new ArrayList<>();
"홍보부"가 없으면, ArrayList를 만들어 -> List<Employee> 객체를 만드는거 (사원객체를 여러개 담을 리스트)
list.add(emp);
거기에 첫번째 사원 정보를 담는거야
map1.put(dept, list);
그리고 그걸 Map에 넣어. Map의 String에 "홍보부" key가 들어가고
"인사부"라는 키로 List를 가리킴
그리고 만약 "홍보부"가 있으면
List<Employee> list = map1.get(dept);
map에서 "홍보부"의 key를 가지고 있는 value값(=홍보부 리스트?) 을 list에 넣을거야
list 변수가 홍보부 리스트를 바라봐
list.add(emp);
그 객체를 리스트에 더해
Map안에 String, List<Employee>가 있고
이 List<Employee>는 각각 key에 맞는 List 객체를 바라봄
이 List 객체 안에는 Employee 객체가 있음
key로 찾은건 value값인 list가 나오고
list에서는 Employee 객체가 나옴
※ 정리
* ArrayList<E>
- 객체를 여러 개 저장할 때 가장 많이 사용되는 자료구조 구현 클래스
- 같은 타입의 객체를 여러 개 저장
- 내부적으로 index(순번)가 있어서 저장한 순서대로 다시 꺼낼 수 있다. (순서 보장)
* HashSet<E>
- 같은 타입의 객체를 여러 개 저장
- 중복을 허용하지 않는다. (동일한 객체 혹은 동등한 객체를 중복해서 저장할 수 없다.)
* 동등성 비교를 위해서는 hashCode와 equals 메소드를 재정의해야 함
* TreeSet<E>
- 같은 타입의 객체를 여러 개 저장
- 중복을 허용하지 않는다.
- 객체를 저장하면 내부 정렬된다.
* TreeSet에 저장하는 객체는 반드시 Comparable<E> 인터페이스의 compareTo(E o) 메소드를 재정의 해야 함
* HashMap<E>
- key, value의 쌍으로 저장
- key는 중복을 허용하지 않는다.
- value는 같은 타입일 수도 있고 다른 타입일 수도 있다.
- 항상 key를 사용해서 key, value 쌍의 정보를 다룬다.
- 정보가 가변적일 때 사용되는 자료구조 구현 클래스