본문 바로가기
카테고리 없음

24. 07. 26 개발자교육 5주차 금요일 JAVA(컬렉션, 제네릭)

by 융기융 2024. 7. 26.
반응형

 

컬렉션은 자바에서 제공하는 자료구조를 담당하는 프레임워크이다.

ListService

package list.service;

 

import java.util.ArrayList;

import java.util.List;

 

/* Collection Framework : Java에서 제공하는 자료구조를 모아둔 것

* (java.util 패키지에 존재)

*

* [특징]

* 1) 크기제한 X

* 2) 추가, 수정, 삭제, 검색 정렬 등 다양한 기능이 제공됨

* 3) 객체만 저장 가능!! (정확히는 객체 참조 주소만 저장 가능)

*

* [List]

* - 자료(Data)를 순차적으로 나열한 자료 구조(배열 비슷)

* - index가 존재함

* -> 각 Data를 index로 구분할 수 있어

* 중복된 Data를 저장할 수 있다!!!

*/

 

 

public class ListService {

 

public void test1() {

 

// ArrayList 객체 생성

// -> List 인터페이스를 상속받은 자식 클래스로

// 가장 많이 사용하는 List

 

// List : 부모 인터페이스

// -> 객체 생성불가 / 부모 참조변수 가능

 

// List list = new ArrayList(); // 10칸 짜리 생성

 

List<Object> list = new ArrayList<Object>(3); // 3칸 짜리 생성

 

// E(Element) : 요소를 뜻하는 상직적인 글자

// (특정 자료형 X, Object 타입)

 

// boolean add(E e)

// -List에 주어진 객체(e)를 맨 끝에 추가

list.add("아무거나 홍홍");

list.add(new Object());

list.add(new int[4]); // 3번째

 

// 4번째 -> 크기초과, 오류 발생 X

// --> List 크기가 자동으로 증가

list.add(123); // int 기본 자료형은 추가 불가

// integer Wrapper class로

// 자동으로 변환되어 저장됨

 

System.out.println(list.toString());

 

// 2. void add(int index, E e)

// - index 번째에 e를 추가 -> 중간에 삽입한다

 

list.add(2, "중간");

 

System.out.println(list); // toString() 생략 가능

 

// 3. int size()

// - 저장된 Data(객체)의 수를 반환

 

System.out.println("현재 저장된 data 개수 : " + list.size());

 

// (E == Object)

 

// 4. E get(int index)

// - index번째 요소를 반환

System.out.println(list.get(0));

 

// List + 일반 for 문

for(int i=0 ; i < list.size() ; i++) {

 

System.out.printf("%d 번째 인덱스 요소 : %s\n",

i, list.get(i));

}

 

System.out.println("-------------------------------------");

 

// List + 향상된 for문

 

for( Object obj : list ) {

 

String str = null;

 

// obj가 참조하는 객체가 String 타입이라면

if(obj instanceof String) str = "[String]";

else if(obj instanceof int[]) str = "[int[]]";

else if(obj instanceof Integer) str = "[integer]";

else str = "[Object]";

 

System.out.println( str + obj);

}

}

/**

* List + 제네릭(타입제한) 확인

* + List 메서드 몇가지 더 확인

*/

 

public void test2() {

 

/* 제네릭(Generics, <>)

* 1) 컬렉션의 타입을 제한하여

* 한 가지 자료형만 저장할 수 있게하는 기능

*

* 2) 클래스나 메서드가 다룰 타입을 지정하는 기능

*/

 

// String으로 타입이 제한된 List 생성

List<String> menuList = new ArrayList<String>();

 

// add() 확인

// menuList.add(12342); // String으로 제한되서

// 다른 자료형 추가 불가능

 

menuList.add("보쌈");

menuList.add("닭갈비");

menuList.add("양념갈비");

menuList.add("삼겹살");

menuList.add("칼국수");

menuList.add("냉면");

 

// 향상된 for문

for( String menu : menuList ) {

System.out.println(menu);

}

 

// 5. E set(int index, E e)

// - 지정된 index번째 요소를

// e(두 번째 매개 변수)로 수정

// -> 메서드 반환 값으로 이전 객체가 반환된다

 

System.out.println("-----------------------------");

System.out.println(menuList);

 

String before = menuList.set(2, "소갈비");

 

System.out.println(before + "가 " + menuList.get(2) + "로 변경됨");

System.out.println(menuList);

 

// 6. boolean contains(E e)

// - List 내부에 e와 같은 객체가

// 존재하면 true, 없으면 false 반환 ( 확인 기능 )

System.out.println("보쌈 : " + menuList.contains("보쌈"));

System.out.println("막국수 : " + menuList.contains("막국수"));

 

// 7. int indexOf(E e)

// - List 내부에 e와 같은 객체가

// 존재하면 해당 index를 반환

// 존재하지 않으면 -1 반환

System.out.println("삼겹살 : " + menuList.indexOf("삼겹살"));

System.out.println("오겹살 : " + menuList.indexOf("오겹살"));

 

// 8. E remove(int index)

// - List에서 지정된 index 번째 요소를 제거

// -> 중간이 제거되면 뒤쪽 요소를 앞으로 이동됨

// - 제거된 요소는 메서드 결과로 반환됨

 

System.out.println(menuList.remove(1) + "제거");

System.out.println(menuList);

}

}

ListRun,java

package list.run;

import list.service.ListService;

public class ListRun {

public static void main(String[] args) {

ListService service = new ListService();

// service.test1();

service.test2();

}

}

 

 

 

책목록을 조회하고 책 추가 및 제거 및 책 가격까지도 수정 할 수 있는

도서관리 프로그램 만들기!! 연습 많이 필요!!!

 

BookRun

package list.run;

 

import list.view.BookView;

 

public class BookRun {

 

public static void main(String[] args) {

 

// 변수 : 메모리에 값을 저장하는 공간

// -> 변수에 저장하면 계속 호출 가능(재사용 가능)

 

// 객체를 1회성으로 사용하는 방법

new BookView().mainMenu();

// 문자열 포함 확인

// String.contains("검색어") : 포함이면 true / 아니면 false

// System.out.println("선재 업고 튀어".contains("선재"));

// System.out.println("선재 업고 튀어".contains("업고"));

// System.out.println("선재 업고 튀어".contains("카리나"));

}

}

 

BookDTO

package list.dto;

 

public class BookDTO {

 

private String title; // 제목

private String writer; // 저자(글쓴이)

private int price; // 가격

 

public BookDTO() {} // 기본생성자

 

// 매개변수 생성자

public BookDTO(String title, String writer, int price) {

super();

this.title = title;

this.writer = writer;

this.price = price;

}

 

public String getTitle() {

return title;

}

 

public void setTitle(String title) {

this.title = title;

}

 

public String getWriter() {

return writer;

}

 

public void setWriter(String writer) {

this.writer = writer;

}

 

public int getPrice() {

return price;

}

 

public void setPrice(int price) {

this.price = price;

}

 

// 이클립스 toString() 자동완성 : alt + shift + s -> s

@Override

public String toString() {

return "BookDTO [title=" + title + ", writer=" + writer + ", price=" + price + "]";

}

}

 

BookView

package list.view;

 

import java.util.List;

import java.util.Scanner;

 

import list.dto.BookDTO;

import list.service.BookService;

 

// view : 사용자에게 보여지는 부분(출력, 입력)

public class BookView {

 

private Scanner sc = new Scanner(System.in);

private BookService service = new BookService();

 

/**

* 사용자에게 보여질 메인화면

*/

public void mainMenu() {

int input = 0;

 

do {

System.out.println("\n***** 도서관리 프로그램 *****\n");

 

System.out.println("1. 전체조회");

System.out.println("2. index로 조회");

System.out.println("3. 책 이름으로 조회(포함)");

System.out.println("4. 글쓴이 이름으로 조회(포함)");

System.out.println("5. 가격으로 조회");

System.out.println("6. 책 추가하기");

System.out.println("7. 책 제거하기");

System.out.println("8. 책 가격 수정하기");

System.out.println("0. 종료");

 

System.out.println(); // 줄 바꿈

 

System.out.print("메뉴 선택 >> ");

input = sc.nextInt();

sc.nextLine(); // 입력 버퍼에 남은 엔터 제거

 

System.out.println(); // 줄 바꿈

 

switch(input) {

case 1: selectAll(); break;

case 2: selectIndex(); break;

case 3: selectTitle(); break;

case 4: selectWriter(); break;

case 5: selectPrice(); break;

case 6: addBook(); break;

case 7: removeBook(); break;

case 8: updateBook(); break;

case 0: System.out.println("***** 프로그램 종료 *****"); break;

default : System.out.println("=-=-= 잘못 입력 =-=-=");

}

}while(input != 0);

 

} // mainMenu() method end

 

/**

* 전체 조회

* - BookService에 있는 bookList를 얻어와

* 존재하는 모든 요소의 정보를 출력

*/

private void selectAll() {

System.out.println("\n★☆★☆★ 전체 조회 ★☆★☆★\n");

 

List<BookDTO> bookList = service.selectAll();

 

for(int i = 0 ; i < bookList.size(); i++) {

// print() 관련 구문에서 참조 변수명을 작성하면

// 자동으로 toString()이 호출된다!

System.out.println(i + ") " + bookList.get(i));

}

}

/**

* 입력 받은 index번째 BookDTO를 반환 받아와 출력

*/

private void selectIndex() {

 

System.out.println("\n★☆★☆★ index로 조회 ★☆★☆★\n");

 

System.out.println("조회할 책의 index 번호 입력");

int index = sc.nextInt();

 

// 전달한 index번째 요소가 존재하면 bookDTO 객체 주소

 

// 없다면 null(참조하는 객체가 없음) 반환

BookDTO book = service.selectIndex(index);

 

if(book == null) {

System.out.println("=-=-= 해당 인덱스에 책이 존재하지 않습니다 =-=-=");

return;

}

 

System.out.println("제목 : " + book.getTitle());

System.out.println("저자 : " + book.getWriter());

System.out.println("가격 : " + book.getPrice() + "원");

 

}

 

/**

* 입력 받은 책 제목이 포함된 모든 책 출력하기

* 단, 없으면 "조회 결과가 없습니다" 출력

*

*/

private void selectTitle() {

System.out.println("\n★☆★☆★ 책 이름으로 조회(포함) ★☆★☆★\n");

 

System.out.print("검색할 책 제목 입력 : ");

String title = sc.nextLine();

 

List<BookDTO> searchList = service.selectTitle(title);

 

// 만약 검색 결과가 없을 경우 == 비어있는 경우

// if(searchList.size() == 0) {

if(searchList.isEmpty()) {

System.out.println("=-=-= 조회 결과가 없습니다 =-=-=");

return;

}

 

// 검색 결과가 있는 경우

for(BookDTO book : searchList) {

System.out.println(book);

}

 

}

 

/**

* 입력된 글쓴이 이름이 같은 책을 모두 조회하여 출력하기

* 단, 없으면 "조회 결과가 없습니다" 출력

*/

private void selectWriter() {

System.out.println("\n★☆★☆★ 글쓴이의 이름으로 조회(포함) ★☆★☆★\n");

 

System.out.print("검색할 글쓴이 입력 : ");

String writer = sc.nextLine();

 

List<BookDTO> searchList = service.selectWriter(writer);

// 서비스에 전달할 service.selectWriter(writer) 을 먼저 쓰도록 이해하기!!

 

if(searchList.isEmpty()) {

System.out.println("=-=-= 조회 결과가 없습니다 =-=-=");

return;

}

 

// 검색 결과가 있는 경우

for(BookDTO book : searchList) {

System.out.println(book);

}

 

}

 

/**

* 검색할 가격의 범위(최소값, 최대값)을 입력받아

* 가격범위 내의 모든책을 조회하여 출력

* 단, 없으면 "조회 결과가 없습니다" 출력

*/

private void selectPrice() {

System.out.println("\n ★☆★☆★ 가격으로 조회 ★☆★☆★\n");

 

System.out.print("최소값 입력 :");

int min = sc.nextInt();

 

System.out.print("최대값 입력 :");

int max = sc.nextInt();

 

List<BookDTO> searchList = service.selectPrice(min, max);

 

if(searchList.isEmpty()) {

System.out.println("=-=-= 조회 결과가 없습니다 =-=-=");

return;

}

 

// 검색 결과가 있는 경우

for(BookDTO book : searchList) {

System.out.println(book);

}

 

}

 

/**

* 제목, 글쓴이, 가격을 입력받아

* BookService의 bookList에 추가하기

*/

public void addBook() {

System.out.println("\n★☆★☆★ 책 추가하기 ★☆★☆★\n");

 

System.out.print("제목 : ");

String title = sc.nextLine();

 

System.out.print("글쓴이 : ");

String writer = sc.nextLine();

 

System.out.print("가격 : ");

int price = sc.nextInt();

 

// 입력 받은 정보를 묶어서 Service로 전달할 수 있도록

// BookDTO 객체를 생성

BookDTO newBook = new BookDTO(title, writer, price);

 

boolean result = service.addBook(newBook);

 

if(result) {

System.out.println("***** 추가 완료 *****");

}else{

System.out.println("***** 추가 중 문제 발생 *****");

}

 

}

 

/**

* 인덱스 번호를 입력받아

*

* 1) 일치하는 인덱스가 있으면 bookList에서 제거 후

* "[책제목] 책이 목록에서 제거 되었습니다" 출력

*

* 2) 일치하는 인덱스가 없으면

* "해당 인덱스에 존재하는 책이 없습니다" 출력

*

*/

private void removeBook() {

System.out.println("\n★☆★☆★ 책 제거하기 ★☆★☆★\n");

 

System.out.println("제거할 책 인덱스 입력 :");

int index = sc.nextInt();

 

String result = service.removeBook(index);

 

if(result == null) {

System.out.println("=-=-= 해당 인덱스에 존재하는 책이 없습니다 =-=-=");

return;

 

}

 

System.out.printf("[%s] 책이 목록에서 제거 되었습니다 \n",

result);

/**

* index 변호를 입력받아

*해당 index에 책이 좋재하지 않으면

* -> "해당 인덱스에 책이 존재하지 않습니다"

* 출력 후 메서드 종료

*

* 해당 index에 책이 좋재하면

* -> 수정할 가격을 입력 후 수정

* -> "[책제목] 가격이 (이전가격) ->

* (새 가격) 수정되었습니다" 형식으로 출력

*/

 

}

private void updateBook() {

System.out.println("\n@@@@@ 책 가격 수정하기 @@@@@@\n");

 

System.out.print("수정할 책의 인덱스 입력 : ");

int index = sc.nextInt();

 

// 인덱스가 일치하는 요소의 BookDTO(참조 주소)를 반환 받기

 

// ex) index가 0인 경우

// BookService의 bookList.get(0)에 저장된 주소와

// 아래 book에 저장된 주소가 "같음"

BookDTO book = service.selectIndex(index);

 

if(book == null) {

System.out.println("해당 인덱스에 책이 존재하지 않습니다");

return;

}

// 책이 존재하면 가격 입력받기

System.out.print("수정할 가격 입력 : ");

int newPrice = sc.nextInt();

 

// 수정 전 가격을 임시변수에 저장!

int beforePrice = book.getPrice();

 

// book이 참조한 BookDTO의 가격을 newPrice로 수정

book.setPrice(newPrice);

 

// 결과출력

System.out.printf("[%s] 가격이 (%d) -> (%d)로 수정되었습니다 \n:"

,book.getTitle(), beforePrice, newPrice);

}

}

 

BookService

package list.service;

 

import java.util.ArrayList;

import java.util.List;

 

import list.dto.BookDTO;

 

// Service : 기능(비즈니스 로직)제공용 클래스

 

public class BookService {

 

// BookDTO 객체 참조 변수만을 저장하는

// ArrayList 객체 생성

// -> <BookDTO> == 제네릭(타입 제한)

private List<BookDTO> bookList = new ArrayList<BookDTO>();

 

// 기본 생성자

public BookService() {

bookList.add(new BookDTO("자바 프로그래밍 입문", "박은종", 25000));

bookList.add(new BookDTO("선재 업고 튀어 대본집 세트", "이시은", 45000));

bookList.add(new BookDTO("THE MONEY BOOK", "토스", 19800));

 

bookList.add(new BookDTO("자바의 정석", "남궁 성", 35000));

bookList.add(new BookDTO("눈물의 여왕 대본집 세트", "박지은", 60000));

bookList.add(new BookDTO("삼국지 전권 세트", "이문열", 300000));

}

 

/**

* bookList를 반환하는 서비스 메서드

* @return bookList

*/

public List<BookDTO> selectAll() {

return bookList;

}

 

/**

* bookList에 전달받은 index가 존재하면

* 해당 index번째 요소(BookDTO) 반환.

* 없으면 null 반환

* @param index

* @return bookDTO 또는 null

*/

public BookDTO selectIndex(int index) {

 

// index 범위가 bookList의 인덱스 범위 밖인 경우

if( index < 0 || index >= bookList.size()) return null;

 

// 정상 범위인 경우

return bookList.get(index);

}

 

/**

* bookList 요소의 제목중

* 전달 받은 title이 포함된 책을 모두 반환

* @param title

* @return searchList(찾은 책이 저장된 리스트)

*/

public List<BookDTO >selectTitle(String title) {

 

// 검색 결과를 저장할 List 생성

List<BookDTO> searchList = new ArrayList<BookDTO>();

 

// bookList 모든 요소 순차접근

for(BookDTO book : bookList) {

 

// 책 제목에 title이 포함되어 있을 경우

if(book.getTitle().contains(title)) {

 

searchList.add(book); // 찾은 책을 searchList에 추가

}

}

 

 

return searchList; // 검색 결과 반환

 

}

 

public List<BookDTO>selectWriter(String writer) {

 

List<BookDTO> searchList = new ArrayList<BookDTO>();

 

for(BookDTO book : bookList) {

 

// 글쓴이가 포함되는 책을 searchList에 추가

if(book.getWriter().contains(writer)) {

 

searchList.add(book);

}

 

}

 

return searchList;

 

}

 

/**

* 가격 범위 내 모든 책을 찾아서 반환

* @param min

* @param max

* @return searchList

*/

public List<BookDTO> selectPrice(int min, int max) {

 

List<BookDTO> searchList = new ArrayList<BookDTO>();

 

for(BookDTO book : bookList) {

 

int price = book.getPrice();

 

// 책의 가격이 최소~최대 사이 범위에 있을 때

if(price >= min && price <= max) {

searchList.add(book);

}

}

return searchList;

}

 

/**

* 전달 받은 newBook을 bookList에 추가

* @param newBook

* @return ture (List의 add() 구문은 무조건 성공하기 때문에)

*/

public boolean addBook(BookDTO newBook) {

return bookList.add(newBook);

}

 

/**

* 전달 받은 index요소 제거하기

* @param index

* @return null : index 범위가 맞지 않음

* 제목 : index가 정상 범위

*/

public String removeBook(int index) {

 

// 1) index가 bookList범위 내 인덱스가 맞는지 확인

if(index <0 || index >= bookList.size()) { // 범위 밖

return null;

}

 

// 2) 정상 범위인 경우 index번째 요소를 제거한 후

// "제거된 책 제목"을 반환

 

// bookList.remove(index) -> 제거된 책(bookDTO) 반환

 

// bookList.remove(index).getTitle();

// -> 제거된 책의 제목 얻어오기

 

// * method chaining : 메서드의 결과(반환값)를 이용해

// 또 다른 메서드를 호출

 

return bookList.remove(index).getTitle();

 

}

 

}

반응형