개발일지 -HashMap , 상속 클래스-

HashMap

• Key, Value의 쌍으로 구성된 데이터 구조
• Key 값을 이용하여 데이터에 접근할 수 있음
• Key 값은 정수, 문자 등 다양한 타입으로 지정 가능
  1. 선언 문법

Map<Key타입, Value타입> [map 객체이름] = new HashMap<>();

// Key 가 정수, Value가 String 이라면
Map<Integer , String> map1 = new HashMap<>();

//Key가 long Value 가 MemberDTO라면
Map<Long , MemberDTO> map2 = new HashMap<>();

1. map에 데이터 저 저장

a. put(): 데이터 저장

put(key 이름 , 저장할 데이터);

 

b. get(): 데이터 꺼내기

map이름.get(key이름);

 

c. remove(): 삭제

map이름.remove(key이름);

1. 반복문으로 map 데이터 접근
   1. key로 이루어진 Set 객체를 만들고 이를 반복문으로 접근한 뒤 반복문 안에서 get() 활용

// Key 가 정수, Value가 String 이라면
Map<Integer , String> map1 = new HashMap<>();

// map1에 반복문 적용
for(Integer i : map.keySet()){
System.out.println(map1.get(i));
}

 

<예문>

package ch13_map;

import java.util.HashMap;
import java.util.Map;

public class Ex01_MapBasic {
    public static void main(String[] args) {
        // key: 정수(int) , value: String
        Map<Integer, String> map1 = new HashMap<>();
        map1.put(1, "안녕");
        map1.put(2, "hello");
//        map1.put(3, 100); // value 타입 불일치
//        map1.put("4","안녕하세요"); // key 타입 불일치
        //key가 1인 데이터
        System.out.println(map1.get(1));
        String s1 = map1.get(2);
        System.out.println("s1 = " + s1);
        map1.put(100, "ㅎㅎㅎㅎㅎ");
        // 동일한 키에 다른 데이터를 넣는다면
        map1.put(1, "안녕하십니까");
        System.out.println(map1.get(1));
        // 반복문으로 접근
        for (Integer i : map1.keySet()) {
            System.out.println("i = " + i);
        }
        // key:String , value: Sting
        Map<String, String> map2 = new HashMap<>();
        map2.put("가", "안녕");
        map2.put("나", "ㅎㅎㅎ");
        map2.put("a", "ㅋㅋㅋ");
        System.out.println(map2.get("a"));

        //반복문
        for (String s : map2.keySet()) {
            System.out.println(map2.get(s));
        }
        
        Map<Long , String> map3 = new HashMap<>();
        String ss1 = map3.put(1L , "안녕");
        System.out.println("ss1 = " + ss1);
        String ss2 = map3.put(2L , "hello");
        System.out.println("ss2 = " + ss2);
        String ss3 = map3.put(1L , "안녕하세요");
        System.out.println("ss3 = " + ss3);
    }
}

HashMap은 ArrayList와 비슷하지만 다른 점은 데이터 저장 방식이다

HashMap은 키 - 값 쌍으로 데이터를 저장하고 키는 데이터를 식별하는 데 사용하는 고유한 값이고 값은 키에 해당하는 데이터이고

 

arrayList는 순차적으로 데이터 값을 저장하게된다 각 데이터는 인덱스가 할당되어 있으며 인덱스를 사용하여 데이터에 접근할 수 있다

 

HashMap은 키를 사용하여 데이터에 바로 접근을 할 수 있지만 ArrayList는 인덱스를 사용하여 데이터에 접근해야 하므로 HashMap에 비해 검색 성능이 떨어지고 HashMap은 데이터를 추가하거나 삭제하면 테이블의 인덱스를 조정할 필요가 없기 때문에 arrayList 보다 성능이 더 좋다

 

arrayList는 순차적으로 데이터를 저장하고 검색하는데 적절하고

HashMap은 키와 값을 저장하고 검색하는데 적합하다

 

HashMap은

• 이름과 나이를 저장하는 경우
• 상품 코드와 상품 정보를 저장하는 경우
• URL과 페이지 내용을 저장하는 경우

에 적합하고

 

ArrayList는

• 숫자 목록을 저장하는 경우
• 문자열 목록을 저장하는 경우
• 물품 목록을 저장하는 경우

에 적합하다

 

 

 

<예제> 도서등록을 HashMap을 이용하여 구현

 

-DTO-

package ch13_map.ex02;
public class BookDTO {

    private Long id;
    private String bookTitle;
    private String bookAuthor;
    private int bookPrice;
    private String bookPublisher;

    public void setId(Long id) {
        this.id = id;
    }

    public void setBookTitle(String bookTitle) {
        this.bookTitle = bookTitle;
    }

    public void setBookAuthor(String bookAuthor) {
        this.bookAuthor = bookAuthor;
    }

    public void setBookPrice(int bookPrice) {
        this.bookPrice = bookPrice;
    }

    public void setBookPublisher(String bookPublisher) {
        this.bookPublisher = bookPublisher;
    }

    public Long getId() {
        return id;
    }

    public String getBookTitle() {
        return bookTitle;
    }

    public String getBookAuthor() {
        return bookAuthor;
    }

    public int getBookPrice() {
        return bookPrice;
    }

    public String getBookPublisher() {
        return bookPublisher;
    }

    public BookDTO(){

    }
    private static Long idValue=1L;

    public BookDTO (String bookTitle , String bookAuthor , int bookPrice , String bookPublisher){
        this.id =idValue++;
        this.bookTitle = bookTitle;
        this.bookAuthor = bookAuthor;
        this.bookPrice = bookPrice;
        this.bookPublisher = bookPublisher;
    }

    @Override
    public String toString() {
        return "BookDTO{" +
                "id=" + id +
                ", bookTitle='" + bookTitle + '\'' +
                ", bookAuthor='" + bookAuthor + '\'' +
                ", bookPrice='" + bookPrice + '\'' +
                ", bookPublisher='" + bookPublisher + '\'' +
                '}';
    }
}

 

-Main-

package ch13_map.ex02;


import java.util.Scanner;
public class BookMain {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        boolean run = true;
        int selectNo = 0;
        // bookService 클래스 객체 선언
        BookService bookService = new BookService();
        while (run) {
            System.out.println("-----------------------------------------------------------------------------------------");
            System.out.println("1.도서등록 | 2.도서목록 | 3.도서조회(id) | 4.도서조회(제목) | 5.가격수정 | 6.도서삭제 | 7.도서검색 | 0.종료");
            System.out.println("-----------------------------------------------------------------------------------------");
            System.out.print("선택> ");
            selectNo = scan.nextInt();
            if (selectNo == 1) {
                // 호출하는 문장 작성
                System.out.println("도서를 등록하세요");
                bookService.save();
            } else if (selectNo == 2) {
                // 호출하는 문장 작성
                bookService.findAll();
            } else if (selectNo == 3) {
                // 호출하는 문장 작성
                bookService.findById();
            } else if (selectNo == 4) {
                // 호출하는 문장 작성
//                bookService.findByTitle();
            } else if (selectNo == 5) {
                // 호출하는 문장 작성
                bookService.update();
            } else if (selectNo == 6) {
                // 호출하는 문장 작성
                bookService.delete();
            } else if (selectNo == 7) {
                bookService.search();
            } else if (selectNo == 0) {
                run = false;
            }
        }
    }
}

 

-Repository-

package ch13_map.ex02;

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

public class BookRepository {
    private  static Map<Long , BookDTO> bookDTOMap = new HashMap<>();
    public boolean save(BookDTO bookDTO) {
        System.out.println("bookDTO = " + bookDTO);
       BookDTO dto =  bookDTOMap.put(bookDTO.getId(), bookDTO);
        System.out.println("dto = " + dto);
        if (dto == null){
            return true;
        }else {
            return false;
        }
    }

    public Map<Long, BookDTO> findAll() {
        return bookDTOMap;
    }

    public BookDTO findById(Long id) {
        for (Long i:bookDTOMap.keySet()){
            if (id.equals(bookDTOMap.get(i).getId())){
                return bookDTOMap.get(i);
            }
        }
        return null;
    }

    public boolean update(Long id, int bookPrice) {
        for (Long i: bookDTOMap.keySet()){
            if (id.equals(bookDTOMap.get(i).getId())){
                bookDTOMap.get(i).setBookPrice(bookPrice);
                return true;
            }
        }
        return false;
    }

    public boolean delete(Long id) {
        for (Long i: bookDTOMap.keySet()){
            if (id.equals(bookDTOMap.get(i).getId())){
                bookDTOMap.remove(i);
            }
        }
        return false;
    }

    public List<BookDTO> sarch(String bookTitle) {
        //검색 결과를 담을 list 선언
        List<BookDTO> bookDTOList = new ArrayList<>();
        for (Long i: bookDTOMap.keySet()){
            if (bookDTOMap.get(i).getBookTitle().contains(bookTitle)){
                bookDTOList.add(bookDTOMap.get(i));
            }
        }
        return bookDTOList;
    }
}

 

-Service-

package ch13_map.ex02;

import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class BookService {
    BookRepository bookRepository = new BookRepository();
    Scanner scanner = new Scanner(System.in);
    public void save() {
        System.out.print("제목: ");
        String bookTitle = scanner.next();
        System.out.print("저자: ");
        String bookAuthor = scanner.next();
        System.out.print("가격: ");
        int bookPrice = scanner.nextInt();
        System.out.print("출판사: ");
        String bookPublisher = scanner.next();
        BookDTO bookDTO = new BookDTO(bookTitle,bookAuthor,bookPrice,bookPublisher);
        boolean result =  bookRepository.save(bookDTO);
        if (result){
            System.out.println("등록 성공");
        }else {
            System.out.println("등록 실패");
        }
    }

    public void findAll() {
        Map<Long , BookDTO> bookDTOMap = bookRepository.findAll();
        for(Long i: bookDTOMap.keySet()){
            System.out.println(bookDTOMap.get(i));
            //도서 제목만 본다면
            System.out.println(bookDTOMap.get(i).getBookTitle());
        }
    }

    public void findById() {
        System.out.println("조회할 id: ");
        Long id =scanner.nextLong();
        BookDTO bookDTO = bookRepository.findById(id);
        if (bookDTO != null){
            System.out.println("bookDTO = " + bookDTO);
        }else {
            System.out.println("요청하신 정보를 찾을 수 없습니다");
        }
    }

    public void update() {
        System.out.println("수정할 id: ");
        Long id =scanner.nextLong();
        BookDTO bookDTO = bookRepository.findById(id);
        if (bookDTO != null){
            System.out.println("수정할 가격: ");
            int bookPrice =scanner.nextInt();
            boolean updateResult = bookRepository.update(id , bookPrice);
            if (updateResult){
                System.out.println("수정 성공");
            }else {
                System.out.println("수정 실패");
            }
        }else {
            System.out.println("요청하신 정보를 찾을 수 없습니다");
        }
    }

    public void delete() {
        System.out.println("삭제할 id: ");
        Long id =scanner.nextLong();
        boolean result = bookRepository.delete(id);
        if (result){
            System.out.println("삭제 성공");
        }else {
            System.out.println("삭제 실패");
        }
    }

    public void search() {
        System.out.println("검색어: ");
        String bookTitle = scanner.next();
        List<BookDTO> bookDTOList = bookRepository.sarch(bookTitle);
        if (bookDTOList.size()>0){
            for (BookDTO bookDTO:bookDTOList){
                System.out.println("bookDTO = " + bookDTO);
            }
        }else {
            //bookDTOList.size() == 0 => 결과가 없다
            System.out.println("검색 결과가 없습니다");
        }
    }
}

 

<예제 2> HashMap을 이용하여 회원관리 구현

-Main-

package ch13_map.ex03;

import java.util.Scanner;

public class MemberMain {

    public static void main(String[] args) {
        MemberService memberService = new MemberService();

        Scanner scanner = new Scanner(System.in);
        int selecNo = 0;
        boolean run = true;
        while (run){
            System.out.println("1.회원가입 | 2.로그인 | 3.회원 목록 조회 | 4.회원 정보 수정 | 5.회원탈퇴 | 6.로그아웃 | 0.종료");
            selecNo = scanner.nextInt();
            if (selecNo == 1){
                memberService.memberJoin();
            } else if (selecNo == 2) {
                memberService.memberLogin();

            } else if (selecNo == 3) {
                memberService.findAll();

            } else if (selecNo == 4) {
                memberService.memberUpdate();

            } else if (selecNo == 5) {
                memberService.memberDelete();

            } else if (selecNo == 6) {
                memberService.memberLogout();
            } else if (selecNo == 0) {
                System.out.println("종료합니다");
                break;
            }
        }
    }
}

 

-Service-

package ch13_map.ex03;
import java.util.Map;
import java.util.Scanner;
public class MemberService {
    private static String loginEmail = null;
    Scanner scanner = new Scanner(System.in);
    MemberRepository memberRepository = new MemberRepository();

    public void memberJoin() {
        // 중복체크 결과를 담을 변수
        boolean checkResult = false;
        String memberEmali = null;
        do {
            System.out.print("이메일: ");
            memberEmali = scanner.next();
            // checkReslt 가 true 라면 사용가능(반복문 종료), checkResult 가 false 라면 사용불가(다시 이메일 입력)
            checkResult = MemberRepository.emailChack(memberEmali);
            if (checkResult) {
                System.out.println("사용가능한 이메일 입니다");
            } else {
                System.out.println("이미 사용중인 이메일 입니다");
            }
        } while (!checkResult);//checkResult 값이 false 라면 계속 반복되도록
        System.out.print("비밀 번호: ");
        String memberPassword = scanner.next();
        System.out.print("이름: ");
        String memberName = scanner.next();
        System.out.print("전화번호: ");
        String memberMobile = scanner.next();
        MemberDTO memberDTO = new MemberDTO(memberEmali, memberPassword, memberName, memberMobile);
        boolean result = MemberRepository.memberJoin(memberDTO);
        if (result) {
            System.out.println("등록 성공");
        } else {
            System.out.println("등록 실패");
        }
    }

    public void memberLogin() {
        System.out.print("이메일: ");
        String memberEmail = scanner.next();
        System.out.print("비밀번호: ");
        String memberPassword = scanner.next();
        MemberDTO loginResult = memberRepository.memberLogin(memberEmail, memberPassword);
        if (loginResult != null) {
            System.out.println("로그인 성공");
            loginEmail = memberEmail;
        } else {
            System.out.println("로그인 실패");
        }
    }

    public void findAll() {
        Map<Long, MemberDTO> memberDTOMap = memberRepository.findAll();
        for (Long i : memberDTOMap.keySet()) {
            System.out.println(memberDTOMap.get(i));
            System.out.println(memberDTOMap.get(i).getMemberEamil());
        }
    }

    public void memberUpdate() {
        if (loginEmail != null){
            System.out.print("수정할 전화번호: ");
            String memberMobile = scanner.next();
            boolean updateResult = memberRepository.memberUpdate(loginEmail , memberMobile);
            if (updateResult){
                System.out.println("수정 성공");

            }else {
                System.out.println("수정 실패");

            }
        }else {
            System.out.println("로그인을 실행하세요");
        }
    }

    public void memberDelete() {
        if (loginEmail != null){
            System.out.println("탈퇴하시겠습니까?");
            System.out.print("비밀 번호: ");
            String memberPassword = scanner.next();
            MemberDTO memberDTO=memberRepository.memberLogin(loginEmail,memberPassword);
            if (memberDTO != null){
                boolean result = memberRepository.memberDelete(loginEmail);
                if (result){
                    System.out.println("탈퇴 되었습니다");
                }else {
                    System.out.println("탈퇴가 처리되지 않았습니다");
                }
            }
        }else {
            System.out.println("로그인 해주세요");
        }
    }

    public void memberLogout() {
        loginEmail = null;
        System.out.println("로그아웃 되었습니다");
    }
}

 

-Repository-

package ch13_map.ex03;

import java.util.HashMap;
import java.util.Map;

public class MemberRepository {
    private static Map<Long , MemberDTO> memberDTOMap = new  HashMap<>();
    public static boolean emailChack(String memberEmali) {
        boolean result = true;
        for (Long i: memberDTOMap.keySet()){
            if (memberEmali.equals(memberDTOMap.get(i).getMemberEamil())){
                result = false;
            }
        }
        return result;
    }

    public static boolean memberJoin(MemberDTO memberDTO) {
        MemberDTO dto = memberDTOMap.put(memberDTO.getId() , memberDTO);
        System.out.println("dto = " + dto);
        if (dto == null){
            return true;
        }else {
            return false;
        }
    }

    public MemberDTO memberLogin(String memberEmail, String memberPassword) {
        MemberDTO result = null;
        for (Long i: memberDTOMap.keySet()){
            if (memberEmail.equals(memberDTOMap.get(i).getMemberEamil()) && memberPassword.equals(memberDTOMap.get(i).getMemberPassword())){
                result = memberDTOMap.get(i);
            }
        }
        return result;
    }

    public Map<Long, MemberDTO> findAll() {
        return memberDTOMap;
    }

    public boolean memberUpdate(String loginEmail, String memberMobile) {
        boolean result = false;
        for (Long i: memberDTOMap.keySet()){
            if (loginEmail.equals(memberDTOMap.get(i).getMemberEamil())){
                memberDTOMap.get(i).setMemberMobile(memberMobile);
                result = true;
            }
        }
        return result;
    }

    public boolean memberDelete(String loginEmail) {
        boolean result = false;
        for (Long i: memberDTOMap.keySet()){
            if (loginEmail.equals(memberDTOMap.get(i).getMemberEamil())){
                memberDTOMap.remove(i);
                result = true;
            }
        }
        return result;
    }
}

 

-DTO-

package ch13_map.ex03;

public class MemberDTO {
        private  Long id;
        private String memberEamil;
        private String memberPassword;
        private String memberName;
        private String memberMobile;

        public void setId(Long id) {
            this.id = id;
        }

        public void setMemberEamil(String memberEamil) {
            this.memberEamil = memberEamil;
        }

        public void setMemberPassword(String memberPassword) {
            this.memberPassword = memberPassword;
        }

        public void setMemberName(String memberName) {
            this.memberName = memberName;
        }

        public void setMemberMobile(String memberMobile) {
            this.memberMobile = memberMobile;
        }

        public Long getId() {
            return id;
        }

        public String getMemberEamil() {
            return memberEamil;
        }

        public String getMemberPassword() {
            return memberPassword;
        }

        public String getMemberName() {
            return memberName;
        }

        public String getMemberMobile() {
            return memberMobile;
        }
        public MemberDTO(){

        }

        private static Long idValue = 1L;
        public MemberDTO(String memberEamil , String memberPassword , String memberName , String memberMobile){
            this.id = idValue++;
            this.memberEamil = memberEamil;
            this.memberPassword = memberPassword;
            this.memberName = memberName;
            this.memberMobile = memberMobile;
        }

        @Override
        public String toString() {
            return "memberDTO{" +
                    "id=" + id +
                    ", memberEamil='" + memberEamil + '\'' +
                    ", memberPassword='" + memberPassword + '\'' +
                    ", memberName='" + memberName + '\'' +
                    ", memberMobile='" + memberMobile + '\'' +
                    '}';
        }
    }

 

상속(Inheritance)

• 부모 클래스의 자원(필드, 생성자, 메서드)을 자식 클래스에게 물려주는 것
  • 물려준다고 해서 부모 자원이 사라지는 것은 아님
  • 부모 클래스에서 private 으 로 지정한 자원은 상속 불가
• • 동시에 두 개 이상의 클래스 상속 불가
  • 메서드 재정의(method overriding)
    • 부모가 가진 메서드의 실행블록을 수정하는 것
    • 메서드 정의 부분(리턴타입, 이름, 매개변수)은 수정 불가
  1. 문법
     1. extends 키워드 사용

// 부모 클래스
public class ParentClass{

}
// 자식 클래스
public class ChilClass extends ParentClass {

}

 

<예문>

package ch14_inheritance;

public class inheritanceMain {
    public static void main(String[] args) {
    ParentClass parentClass = new ParentClass();
        parentClass.setName("이름");
        parentClass.setAge(10);
        System.out.println("parentClass = " + parentClass);
        parentClass.hello();

        ChildClass childClass = new ChildClass();
        childClass.setName("자식이름1");
        childClass.setAge(100);
        System.out.println("childClass = " + childClass);
        childClass.hello();

        // 좌변: 부모타입의 객체, 우변: 자식 클래스의 생성자
        ParentClass parentClass1 = new ChildClass();
        parentClass1.hello();
        parentClass1 = new ParentClass();
        parentClass1.hello();;
        // 좌변: 자식 타입의 객체 , 우변: 부모클래스 생성자
//        ChildClass childClass1 = new ParentClass();
    }

}

 

package ch14_inheritance;

public class ParentClass {
    public String name;

    private int age;

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    ParentClass(){
        System.out.println("부모 기본생성자");
    }

    public void hello(){
        System.out.println("ParentClass.hello");
    }

    @Override
    public String toString() {
        return "ParentClass{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

package ch14_inheritance;

public class ChildClass extends ParentClass{
    public ChildClass(){
        System.out.println("자식 기본생성자");
    }

    // 메서드의 재정의
    @Override
    public void hello(){
        System.out.println("ChildClass.hello");
    }
}

 

상속에서 가장 중요한 부분은 코드의 재사용성이다 상속을 통해 기존에 정의된 클래스의 멤버를 그대로 사용할 수 있음으로 코드의 중복을 줄이고 유지보수의 효율성을 높일 수 있다