220518 - 람다식, 컬렉션 프레임워크, 자료 구조

람다식

: 익명 함수 생성하기 위한 식

: 매개 변수를 가진 코드 블록 => 인터페이스의 익명 구현 객체 생성 => 구현 클래스 생성, 객체화

 

 

• 타겟 타입, 함수적 인터페이스

람다식 대입될 인터페이스 = 람다식의 타겟 타입 (대입될 인터페이스 종류에 따라 람다식 작성 방법 다름)

 

함수적 인터페이스 (@FunctionalInterface) : 단 하나의 추상메소드 선언 (람다식 조건)

 

 

• 매개변수 X, 리턴값 X

public interface Person {
    //추상메서드
    public void info();
    
}
 
public class PersonEx1 {
 
    public static void main(String[] args) {
        //인터페이스 객체 필드 선언, 익명으로 객체 구현
        Person gildong = new Person() {
            @Override
            public void info() {
                System.out.println("나는 종로에 사는 홍길동입니다.");
                System.out.println("자바 웹개발을 배우는 중입니다.");
            }
        };
        gildong.info();
        
        //람다식 표현1
        Person chanho=()-> {
            System.out.println("나는 영등포에 사는 찬호입니다.");
            System.out.println("자바 웹개발을 배우는 중입니다.");
        };
        chanho.info();   //info 메소드 작성 안 돼도 인식 => 함수적 인터페이스 -> 메소드 하나라서
        
        //람다식 표현2 코드 한 줄 => 중괄호 필요 X
        Person minho=()-> System.out.println("나는 강남에 사는 민호입니다.");
        minho.info();
        
    }
 
}

 

 

• 매개변수 O, 리턴값 X

@FunctionalInterface
public interface Person2 {
    //추상메서드
    public void info(int age);
    
}
 
 
public class Person2Ex1 {
 
    public static void main(String[] args) {
        //매개 변수 있는 람다식
        Person2 chanho;
        
        chanho =(age)-> {
            int myAge = age+1;
            System.out.println("내 나이는 "+myAge+"세입니다.");
        };
        chanho.info(27);
        
        chanho=age-> System.out.println("내 나이는 "+(age+1)+"세입니다.");     //한 줄 -> 매개변수 괄호 없애도 됨
        chanho.info(35);
        
    }
 
}
//
내 나이는 28세입니다.
내 나이는 36세입니다.

 

• 매개변수 O, 리턴값 O

@FunctionalInterface
public interface Person3 {
    
     public String info(double height, double weight);
     
}
 
 
public class Person3Ex1 {
 
    public static void main(String[] args) {
        
        Person3 younghee =(h,w)-> {   //매개변수 이름은 개발자 자유
            String result = "내 키는 "+h+"cm이고 몸무게는 "+w+"kg입니다.";
            return result;
        };
        System.out.println(younghee.info(168, 47));
    }
 
}
//
내 키는 168.0cm이고 몸무게는 47.0kg입니다.

 

 

•  

@FunctionalInterface
public interface Calculator {
    //추상 메소드 1
    public int hap(int num1, int num2);
    
}
 
public class CalculatorEx1 {
 
    public static void main(String[] args) {
    
        Calculator cal;  //함수적 인터페이스
        
        //람다식 이용 익명 객체 구현
        cal =(a,b)-> {
            int result = a+b;
            return result;
        };
        System.out.println("두 수의 합 : "+cal.hap(3, 2));
        
        //람다식 이용 (실행할 명령문이 한 줄일 때)
        cal =(a,b)-> {return a+b;};
        System.out.println("두 수의 합 = "+cal.hap(4, 2));
        
        //람다식 이용 (실행할 명령문이 한 줄 => 리턴문, 중괄호 생략 가능)
        cal =(a,b)-> a+b;
        System.out.println("두 수의 합 = "+cal.hap(4, 3));
        
        //람다식 이용 (내부 메서드 호출해서 처리)
        cal =(a,b)-> sum(a,b);
        System.out.println("두 수의 합 : "+cal.hap(3, 6));
        
    }//main
    
    //합을 구하는 메서드
    public static int sum(int num1, int num2) {
        return num1+num2;
    }
    
}
//
두 수의 합 : 5
두 수의 합 = 6
두 수의 합 = 7
두 수의 합 : 9

 

 

• 표준 API의 함수적 인터페이스
• Supplier (매개값 X, 리턴값 O)

import java.util.function.IntSupplier;
 
public class SupplierEx1 {
    
    public static void main(String[] args) {
 
        IntSupplier supplier =()-> {  //리턴값 필요
            int num = (int) ((Math.random()*6)+1);
            return num;
        };
        System.out.println("주사위 눈의 수 : "+supplier.getAsInt());  //추상메서드
        
    }    
 
}

 

 

 

컬렉션 프레임워크

=> 유동적으로 (동적 배열 : 인덱스 수 유동적) 객체 추가, 검색, 삭제하기 위함

 

cf. 일반 배열 => 처음 선언한 만큼의 인덱스 수로 제한

 

 

• 세가지 인터페이스

1.List
1) 순서를 유지하고 저장
2) 중복 저장 가능
3) 구현클래스 - ArrayList, Vector, LinkedList,..

2. Set
1) 순서 없이 저장
2) 중복 저장 불가
3) 구현클래스 - HashSet, TreeSet

3. Map 
1) 키&값 쌍으로 저장 
2) 키는 중복 저장 안 됨 
3) 구현클래스 - HashMap, Hashtable, TreeMap

 

 

• List

1. ArrayList

•  

import java.util.ArrayList;
import java.util.List;
 
public class ArrayListEx1 {
 
    public static void main(String[] args) {
        //일반 배열
        String[] subject = new String[5];
        subject[0]="java";
        subject[1]="html";
        subject[2]="css";
        subject[3]="javascript";
        subject[4]="react";
        System.out.println("총 과목 수 : "+subject.length);
        for (int i=0;i<subject.length;i++) {
            System.out.println("과목 "+(i+1)+ " "+ subject[i]);
        }
        
        //컬렉션 프레임워크 ArrayList //배열 목록화
        List<String> subject2 = new ArrayList<String>();        
        subject2.add("java");
        subject2.add("html");
        subject2.add("css");
        subject2.add("javascript");
        subject2.add("react");
        subject2.add(2, "nodejs");  //2번째 자리에 삽입
        subject2.remove(2);  //css 삭제
        subject2.remove(2);  //javascript 삭제 => 뒷자리는 빈 배열 됨
        subject2.remove("react");
        System.out.println("총 과목 수 : "+subject2.size());  
        for (int i=0;i<subject2.size();i++) {  
            System.out.println("과목 "+(i+1)+ " "+ subject2.get(i));  
        }        
    }
 
}
//
총 과목 수 : 3
과목 1 java
과목 2 html
과목 3 javascript

 

 

•  

import java.util.Arrays;
import java.util.List;
 
public class ArrayListEx2 {
 
    public static void main(String[] args) {
        //배열의 초기화
        String[] names = {"홍길동","김철수","이영희","박찬호","손흥민"};  
        
        //List 인터페이스의 구현클래스 ArrayList의 초기화 -> add, remove X 
        List<String> names2 = Arrays.asList("홍길동","김철수","이영희","박찬호","손흥민");
        //고정된 객체들로 구성된 List 생성 
        for (String n:names) {
            System.out.println(n);
        }
        
        List<Integer> nums2 = Arrays.asList(10,20,30);
        for (int num:nums2) {  //자동언박싱
            System.out.println(num);
        } 
        
    }
 
}

 

 

2. Vector

=> 동기화 메소드로 구성됨 => 멀티스레드가 메소드들 동시 실행 X => 안전한 스레드

 

 

public class Board {
 
    String subject;
    String content;
    String writer;
    
    public Board(String subject, String content, String writer) {
    
        this.subject=subject;
        this.content=content;
        this.writer=writer;
        
    }
    
}
 
 
import java.util.List;
import java.util.Vector;
 
public class VectorEx1 {
 
    public static void main(String[] args) {
 
        List<Board> list = new Vector<Board>();
        list.add(new Board("코로나", "코로나 확진 시 격리 1주","홍길동"));
        list.add(new Board("자바황용", "5/20 시험(변수~참조)", "김철수"));
        list.add(new Board("자바구현", "프론트엔드 시작 전 자바 구현 : 스마트폰", "이영희"));
        //list.remove(1);
        for (int i=0;i<list.size();i++) {
            Board board = list.get(i);
            System.out.println("제목 : "+board.subject);
            System.out.println("내용 : "+board.content);
            System.out.println("글쓴이 : "+board.writer);
            System.out.println("---------------------");
 
        }
        
    }
 
}
//
제목 : 코로나
내용 : 코로나 확진 시 격리 1주
글쓴이 : 홍길동
---------------------
제목 : 자바황용
내용 : 5/20 시험(변수~참조)
글쓴이 : 김철수
---------------------
제목 : 자바구현
내용 : 프론트엔드 시작 전 자바 구현 : 스마트폰
글쓴이 : 이영희
---------------------

 

 

3. LinkedList

: 내부값들은 앞 뒤 값들 모두 연결해 갖고 있음 = 인접참조 링크해 체인처럼 관리

=> 특정 인덱스 객체 제거 시 앞뒤 링크만 변경됨

 

=> ArrayList와 유사
=> 삽입, 삭제 ☆빈번할 때 성능 좋음 / 빈번 X => 더 느림
=> 메모리 사용 많이 함

cf. ArrayList : 제거 시 뒤의 객체 인덱스 모두 1씩 당겨짐

 

 

•  

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
 
 
public class LinkedListEx1 {
 
    public static void main(String[] args) {
 
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new LinkedList<String>();
        
        long startTime;
        long endTime;
        
        startTime=System.nanoTime();
        for (int i=0;i<10000;i++) {
            list1.add(0, String.valueOf(i));  
            //int->String  //0 자리에 문자 삽입해서 뒤 문자들 계속 밀려나도록
        }
        endTime=System.nanoTime();
        System.out.println("ArrayList 시간 : "+ (endTime-startTime)+"ns");
        
        startTime=System.nanoTime();
        for (int i=0;i<10000;i++) {
            list2.add(0, String.valueOf(i));
        }
        endTime=System.nanoTime();
        System.out.println("LinkedList 시간 : "+ (endTime-startTime)+"ns");
        
    }
 
}
//
ArrayList 시간 : 5326500ns
LinkedList 시간 : 1404200ns => 더 빠름

 

 

• Set

Set = 집합 => 인덱스값 없으므로 get(), for 반복문 사용 불가

 

 

1. HashSet

• Iterator 통해 출력

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class HashSetEx1 {
 
    public static void main(String[] args) {
 
        Set<String> set1 = new HashSet<String>();
        set1.add("java"); 
        set1.add("html");
        set1.add("css");
        set1.add("react");
        set1.add("java"); //중복 제외됨
        set1.remove("css"); 
        
        System.out.println("총 자료 수 : "+set1.size()); 
        Iterator<String> iter = set1.iterator();  //get => Iterator 사용
        while(iter.hasNext()) {  //자료 있으면 true
            System.out.println(iter.next());  //한 객체 꺼냄
        }
        
    }
 
}
//
총 자료 수 : 3 =>중복 제외
java
html
react

 

 

2. TreeSet

=> 족보와 유사
=> 검색 강화 위한 컬렉션


  70
  |   |   
62   95
 |     |  |
67  88  98
     |
    80

=> 첫숫자 기준으로 
=> 가장 큰 숫자 : 맨오른쪽 / 가장 작은 숫자 : 맨왼쪽

 

 

• TreeSet 메소드 => 정렬, 출력

import java.util.TreeSet;
 
public class TreeSetEx1 {
 
    public static void main(String[] args) {
 
        TreeSet<Integer> scores = new TreeSet<Integer>();//TreeSet 검색 메소드 사용 위해 TreeSet타입으로 대입
        scores.add(70);
        scores.add(95);
        scores.add(62);
        scores.add(88);
        scores.add(80);
        scores.add(67);
        scores.add(98);
        
        System.out.println("가장 높은 점수 : "+scores.last());  //last : 가장 높은
        System.out.println("가장 낮은 점수 : "+scores.first());  //first : 가장 낮은
        System.out.println("88 아래 점수 : "+scores.lower(88));
        System.out.println("88 위 점수 : "+scores.higher(88));
 
        int jumsu;
        while(!scores.isEmpty()) {
            jumsu = scores.pollFirst(); //제일 작은 숫자 꺼냄
            System.out.println("꺼낸 점수 : "+jumsu);
            System.out.println("남은 자료 수 : "+scores.size());
        }
    
    }
 
}
//
가장 높은 점수 : 98
가장 낮은 점수 : 62
88 아래 점수 : 80
88 위 점수 : 95
 
꺼낸 점수 : 62
남은 자료 수 : 6
꺼낸 점수 : 67
남은 자료 수 : 5
꺼낸 점수 : 70
남은 자료 수 : 4
꺼낸 점수 : 80
남은 자료 수 : 3
꺼낸 점수 : 88
남은 자료 수 : 2
꺼낸 점수 : 95
남은 자료 수 : 1
꺼낸 점수 : 98
남은 자료 수 : 0

 

 

• NavigableSet 통해 검색, 출력

import java.util.NavigableSet;
import java.util.TreeSet;
 
public class TreeSetEx2 {
 
    public static void main(String[] args) {
 
        TreeSet<String> tree1 = new TreeSet<String>();
        tree1.add("bear");
        tree1.add("student");
        tree1.add("banana");
        tree1.add("car");
        tree1.add("tree");
        tree1.add("forever");
        tree1.add("cherry");
        tree1.add("fruit");
        
        System.out.println("b~f 단어 검색");
        NavigableSet<String> rangeSet =  tree1.subSet("b", true, "g", true);
        //NavigableSet 인터페이스의 메소드 subset 사용 => 정렬, 검색
        //(시작 객체, 시작 객체 존재 여부, 마지막 객체, 마지막 객체 존재 여부)
        for (String word:rangeSet) {
            System.out.println(word);
        }
    }
 
}
//
b~f 단어 검색
banana
bear
car
cherry
forever
fruit

 

 

• Map

1. HashMap

• Iterator 이용해 value 출력

○ Set.keySet(), Iterator 이용해 value 출력
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class HashMapEx1 {
 
    public static void main(String[] args) {
 
        Map<String, Integer> map1 = new HashMap<String, Integer>();
        map1.put("김철수", 90);  //중복 없는 값으로 key 지정 추천
        map1.put("홍길동", 70);
        map1.put("이영희", 97);
        map1.put("박찬호", 85);
        map1.put("손흥민", 77);
        
        System.out.println("총 자료 수 : "+map1.size());
        //System.out.println(map1.get("박찬호"));
        Set<String> keySet = map1.keySet();  //Iterator 사용 위해 Set 타입에 대입
        Iterator<String> iter = keySet.iterator();  //Iterator : Set 안 원소 출력 위한 클래스
        while (iter.hasNext()) {
            System.out.println(map1.get(iter.next())); //key 통해 value 가져옴
        }
        
    }
 
}
//
총 자료 수 : 5
70
77
97
85
90
 
 
○ value 값 모두 출력
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class HashMapEx1 {
 
    public static void main(String[] args) {
 
        Map<String, Integer> map1 = new HashMap<String, Integer>();
        map1.put("김철수", 90);  //중복 없는 값으로 key 대입 추천
        map1.put("홍길동", 70);
        map1.put("이영희", 97);
        map1.put("박찬호", 85);
        map1.put("손흥민", 77);
        
        System.out.println("총 자료 수 : "+map1.size());
        //System.out.println(map1.get("박찬호"));
        Set<String> keySet = map1.keySet(); 
        Iterator<String> iter = keySet.iterator();
        while (iter.hasNext()) {
            String key = iter.next(); //key 값 
            Integer score = map1.get(key); //value 값
            System.out.println(key + " : "+ score); //key 통해 value 가져옴
        }
        
    }
 
}
//
총 자료 수 : 5
홍길동 : 70
손흥민 : 77
이영희 : 97
박찬호 : 85
김철수 : 90

 

 

• Map.entry, Iterator 이용해 key, value 출력

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class HashMapEx1 {
 
    public static void main(String[] args) {
 
        Map<String, Integer> map1 = new HashMap<String, Integer>();
        map1.put("김철수", 90); 
        map1.put("홍길동", 70);
        map1.put("이영희", 97);
        map1.put("박찬호", 85);
        map1.put("손흥민", 77);
        
        System.out.println("총 자료 수 : "+map1.size());
        //System.out.println(map1.get("박찬호"));
 
 
        /*Set<String> keySet = map1.keySet();  //전체 key 가져옴
        Iterator<String> iter = keySet.iterator();
        while (iter.hasNext()) {
            String key = iter.next();  //key 값 문자열에 넣음
            Integer score = map1.get(key);  //value 값
            System.out.println(key + " : "+ score); //key 통해 value 가져옴
        }
        //map1.remove("이영희");*/
 
 
        Set<Map.Entry<String, Integer>> entrySet = map1.entrySet();
        //entrySet() : 자료 가져옴 (해당 map의 key와 value를 가지는 Set 객체 리턴)
        Iterator<Map.Entry<String, Integer>> iter = entrySet.iterator();
        //Iterator : Set 의 자료 가져옴
        while (iter.hasNext()) {
            Map.Entry<String, Integer> entry = iter.next();
            String key = entry.getKey(); //Map.Entry 메소드
            Integer score = entry.getValue();
            System.out.println(key + " : "+score);
        }
        
        
    }
 
}
//
총 자료 수 : 5
홍길동 : 70
손흥민 : 77
이영희 : 97
박찬호 : 85
김철수 : 90

 

 

2. Hashtable

=> 동기화 메소드로 구성돼 하나의 스레드 실행 완료한 후 다른 스레드 실행

 

 

•  

import java.util.Hashtable;
import java.util.Map;
import java.util.Scanner;
 
public class HashtableEx1 {
 
    public static void main(String[] args) {
 
        Map<String, String> map1 = new Hashtable<String, String>();
        map1.put("hong", "12345");
        map1.put("chanho", "77777");
        map1.put("young", "22222");
        map1.put("son", "33333");
        map1.put("park", "11111");
        
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.println("아이디 비밀번호 입력해주세요");
            System.out.print("아이디>> ");
            String id = sc.next();
            System.out.print("비밀번호>> ");
            String pass = sc.next();
            if (map1.containsKey(id)) {  //Key값인 id 존재 여부 확인
                if (map1.get(id).equals(pass)){   //id 상응하는 기존 value 값들 - 입력한 pass 값 비교
                    System.out.println("로그인 성공");
                    break;
                } else {
                    System.out.println("비밀번호 존재하지 않음");
                }
            }else {
                System.out.println("입력한 아이디 존재 X");
            }
        }//while
        
    }
 
}
//
아이디 비밀번호 입력해주세요
아이디>> son
비밀번호>> 33333
로그인 성공

 

 

3. Treemap

 

    5
    |  |
   3   7
        |  |
       8  10

 

import java.util.Map;
import java.util.TreeMap;
 
public class TreeMapEx1 {
 
    public static void main(String[] args) {
 
        TreeMap<Integer, String> mapList = new TreeMap<Integer, String>();
        mapList.put(5, "홍길동");
        mapList.put(7, "김철수");
        mapList.put(10, "이영희");
        mapList.put(3, "손흥민");
        mapList.put(8, "박찬호");
 
        Map.Entry<Integer, String> entry=null;
        entry = mapList.firstEntry();  //가장 낮은 값
        System.out.println("가장 낮은 번호 : "+entry.getKey()+" ☞ "+entry.getValue());
        entry = mapList.lastEntry();  //가장 높은 값
        System.out.println("가장 높은 번호 : "+entry.getKey()+" ☞ "+entry.getValue());
        
        while(!mapList.isEmpty()) {
        entry = mapList.pollFirstEntry();
        System.out.print(entry.getKey()+" ☞ "+entry.getValue());
        System.out.println(" (남은 자료 수 : "+mapList.size()+")");
        }        
            
    }
 
}
//
가장 낮은 번호 : 3 ☞ 손흥민
가장 높은 번호 : 10 ☞ 이영희
 
3 ☞ 손흥민 (남은 자료 수 : 4)
5 ☞ 홍길동 (남은 자료 수 : 3)
7 ☞ 김철수 (남은 자료 수 : 2)
8 ☞ 박찬호 (남은 자료 수 : 1)
10 ☞ 이영희 (남은 자료 수 : 0)

 

 

 

자료 구조

1. 스택 (Stack) - FILO (first in last out : 먼저 들어가면 나중에 나옴)
ex. 컵 밑 바닥부터 쌓임 - 가장 나중에 들어간 값이 제일 먼저 나옴
=> 메소드에서 다른 메소드 호출할 때

=> a 실행하다 b 호출(a 실행시점을 스택에 저장), b 실행하다 c 호출(b 실행시점 스택에 저장), c 실행 끝나면 금방 했던 b 실행지점으로 복귀, b 실행 끝나면 a 실행지점으로 복귀

2. 큐 (Queue) - FIFO (first in first out : 먼저 들어가면 먼저 나옴)
ex. 통로 - 들어간 순서대로 나감
=> 부팅 (컴퓨터 켜진 후 모든 프로그램 실행 대기 완료일 때) 

=> 켜지자마자 이것저것 누르면 부팅 완료 후 순서대로 실행 됨

 

 

•  

public class BookBox {
 
    private String book;
 
    public BookBox(String book) {
        this.book=book;
    }
    
    public String getBook() {
        return book;
    }
    
}
 
 
import java.util.Stack;
 
public class StackEx1 {
 
    public static void main(String[] args) {
 
        Stack<BookBox> box = new Stack<BookBox>();
        box.push(new BookBox("java"));
        box.push(new BookBox("html"));
        box.push(new BookBox("nodejs"));
        box.push(new BookBox("react"));
        
        while(!box.isEmpty()) {
            BookBox a = box.pop();
            System.out.println("꺼낸 책 : "+a.getBook());
        }
 
    }
 
}
//
꺼낸 책 : react
꺼낸 책 : nodejs
꺼낸 책 : html
꺼낸 책 : java