Java 문법 종합 2주차-2

배열

• Java 프로그래밍에서 여러 개의 변수를 분류통 같은 곳에 모아서 저장하고 싶을 때 "배열"이라는 변수에 저장함. 여러 개의 값들을 한 꺼번에 넣거나 하나씩 넣을 수도 있고, 꺼낼 때는 하나씩 꺼낼 수 있음
• 분류통은 자료구조라고 불림

 선언 [ ]

• int 와 같은 기본형 변수는 1개의 값만 저장할 수 있다면, int[ ] 같은 배열형 변수는 여러 개를 변수에 저장할 수 있음
  • 하나의 배열형 변수에 는 같은 타입의 변수만 담을 수 있음
• 한 번에 많은 양의 데이터를 다루거나 계산할 때 사용함
• 배열은 영어로 Array라고 부름
• 선언 방법
  1. 타입 [ ] 변수;
     • ex. int [ ] intArray;
  2. 타입 변수 [ ];
     • ex. int intArray[ ];

 생성

• 배열(Array)는 참조형 변수들처럼 new 명령어를 통해 생성, [ ] 안에 크기를 지정
• 사이즈를 지정해서 생성된 배열은 각 칸마다 순번이 있음
• 순번은 0부터 시작함(8개 사이즈의 배열은 0번 ~ 7번까지)
• Int array[ ] = new int[8]
  • new int[8] : 배열 크기를 지정
  • 배열은 생성될 떄 각 타입별 초기 값으로 초기화되어 채워짐
    • int 는 0 , boolean은 false , String은 null 값 같이 초기 값이 정해져 있음
• 참조형 변수이기 때문에 실제 값을 담지 않고 실제값의 주소값을 저장하고 있음(Stack, Heap 구조)

순회

• 배열 안에 담겨 있는 변수들을 하나씩 꺼내서 사용하는 것
• 배열 조회는 해당 배열변수 뒤에 [ ]로 감싸서 명시
  • ex. intArray라는 배열에서 n번 째 값을 순회할 경우  intArray[n]
• 배열의 순회 방법은 반복문을 사용하는 것이 일반적임

초기화

• 배열 초기화 할 때는 3가지 방법이 있음
  • 중괄호 { } 사용해서 초기화
  • 반복문 for 문을 사용해서 초기화(또는 향상된 for문)
  • Array.fill 메서드를 사용해서 초기화
    • Array 클래스는 Java 기본 제공 메서드가 담긴 클래스

Array

package week02.array;

public class Array01 {
    public static void main(String[] args) {
        // 배열 생성
        int[] intArray = new int[3];
        boolean[] boolArray = new boolean[3];
        String[] stringArray = new String[3];

        // 배열 선언 먼저 -> 나중에 초기화
        int [] intArray2;
        intArray2 = new int[3];

        // 생성한 배열을 순회
        // 단건 조회
        System.out.println(intArray[1]);
        // 다건 조회
        for (int i=0; i<intArray2.length; i++) {
            System.out.println(intArray2[i]);
        }

    }
}


package week02.array;

import java.util.Arrays;

public class Array02 {
    public static void main(String[] args) {
        // 초기화
        // 배열의 특정값 대입 선언
        int[] intArr = {1, 2, 3, 4, 5};
        String[] strArr = {"a", "b", "c", "d"};

        // for문 사용해서 대입
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = i;
        }

        // 다건 출력
        for (int i = 0; i < intArr.length; i++) {
            System.out.println(intArr[i]);
        }

       int[] intArr2 = {10, 20, 30, 40, 50};
        // 향상된 for문 사용 다건 출력
        for (int item : intArr2) {
            System.out.println(item);
        }

        // 배열 주소를 모두 같은 값으로 초기화
        Arrays.fill(intArr, 1);

        for (int item : intArr) {
            System.out.println(item);
        }
    }
}

 

 

복사

• 얕은 복사
  • 배열 변수간에 대입 연산자 = 를 사용해서 복사를 하게 되면 주소 값만 복사 됨
  • 주소 값만 복사되고 실제 값은 1개로 유지되는 것을 얕은 복사라고 함
    • 주소 값만 복사되는 것은 변수명은 서로 다르지만 같은 값을 보고 있다는 것을 뜻함
• 깊은 복사
  • 새로운 배열을 똑같이 만드록 싶을 때 깊은 복사를 사용함
  • 실제 값을 가지고 있는 배열의 기본형 값을 꺼내서 복사하면 됨
  • 반복문 for문을 통해서 하나씩 꺼내서 복사해주는 방법과 여러 메서드를 사용하는 방법이 있음
    • .clone( ) 메서드 : 2차원 이상의 배열에서는 얕은 복사로 작동함
    • .copyOf( ) 메서드 : 배열과 함께 length 값도 같이 넣어서 실행

array copy

package week02.array;

public class Array03 {
    public static void main(String[] args) {
        // 얕은 복사
        int [] a = {1, 2, 3, 4};
        int [] b = a; // 얕은 복사

        b[0] = 3; // b의 0번째 값 변경

        System.out.println(a[0]);
    }
}

package week02.array;

import java.util.Arrays;

public class Array04 {
    public static void main(String[] args) {
        // 2. Arrays.copyOf() 메서드
        int[] a = {1, 2, 3, 4};
        int[] b = Arrays.copyOf(a, a.length); // 배열과 배열의 length도 같이 넣음

        a[3] = 0;
        System.out.println(a[3]);
        System.out.println(b[3]);
    }
}

 

String 배열

1. 선언, 생성 초기화
   • 배열 중에서 가장 많이 사용하게 되는 배열이 문자열 배열임
   • 선언 방법은 기존 배열과 동일
   • 배열 선언 및 생성 
     • String[ ] stringArrray = new String[3];
   • 배열의 초기화
     • 1개 씩 초기화 : stringArray[0] = "val1" 
     • 선언과 동시에 초기화 : String[ ] stringArray = new String[ ] {"val1", "val2", "val3"}
2. String 기능 활용 (= char 배열)
   • char 배열은 문자 배열, String은 문자열
     • 수식으로 표현 시 : String = char [ ]
   • String은 char 배열과 같기 때문에 둘 다 문자열을 저장할 수 있는 변수
   • String을 많이 쓰는 이유는 참조형 변수가 더 많은 기능을 가지고 있음
   • String만 가지고 있는 기능

 

string Array

package week02.array;

public class Array05 {
    public static void main(String[] args) {
        // 문자(char), 문자열(String)
        // String = char[]

        // 기본형 변수는 소문자로 시작함, 참조형 변수는 대문자로 시작함
        // - Wrapper class에서 기본형 변수를 boxing 하면 int -> Integer
        // 기본형 변수는 값 자체를 저장, 참조형 변수는 별도의 공간에 값 저장 후 그 주소를 저장(=주소형 변수)

        // String이 기능이 많아서 char보다 많이 사용함
        // String 활용 예시
        String str = "ABCD";

        // length
        int strLength = str.length();
        System.out.println(strLength);

        // charAt(int index)
        char strChar = str.charAt(1);
        System.out.println(strChar);

        // substring(int fromIdx, int toIdx)
        String strSub = str.substring(0, 3);
        System.out.println(strSub);

        // equals(String str)
        String newStr = "ABCD";
        boolean strEqual = newStr.equals(str);
        System.out.println(strEqual);

        // toCharArray() : String -> char[]
        char[] strCharArray = str.toCharArray();

        // char[] -> String -> char
        char[] charArray = {'A', 'B', 'C'};
        String charArrayString = new String(charArray);
        System.out.println(charArrayString);
    }
}

 

 

 

다차원 배열

1. 2차원 배열(2열 배열), 순회
   • 1열로 구성된 분류통을 배열이라고 하고, 1차원 배열이라고도 부름
   • 1열 배열을 위로 쌓으면 2열 배열이 되고 이걸 2차원 배열이라고 함

선언

• 2차원 배열을 선언할 때는 1차월 배열에 대괄호를 하나 더 추가
  • int [ ] [ ] array , int array[ ] [ ] , int [ ] array [ ]
• 2차원 배열을 생성할 때도 대괄호를 하나 더 추가
  • int [ ] [ ] array = new int [ ] [ ];
• 초기화
  • 2차원 배열 초기화는 2가지 방법이 존재
    • 중괄호를 사용해 선언과 동시에 초기화
    • 선언/ 생성 이후 반복문을 통해 초기화

2 dimension Array

package week02.array;

public class Array06 {
    public static void main(String[] args) {
        // 2차원 배열
        int[][] array = new int[2][3]; // 최초 선언

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[j].length; j++) {
                System.out.println("출력값 =>" + i + ", " + j);
                array[i][j] = 0;
            }
        }
    }
}

 

2. 가변 배열

• 2차원 이상의 배열을 생성할 때 열의 길이를 생략하여, 행마다 다른 길이의 배열을 요소로 저장할 수 있음
• 행마다 다른 길이의 배열을 저장할 수 있는 배열을 가변 배열이라고 함

3. 2차원 배열 이상의 다차원 배열

• 2차원 배열 외에도 3차원, 4차원 등이 있으나 대부분 3차원 까지만 사용하는 경우가 많음
• 3차원 배열은 2차원 배열 생성에 괄호를 하나 더 추가함
  • ex. int [ ] [ ] [ ] multiArray
• 초기화 할 때는 중괄호를 하나 더 추가
• {{{배열원소1}, {배열원소2}}, {{배열원소3}}} 와 같은 형태로 초기화가 가능

Variable Array

package week02.array;

public class Array07 {
    public static void main(String[] args) {
        // 가변 배열
        int [][] array = new int[3][];

        // 배열 원소마다 각기 다른 크기로 지정
        array[0] = new int[2];
        array[1] = new int[4];
        array[2] = new int[1];

        // 중괄호롤 초기화
        int [][] array2 = {
                {10, 20},
                {10, 20, 30, 40},
                {10}
        };
    }
}

 

 

4. 다차원 배열 조회

• 2차원 배열 조회 시 2차원 인덱스를 가진만큼 2중 반복문을 통해 출력 가능
  • 2중 반복문을 통해 가변 배열도 출력 가능

최대값, 최소값 구하기

package week02.array;

public class Array08 {
    public static void main(String[] args) {
        // 최대값 구하기
        int[] array = {3, 2, 1, 5, 1};

        // 최대값 초기화 세팅
        int max = array[0];

        // 최대값 구하기 로직
        for (int num : array) {
            if (num > max) {
                max = num;
            }
        }

        // 최소값 구하기
        int min = array[0];

        // 최소값 구하기 로직
        for (int num : array) {
            if (num < min) {
                min = num;
            }
        }

        System.out.println("최대값은 => " + max);
        System.out.println("최소값은 => " + min);
    }
}

 

 

컬렉션(Collection)

Java 프로그래밍에서는 배열을 더 고도화 시켜서 컬렉션이라는 이름으로 참조형 자료구조를 제공함.

 

컬렉션

• Java에서 컬렉션은 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있음
  • 컬렉션 기능 : 크기 자동조정/ 추가/ 수정/ 삭제/ 반복/ 순회/ 필터/ 포함확인 등...
• 컬렉션 종류
  • collection 에는 List, Set, Queue, Map 이 있음.
  • List  : 순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷
  • Queue : 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
    • First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있음
  • Set : 순서가 없는 데이터의 집합 (데이터 중복 허용 안 함) - 순서없고 중복 없는 배열
  • Map : 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (Key 값 중복 허용 안함)
    • Map하고 python의 Dictionary가 같은 기능을 가졌다고 판단 됨.

컬렉션 구조

• 컬렉션은 기본형 변수가 아닌 참조형 변수를 저장함
  • 자주 쓰는 참조형 변수
    • int 의 참조형 변수 = Integer
    • long 의 참조형 변수 = Long
    • double 의 참조형 변수 = Double
    • String 은 원래부터 참조형 변수

 

List

순서가 있는 데이터의 집합(데이터 중복 허용) - 배열과 비슷

 

ArrayList

배열(Array) 처럼 일렬로 데이터를 저장하고 조회하여 순번값(인덱스)로 값을 하나씩 조회할 수 있음

• 특징
  • 배열(Array)처럼 크기가 정해져 있지 않고 필요할 때마다 크기가 점점 더 늘어납니다.
  • Array처럼 크기가 고정된 정적배열이 아닌 크기가 가변적으로 늘어나는 동적배열
    • Array는 메모리에 연속된 공간을 요청한 사이즈만큼 받아서 실제값을 저장하는 기본형 변수로 저장해서 정적배열
    • ArrayList는 생성 시 작은 연속된 공간을 요청해 참조형 변수들을 담아놓고, 값이 추가될 때 더 큰 공간이 필요 시 필요한 공간을 받아서 저장해서 동적 배열
• 기능
  • 선언 : ArrayList <Integer> intList 형태로 선언
  • 생성 : new ArrayList <Integer> ( ); 형태로 생성
  • 초기화 : 사이즈를 지정하는 것이 없기 때문에 초기화 필요 없음
  • 값 추가 : intList.add( { 추가할 값 } ) 형태로 값을 추가
  • 값 수정 : intList.set( { 수정할 순번 } , { 수정할 값 } ) 형태로 수정
  • 값 삭제 : intList.remove( {삭제할 순번 } ) 형태로 값을 삭제
  • 전체 출력 : intList.toString( ) 형태로 전체 값을 대괄호 [ ] 로 묶어서 출력
  • 전체 제거 : intList.clear( ) 형태로 전체 값을 삭제

ArrayList

package week02.collection;

import java.util.ArrayList;

public class Col1 {
    public static void main(String[] args) {
        // List
        // 길이 지정 안 해도 생성 가능
        // Array -> 정적배열
        // List(ArrayList) -> 동적배열
        ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 + 생성

        intList.add(99);
        intList.add(15);
        intList.add(3);

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

        // 2번째 값 변경
        intList.set(1, 10);
        System.out.println(intList.get(1));

        // 삭제
        intList.remove(0);
        System.out.println(intList.get(0)); // 0번째 값이 삭제되고 1번째 값이 0번째 값으로 바뀜

        System.out.println(intList.toString());
        intList.clear();
        System.out.println(intList.toString());
    }
}

 

LinkedList

메모리에 남는 공간을 요청해서 여기저기 나누어서 실제 값을 담아놓고, 실제 값이 이쓴 주소 값으로 목록을 구성하고 저장함

• 특징
  • 기본 기능은 ArrayList와 동일, LinkedList는 값을 나누어 담기 때문에 모든 값을 조회하는 속도가 느림. 대신, 값을 중간에 추가하거나 삭제할 때는 속도가 빠름
  • 중간에 값을 추가하는 기능이 있음. (속도 빠름)
• 기능
  • 선언 : LinkedList <Integer> linkedList 형태로 선언
  • 생성 : new LinkedList <Integer> ( ); 형태로 생성
  • 초기화 : 사이즈를 지정하는 것이 없어서 초기화 필요 없음
  • 값 추가 : linkedList.add ( { 추가할 값 } ) 형태로 값을 추가
  • 값 중간에 추가 : linkedList.add ( { 추가할 순번 } , { 추가할 값 } ) 형태로 값을 중간에 추가함
  • 값 수정 : linkedList.set ( { 수정할 순번 } , { 수정할 값 } ) 형태로 값을 수정함
  • 값 삭제 : linkedList.remove( { 삭제할 순번 } ) 형태로 값을 삭제
  • 전체 출력 : linkedList.toString( ) 형태로 전체 값을 대괄호 [ ]로 묶어서 출력
  • 전체 제거 : linkedList.clear( ) 형태로 전체 값을 삭제 

LinkedList

package week02.collection;

import java.util.LinkedList;

public class Col2 {
    public static void main(String[] args) {
        // LinkedList
        // 실제 값이 있는 주소 값으로 목록을 구성하고 저장하는 자료구조

        LinkedList<Integer> linkedList = new LinkedList<Integer>();

        linkedList.add(5);
        linkedList.add(10);
        linkedList.add(3);

        System.out.println(linkedList.get(0));
        System.out.println(linkedList.get(1));
        System.out.println(linkedList.get(2));

        System.out.println(linkedList.toString()); // toString()은 속도가 느림

        linkedList.add(200);
        System.out.println(linkedList.toString());

        linkedList.add(2, 4);
        System.out.println(linkedList.toString());

        linkedList.set(1, 30);
        System.out.println(linkedList.toString());

        linkedList.remove(1);
        System.out.println(linkedList.toString());

        linkedList.clear();
        System.out.println(linkedList.toString());
        
    }
}

 

 

Stack

값을 수직으로 쌓아놓고 넣었다가 빼서 조회하는 형식으로 데이터를 관리함. (Last In First Out 성질을 가짐)

• 특징
  • 상자에 물건을 넣고 빼는 것처럼 밑에서 위로 쌓고, 꺼낼 때는 위에서부터 꺼내는 형식
  • 넣는 기능( push( ) ), 조회( peek( ) ), 꺼내는 ( pop( ) ) 기능이 있음
  • 최근 저장한 데이터를 나열하고 싶거나 데이터의 중복 처리를 막고 싶을 때 사용
• 기능
  • 선언 : Stack <Integer> intStack 형태로 선언
  • 생성 : new Stack <Integer> ( ); 형태로 생성
  • 추가 : intStack.push( { 추가할 값 } ) 형태로 값을 추가
  • 조회 : intStack.peek( ) 형태로 맨 위 값을 조회
  • 꺼내기 : intStack.pop( ) 형태로 맨 위 값을 꺼냄(꺼내고 나면 삭제 됨)

Stack

package week02.collection;

import java.util.Stack;

public class Col3 {
    public static void main(String[] args) {
        // stack
        // push, peek, pop

        Stack<Integer> intStack = new Stack<Integer>();

        intStack.push(10);
        intStack.push(5);
        intStack.push(1);

        // 다 지워질 때까지 출력
        while (!intStack.isEmpty()) {
            System.out.println(intStack.pop());
        }

        // 추가
        intStack.push(10);
        intStack.push(5);
        intStack.push(1);

        // peak
        System.out.println(intStack.peek());
        System.out.println(intStack.size());
        
    }
}

 

 

Queue

빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합

• 특징
  • First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있음
  • 넣는 기능( push( ) ), 조회( peek( ) ), 꺼내는 ( poll( ) ) 기능만 있음
  • Queue 는 생성자가 없는 껍데기라서 바로 생성할 수는 없음. (껍데기 = 인터페이스)
  • 생성자가 존재하는 클래스인 LinkedList를 사용하여 Queue를 생성 받을 수 있음
    • (Queue 가 부모 / LinkedList 가 자식)
• 기능
  • 선언 : Queue <Integer> intQueue 형태로 선언
  • 생성 : new LinkedList <Integer> ( ); 형태로 생성
  • 추가 : intQueue.add( { 추가할 값 } ) 형태로 값을 맨 위에 추가
  • 조회 : intQueue.peek( ) 형태로 맨 아래 값을 조회
  • 꺼내기 : intQueue.poll( ) 형태로 맨 아래 값을 꺼냄(꺼내고 나면 삭제됨)

Queue

package week02.collection;

import java.util.LinkedList;
import java.util.Queue;

public class Col4 {
    public static void main(String[] args) {
        // Queue
        // add , peek , poll
        // Queue : 생성자가 없는 인터페이스

        Queue<Integer> intQueue = new LinkedList<>(); // Queue 선언, 생성

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        while (!intQueue.isEmpty()) {
            System.out.println(intQueue.poll());
        }

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        // peek
        System.out.println(intQueue.peek());
        System.out.println(intQueue.size());
    }
}

 

 

Set

순서가 없는 데이터의 집합(데이터 중복 허용 안함) - 순서 없고 중복 없는 배열

• 특징
  • 순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있음
  • Set은 그냥 Set으로 쓸 수 있지만, HashSet, TreeSet 등으로 응용하여 사용할 수 있음
  • Set은 생성자가 없는 껍데기라서 바로 생성할 수는 없음.
  • 생성자가 존재하는 클래스인 HashSet를 사용하여 Set를 생성 받을 수 있음
• 기능
  • 선언 : Set <Integer> intSet 형태로 선언
  • 생성 : new HashSet <Integer> ( ); 형태로 생성
  • 추가 : intSet.add( { 추가할 값 } ) 형태로 값을 맨 위에 추가
  • 조회 : intSet.get( { 조회할 순번 } ) 형태로 순번에 있는 값을 조회
  • 삭제 : intSet.remove( { 삭제할 값 } ) 형태로 삭제할 값을 직접 지정
  • 포함 확인 : intSet.contains( { 포함확인 할 값 } ) 형태로 해당 값이 포함되어 있는지 boolean 값으로 응답 받음
• 종류
  • HashSet : 가장 빠르며 순서를 전혀 예측할 수 없음
  • TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
  • LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
    
    • 보통 HashSet을 사용하며 순서보장 필요 시 LinkedHashSet을 주로 사용

Set

package week02.collection;

import java.util.HashSet;
import java.util.Set;

public class Col5 {
    public static void main(String[] args) {
        // Set(집합): 순서 없고, 중복 없음
        // 순서 보정 없이, 중복 허용 않하는 프로그램에 사용되는 자료구조
        // Set -> HashSet, TreeSet
        // Set 바로 생성 불가(생성자가 없음)

        // HashSet
        Set<Integer> intSet = new HashSet<>(); // 선언 생성

        intSet.add(1);
        intSet.add(12);
        intSet.add(5);
        intSet.add(9);
        intSet.add(1);
        intSet.add(12);

        for (Integer value : intSet) {
            System.out.println(value);
        }

        // contains
        System.out.println(intSet.contains(2));
        System.out.println(intSet.contains(5));
    }
}

 

 

Map

value 값들만 넣는 자료구조와 다르게 key - value 구조로 구성된 데이터를 저장할 수 있음.

• 특징
  • key-value 형태로 데이터를 저장하기 때문에 기존에 순번으로만 조회하던 방식에서, key 값을 기준으로 value 조회 가능
  • key 값 단위로 중복을 허용하지 않는 기능이 있음
  • Map은 그냥 Map으로 쓸 수 있지만, HashMap, TreeMap 등으로 응용하여 사용 가능
  • Map으로 쓸 수도 있지만, HashSet, TreeSet 등으로 응용하여 사용 가능
• 기능
  • 선언 : Map <String, Integer> intMap 형태로 선언
  • 생성 : new HashMap < > ( ); 형태로 생성
  • 추가 : intMap.put( { 추가할 key 값 }, { 추가할 value 값 } ) 형태로 Key에 Value 값을 추가
  • 조회 : intMap.get( { 조회할 key값 } ) 형태로 Key에 있는 Value 값을 조회
  • 전체 key 조회 : intMap.keyset( ) 형태로 전체 key 값들을 조회
  • 전체 value 조회 : intMap.values( ) 형태로 전체 value 값들을 조회
  • 삭제 : intMap.remove( { 삭제할 key 값 } ) 형태로 key에 있는 value 값 삭제
• 종류
  • HashMap : 중복을 허용하지 않고 순서를 보장하지 않음, 키와 값으로 null이 허용
  • TreeMap : Key 값을 기준으로 정렬을 할 수 있음, 저장 시 정렬(오름차순)을 하기 때문에 저장시간이 다소 오래 걸림

Map

package week02.collection;

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

public class Col6 {
    public static void main(String[] args) {
        // Map : Key-Value pair
        // key 값은 중복 불가
        // Map -> HashMap, TreeMap

        Map<String, Integer> intMap = new HashMap<>();

        // key setting
        intMap.put("일", 11);
        intMap.put("이", 12);
        intMap.put("삼", 13);
        intMap.put("삼", 14);
        intMap.put("삼", 15);

        // key 전체 출력
        for (String key : intMap.keySet()) {
            System.out.println(key);
        }

        // values 출력
        for (Integer values : intMap.values()) {
            System.out.println(values);
        }

        System.out.println(intMap.get("삼"));
    }
}

 

 

길이 값 가져오기

length vs length( ) vs size( )

1. length
   
   • array( int[ ], double[ ] , String[ ] )
   • length는 배열의 길이를 조회함
2. length( )
   
   • String related Object(String, StringBuilder etc.)
   • length( )는 문자열의 길이를 조회함
3. size( )
   • Collection Object(ArrayList, Set etc)
   • size( )는 컬렉션 타입목록의 길이를 조회함

 

레시피 메모장 - 자료 구조 사용 버전

package javatraining;

import java.util.*;

public class Recipe02 {
    public static void main(String[] args) {
        // 레시피 메모장 - 2주차

        // 입력부 만들기
        Scanner sc = new Scanner(System.in);
        // 자료 구조 선택 및 요리 제목 받기
        System.out.println("사용할 자료 구조를 입력하세요: ");
        String colName = sc.next();
        System.out.println("요리 제목을 입력하세요: ");
        String title = sc.nextLine();

        // 각 자료 구조 별로 입출력부 제작
        switch (colName) {
            case "List":
                // List 생성
                ArrayList<String> strList = new ArrayList<>();

                // 입력 받기
                while (true) {
                    String text = sc.nextLine();
                    if (Objects.equals(text, "끝")) {
                        break;
                    }
                    strList.add(text);
                }

                // 출력하기

                title = "[ List " + title + " ]";
                System.out.println(title);
                for (int i = 0; i < strList.size(); i++) {
                    int number = i + 1;
                    System.out.println(number + ". " + strList.get(i));
                }
                break;

            case "Set":
                // Set 생성
                LinkedHashSet<String> strSet = new LinkedHashSet<>();

                // 입력 받기
                while (true) {
                    String text = sc.nextLine();
                    if (Objects.equals(text, "끝")) {
                        break;
                    }
                    strSet.add(text);
                }

                // 출력하기
                Iterator<String> iterator = strSet.iterator();

                title = "[ Set " + title + " ]";
                System.out.println(title);
                for (int i = 0; i < strSet.size(); i++) {
                    int number = i + 1;
                    System.out.println(number + ". " + iterator.next());
                }
                break;

            case "Map":
                // Map 생성
                Map<Integer, String> strMap = new HashMap<>();
                int lineNumber = 1;

                // 입력 받기
                while (true) {
                    String text = sc.nextLine();
                    if (Objects.equals(text, "끝")) {
                        break;
                    }
                    strMap.put(lineNumber++, text);
                }

                // 출력하기

                title = "[ Map " + title + " ]";
                System.out.println(title);
                for (int i = 0; i < strMap.size(); i++) {
                    int number = i + 1;
                    System.out.println(number + "." + strMap.get(i + 1));
                }
                break;

            default:
                System.out.println("입력한 자료 구조는 사용할 수 없습니다.");
        }
    }
}

 

추후 과제 개선 사항 및 학습 필요 부분

1. 요리 제목이 [ ]로 감싸진 부분이 아닌 아래쪽 레시피의 1번 항목으로 들어가는 문제
2. Iterator에 대해 공부가 필요함(set에 포함된 자료를 확인하기 위해 사용했으나 이해가 부족함)
3. switch문 사용할 수 있는 부분에 대한 이해