2021-11-10(수) 3일차

다차원 배열

변수 안에는 직접적인 값이 들어갈 수도 있고 간접적인 값(레퍼런스)
레퍼런스는 변경이 불가능하다

문법에 맞춰서 수업을 들을 건지
프로그램을 짜는 것에 포커스를 맞춰서 들을 건지

저녁에 공부할 때는 둘로 나눠서 정리
1. 문법
2. 프로그램 짜는 요령

나중에는 양이 많아져서 감당하기 힘듦
미리미리 해두기

5월이 취업하기 좋음
4월 중순 이후에 준비가 끝나야 됨
6월부터 졸업생들 나와서 위험
7, 8월 휴가 시즌에는 사람을 잘 안 뽑음
모의 면접 연습하기

자극을 받는 좋은 방법 : 사람

객체라는 말을 자바책에서 처음 접하는 경우가 많음

도대체 객체라는 게 뭔가 고민해본적은 없을 거임

자바스크립트에는 이런 말이 있음
Everything is an object

자바에서는 인스턴스라는 용어를 씀

메모리 공간을 만들 때 new 라는 키워드를 씀

new도 연산자라고 생각함

얼마의 크기로 잡을지 결정을 할 수 있어야 함

자바는 int[] arr = new int[]; 이렇게 하면 에러남

크기를 모르니까

근데 자바스크립트는 에러 안 남

Linked List

메모리를 차지하면 객체라고 얘기한다

기차랑 똑같음

기차 같은 경우는 양을 붙였다 떼었다 할 수 있음

자바스크립트는 새로 만들고 연결을 걸어버린다

Linked List 라고 한다

리스트에 가까운 애지 배열에 가까운 애는 아님

인덱스 번호로 접근

키-값 사전 같은 거

자바스크립트는
arr[0]으로 접근하는 것도 가능하지만
arr["0"]으로 접근하는 것도 가능하다

const arr = ["가", "나", "다"]

console.log(arr["0"]) // 가

책 뒤에 index 나와있는 거랑 비슷한 거임
단어 쭉 적혀 있고 몇 페이지에 나오는지 써있음
단어 - 페이지

자바스크립트의 객체는 이렇게 관리된다
키와 값으로 구성되어 있다

자바스크립트는 배열보다는 리스트에 가깝다
키와 값을 가진다

배열로 선언하는 데이터의 특징
규칙이 없다
하나일 때 의미 없고 모였을 때 하나의 의미를 가지는 애들
배열 하면 반복문이 따라옴
for루프 - 카운팅 루프 (반복해야 되는 횟수를 알고 있을 때)
for (초기문; 검사식; 변환문)
for루프가 왜 나왔을까
제어를 위로 올리고 싶어서 나온 게 반복문
goto
for루프는 이것만 기억하면 됨

for (let i = 0; i < 10; i++) {
    console.log(i)
}

시험을 잘 못 봤다는 생각을 가진 상태로 면접을 보는 거임
지고 들어가는 거임
인턴을 먼저 해야될 거 같다고 얘기를 풀어냄
for루프도 시험문제로 많이 냄
for루프는 이거랑 배열 돌리는 것만 알면 됨
break랑 continue도 기억
break는 밑으로 빠지고 continue는 위로 가는 거

let i = 0

for (; i < 10; i++) {
    console.log(i)
}

이렇게 해도 에러 안 남

실제로 이렇게 코드 짜는 사람 없음

let i = 0

for (console.log("start"); i < 10; i++) {
    console.log(i)
}
------------------------------------------
start
0
1
2
3
4
5
6
7
8
9

초기문은 딱 한 번 실행됨

let i = 0

for (console.log("start"); ; i++) {
    console.log(i)
    if (i >= 10) {
        break
    }
}
---------------------------------------
start
0
1
2
3
4
5
6
7
8
9
10

let i = 0

for (console.log("start"); ; i = i + 1) {
    console.log(i)
    if (i >= 10) {
        break
    }
}

let i = 0

for (;;) {
    console.log(i)

    i = i + 1

    if (i >= 10) {
        break
    }
}
----------------------
0
1
2
3
4
5
6
7
8
9

근데 이런 걸 문제로 줌

for (;;) 이렇게 쓸 바에 while (true) 이렇게 쓴다

while 루프
언카운팅 루프
while (검사식)
부등호 연산도 연산자고 결과가 나옴

for루프를 while루프를 바꿔보라는 문제도 많이 나옴

let i = 0

while (i < 10) {

    console.log(i)

    i = i + 1
}

while루프는 검사식 밖에 없기 때문에 초기문이랑 변환문 따로 써줘야 됨

do-while루프
한 번의 실행을 보증하고 싶을 때 사용
무조건 한 번은 돌았으면 할 때 사용
검사식이 맨 마지막에 있음
수백라인 뒤에 검사식 있으면 파악하기 힘듦

switch는 :을 씀
중간에 break를 안 넣으면 밑으로 계속 흘러감

if

let flag = false

if (!flag) {
    
    // do something...
    
    flag = !flag
}

if (flag == false) → if (!flag)

let flag

console.log(flag) // undefined

변수에 내용이 없는지 판단해줌

let flag

if (!flag) {
    console.log(".......undefined")
}

let flag = false

if (!flag) {
    console.log(".......undefined or false")
}

let flag = null

if (!flag) {
    console.log(".......undefined or false or check null")
}

not 연산자가 3가지를 체크해줌
undefined, false, null

자바는 false, null인지 다 체크를 해줘야 됨

null

핸드폰 케이스

핸드폰은 없고 케이스만 있는 거

마치 핸드폰처럼 보임

모양으로 봤을 때는 있는 것처럼 보임

null은 핸드폰 케이스처럼 실제 핸드폰은 없음
null이라는 애는 리모컨이기는 한데 그냥 껍데기만 있는 리모컨임
실제로는 내용물이 없고 빈 껍데기만 있는 리모컨
이게 자바에서 정말 많이 나옴
그래서 null을 얘기하려면 자바 얘기를 해야 됨

변수는 내용물에 값이 들어가는 경우가 있고 리모컨이 들어가는 경우가 있다고 했었음

변수의 타입은 값이 들어갈 케이스, 리모컨이 들어가는 케이스

리모컨이 들어가는 케이스는 딱 두 가지

리모컨이 들어가는 케이스는 대문자랑 배열 밖에 없음 (참조형)

public class Ex01 {   // 자바는 무조건 클래스 안에
    public static void main(String[] args) {
        // 리모컨 : 대문자, 배열
        int[] arr = null;
        
        System.out.println(arr[0]);
    }
}
// Exception in thread "main" java.lang.NullPointerException

java.lang.NullPointerException 에러남

String str = "Hello";

String str = new ← 이렇게는 잘 안 만듦

// 리모컨 : 대문자, 배열
String str = null;

str.getBytes();

// Exception in thread "main" java.lang.NullPointerException

Null Pointer Exception 에러남

null은 껍데기만 있는 리모컨

앞글자가 대문자면 null이 들어갈 수 있다

. 점 [] 꺾쇠

Null Pointer Exception은 .점이랑 []꺾쇠에서 발생한다

성적 프로그램

const arr = [88, 97, 45, 63, 71, 52]

// 평균 = 모든 점수의 합 / 개수
for (let i = 0; i < arr.length; i++) {
    let sum = 0
}

루프 안에 변수를 선언하면 루프가 돌 때마다 변수가 만들어지는 꼴
변수를 바깥쪽에 선언하면 한 번 만들고 그걸 계속 쓰는 거. let은 변경이 가능하니까.
계속 써먹어야 되는 변수는 바깥쪽에 선언하고 (계속 보관해야 되는 거)
잠깐만 쓰고 버리는 건 안쪽에 선언하면 됨

const arr = [88, 97, 45, 63, 71, 52]

// 평균 = 모든 점수의 합 / 개수
let sum = 0

for (let i = 0; i < arr.length; i++) {
    sum += arr[i]
    console.log(`sum: ${sum}`)
}
-------------------------------------------
sum: 88
sum: 185
sum: 230
sum: 293
sum: 364
sum: 416

// 평균 = 모든 점수의 합 / 개수
let sum = 0

for (let i = 0; i < arr.length; i++) {
    sum += arr[i]
    console.log(`sum: ${sum}`)
}

let avg = (sum / arr.length).toFixed(3) // 셋째자리까지 표시

console.log(`avg: ${avg}`)

최저 점수 구하기
swap 스왑
기준점은 처음에 있는 점수를 기준점으로 잡고 시작하면 됨
루프
0번째는 돌릴 필요 없음
첫번째 값을 최저점수로 고정시켜놓은 상태로 돌리는 거니까
아니면 처음부터 나올 수 없는 점수로 잡아놓는다
-1점 이런 건 나올 수 없으니까 -1로 잡아놓는다
최소점에 -1 쓰면 안 됨. -1이 무조건 더 작으니까.
최소값을 구할 때는 처음부터 높은 점수를 적는다
처음 점수를 100점으로 잡는다
만점을 100점이라고 했을 때 101점은 나올 수 없음
101점을 최저점으로 잡는다.

if문으로 하는 법

// 최저
let min = 101
for (let i = 0; i < arr.length; i++) {
    const score = arr[i]
    // score가 min보다 작으면 swap
    if (score < min) {
        min = score
    }
}

첫 번째 값을 기준으로 해서 돌려보자

// 최저
let min = arr[0]
for (let i = 0; i < arr.length; i++) {
    const score = arr[i]
    // score가 min보다 작으면 swap
    if (score < min) {
        min = score
    }
}

삼항연산자로 하는 법

let min = 101
for (let i = 0; i < arr.length; i++) {
    const score = arr[i]
    // score가 min보다 작으면 swap
    min = score < min ? score : min
}

// 최고
let max = -1
for (let i = 0; i < arr.length; i++) {
    const score = arr[i]
    // score가 max보다 크면 swap
    if (score > max) {
        max = score
    }
}

console.log(`max: ${max}`)

매출 프로그램

나를 위해서 프로그램을 만들지 말고 남을 위해서 프로그램을 만들자

키오스크

작은 가게

1월달 매출 그래프
2월 매출
3월 매출
...
12월 매출

1년 매출 평균

5월 매출 최고, 최저

데이터를 어떻게 만들어 낼 것인가

1년 데이터
그 안에 월별로 데이터가 또 들어있음
데이터 안에 데이터가 들어가는 케이스
처음 만나는 구조화된 데이터
배열
다차원 배열
대부분 행열 데이터를 처리하기 위해서
테이블
메모리상의 구조로 봤을 때는 아님
다차원 배열은 배열 안에 있는 내용물이 배열인 거

const arr = [[1, 2], [3, 4]]

테이블처럼 생각

2차원 배열을 바라보는 방법 (중요) ★★★★★★

배열 안에 배열의 리모컨이 담기는 거

jump를 2번 해야 된다는 얘기

한 번 더 점프를 해야 된다는 거

arr의 0번째의 0번째

이거를 자바스크립로 짤 건데 자바로 증명해주겠음

자바스크립트로 찍으면 배열의 내용물이 나옴

자바로 찍으면 @로 나옴

@가 나오면 리모컨이라고 생각하면 됨

int[][] arr = {{1, 2}, {3, 4}};
		
System.out.println(arr);
System.out.println(arr.length);

[[I@15db9742
[[ 배열 안의 배열

int[][] arr = {{1, 2}, {3, 4}};
		
System.out.println(arr); // [[I@15db9742
		
System.out.println(arr[0]); // [I@6d06d69c
		
System.out.println(arr[0][0]); // 1

배열의 리모컨을 담을 수 있는 타입

int[] temp = arr[0];

temp로 바로 접근 가능

int[][] arr = {{1, 2}, {3, 4}};
		
System.out.println(arr); // [[I@15db9742

System.out.println(arr[0]); // [I@6d06d69c
		
int[] temp = arr[0]; // temp에 리모컨을 담는다
		
System.out.println(temp); // [I@6d06d69c

System.out.println(temp[0]); // 1

이 코드를 그림으로 그릴 수 있어야 됨!!

우리가 원하는 건 매출 데이터

매출이라는 게 (365일 기준)

배열 하나 만들고 365개가 있으면 됨

365개를 다 넣는 건 바보같은 짓

정보 분리

1월 매출 기록
2월 매출 기록
3월 매출 기록이 있을 거임

분류하고 싶음
나중에 정보를 쉽게 찾기 위해서

2020년도 분기별 매출

const arr = [
    [90, 87, 140], // 1분기
    [120, 130, 150], // 2분기
    [180, 240, 200], // 3분기
    [180, 140, 190] // 4분기
]

몇 분기의 데이터를 줘
몇 분기의 평균
가장 매출이 좋았던 분기를 알고 싶어
매출이 가장 좋았던 월
최고 매출 월과 최저 매출 월의 차이

가장 매출이 좋았던 분기
각 분기별로 매출 평균을 만든다.
그 중에서 최대 평균을 찾는다.

이미 분기별로 나누어져 있음.
arr[0] ← 1분기 (1월, 2월, 3월)
arr[1] ← 2분기 (4월, 5월, 6월)
arr[2] ← 3분기 (7월, 8월, 9월)
arr[3] ← 4분기 (10월, 11월, 12월)

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i] // tempArr은 배열
    console.log(tempArr)
}
----------------------------------------
[ 90, 87, 140 ]
[ 120, 130, 150 ]
[ 180, 240, 200 ]
[ 180, 140, 190 ]

자바는 @ 나오는데 자바스크립트는 값이 나옴
tempArr은 배열
아까 평균 구한 거 재사용해서 쓰면 좋을 텐데
그럼 여기에 다시 코드를 안 짜도 되는데
그게 바로 재사용성
그래서 나온 개념이 함수, 객체

분기별 평균값을 보관하고 있어야 함
평균들을 저장하는 배열이 있어야 됨
1분기의 평균이 얼마였고 2분기의 평균이 얼마였고 저장을 해놔야 됨
그리고 그 안에서 다시 최댓값을 뽑아야 함
오늘은 삽질해볼거
이런 기능이 미리 만들어져 있었으면 좋을텐데
그래서 나온 개념이 함수임
함수로 다 바꿔치기 하면 깔끔해짐

이번 시간의 포인트는 다차원 배열
남들이 볼 때는 2차원 배열이 테이블 모양으로 보이지만
실제로 우리가 볼 때는 배열 안의 배열로 봐야 된다
null(껍데기 리모컨)이면 점프할 데가 없음
그럼 자바에서 Null Pointer Exception 에러 발생
기본형에서는 발생 안 하는 에러
무조건 리모컨형(참조형) 타입에서 발생
.점이나 []꺾쇠로 점프하지 않는 이상 발생할 수 없는 거
NullPointerException 에러가 발생하면 라인에서 점이나 꺾쇠가 뭔지 찾아보면

const arr = [
    [90, 87, 140], // 1분기
    [120, 130, 150], // 2분기
    [180, 240, 200], // 3분기
    [180, 140, 190] // 4분기
]

// 가장 매출이 좋았던 분기
// 각 분기별로 매출 평균을 만든다.
for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)
}

4교시 시작

새로운 개념이 나오면
1. 이게 왜 나왔나
2. 이걸 언제 적용해야 되나
3. 어떻게 사용해야 되나

배열의 평균을 내야 함

루프 안에 i 라는 변수는 이미 선언되어 있음
i 다음은 j니까 j 사용

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)
    
    for (let j = 0; j < tempArr.length; j++) {
        // 
    }
}

j 루프 밖에 sum 변수 선언하기

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)
    
    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {

    }
}

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)

    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {
        sum += tempArr[j]
    }
}

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)

    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {
        sum += tempArr[j]
    }

    console.log(sum)
}
--------------------------------------------------
[ 90, 87, 140 ]
317
[ 120, 130, 150 ]
400
[ 180, 240, 200 ]
620
[ 180, 140, 190 ]
510

(sum/tempArr.length).toFixed(2) 소수점 둘째자리까지

// 각 분기별로 매출 평균을 만든다.
for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)

    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {
        sum += tempArr[j]
    }

    const tempAvg = (sum/tempArr.length).toFixed(2) // 소수점 둘째자리까지
    console.log(tempAvg)
}
------------------------------------------------------
[ 90, 87, 140 ]
105.67
[ 120, 130, 150 ]
133.33
[ 180, 240, 200 ]
206.67
[ 180, 140, 190 ]
170.00

배열이 또 하나 필요함
분기별 평균을 보관할 필요가 있음
그리고 그 안에서 최댓값을 찾아야 함

Q. 분기별 배열을 어디에 선언해야 하는가?

유지해야 되는 데이터는 바깥쪽에 빼줘라

for루프 바깥에 선언하기

// 분기별 평균
const parr = []

// 가장 매출이 좋았던 분기
// 각 분기별로 매출 평균을 만든다.
for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)

    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {
        sum += tempArr[j]
    }

    const tempAvg = (sum/tempArr.length).toFixed(2)
    console.log(tempAvg)
    parr.push(tempAvg)
}

console.log(parr)
-----------------------------------------------------------
[ 90, 87, 140 ]
105.67
[ 120, 130, 150 ]
133.33
[ 180, 240, 200 ]
206.67
[ 180, 140, 190 ]
170.00
[ '105.67', '133.33', '206.67', '170.00' ]

[ '105.67', '133.33', '206.67', '170.00' ]
숫자인데 문자열로 들어가 있음
toFixed() 때문임

배열 안에 문자로 넣을 거냐 숫자로 넣을 거냐

소수니까 parseFloat() 이용해서 문자열에서 숫자로 바꿔주기

// 분기별 매출 금액 평균 구하기
const parr = []

for (let i = 0; i < arr.length; i++) {
    const tempArr = arr[i]
    console.log(tempArr)

    let sum = 0

    for (let j = 0; j < tempArr.length; j++) {
        sum += tempArr[j]
    }

    const tempAvg = (sum / tempArr.length).toFixed(2) // 평균
    console.log(tempAvg)
    parr.push(parseFloat(tempAvg))
}

console.log(parr)
--------------------------------------------------------
[ 90, 87, 140 ]
105.67
[ 120, 130, 150 ]
133.33
[ 180, 240, 200 ]
206.67
[ 180, 140, 190 ]
170.00
[ 105.67, 133.33, 206.67, 170 ] // 숫자로 바뀜

그 중에서 가장 매출이 좋았던 분기

parr 안에서 최댓값 찾아야 됨

문제를 분해

가장 매출이

parr만 바라봐야 돼

이 안에서 최댓값을 찾는 거 할 수 있음
이건 어렵지 않음

질문을 자세히 보면 분기를 찾는 거
최대 금액을 찾는 게 아니라
그 매출액이 발생한 분기가 어딘지 찾는 거

애플에서 순서도 문제도 봄

// 최고 매출 분기의 평균 금액 찾기
let max = 0

for (let i = 0; i < parr.length; i++) {
    if (parr[i] > max) {
        max = parr[i]
    }
}

console.log("max: " + max)

분기 = i + 1

// 최고 매출 분기와 평균 금액은?
let max = 0
let period = 0

for (let i = 0; i < parr.length; i++) {
    if (parr[i] > max) {
        max = parr[i]
        period = i
    }
}

console.log("max: " + max)
console.log("period: " + (period + 1) + " 분기입니다.")
---------------------------------------------------------
[ 90, 87, 140 ]
105.67
[ 120, 130, 150 ]
133.33
[ 180, 240, 200 ]
206.67
[ 180, 140, 190 ]
170.00
[ 105.67, 133.33, 206.67, 170 ]
max: 206.67
period: 3 분기입니다.

2020년도 날씨를 보자

다차원 배열을 공부하는 이유

이게 몇월달인지
다시 변수 선언하고 난리였음
최고 기온, 최저 기온 : 숫자
요일, 맑음, 흐림 : 문자
실제로 우리가 다루는 정보들의 대부분은 정보가 하나로 구성되지 않는다
거의 없음
그래서 데이터를 제대로 다루려면
내가 원하는 구조화된 정보를 다루는 방법
구조화된 정보를 쉽게 말하면 정보들을 붙여놓은 거
구조화된 데이터가 알아보기 쉬움
그걸 만드는 방법이 자바보다 쉬움
중괄호랑 키, 값을 이용

자바
다차원 배열. 여러 개의 데이터를 한 번에 묶을 수 있는 장치.
다차원 배열에는 치명적인 약점이 있음. 같은 타입이 아니면 묶을 수 없음.
자바 입장에서는 뭐가 필요? 새로운 타입이 필요함
문자열과 숫자가 같이 하나의 메모리 공간에 들어갈 수 있는 타입이 필요
그게 바로 클래스

클래스를 바라보는 입장
자바를 어려워하는 가장 큰 이유. 클래스. 인스턴스.
우리가 프로그램에서 다루는 건 결국 두 가지임. 데이터와 로직이다.
데이터라는 게 있고 로직이라는 게 있는데
데이터가 굉장히 특이
데이터 : 여러 데이터가 뭉쳐서 하나의 의미를 만들어내는 경우
대표적으로 신상정보가 있다.
이름
이메일
핸드폰 번호
이런 데이터를 보면 특징이 있음. 약간 엑셀스러움. 도표로 정리가 됨.
도표로 정리가 된 데이터는 이렇게는 의미를 가지지만
이렇게는 의미를 가지지 않는다
다른 사람의 전화번호를 매칭하면 아무런 의미 없는 데이터임

어떻게 하면 데이터를 떨어뜨리지 않게 할 수 있을까
데이터를 묶으면 되는 거 아닌가

자바스크립트는 타입이라는 게 없음
다차원 배열

[["홍길동", "010-0000-0000", 16]
["고길동", "010-0000-0000", 40]
["신형만", "010-0000-0000", 50]]

다차원 배열을 쓰는 이유는 정보를 묶어버릴 수 있어서
자바스크립트에서는 배열 하나를 선언해서 문자와 숫자를 같이 저장할 수 있다
나중에 이름만 출력하고 싶을 때
이 배열들의 맨 앞을 끄집어내면 이름을 알 수 있음
이렇게 정보를 구조화시켜 놓은 진짜 이유는 내가 나중에 사용하기 편하려고
문제는 자바는 이렇게 안 됨
자바는 int의 배열의 배열에는 int만 들어갈 수 있음. String은 못 들어감
타입이라는 건 결국엔 메모리 구조를 의미.
타입이라는 건 내가 넣을 수 있는 데이터의 종류가 필요한 거.

문자열도 들어갈 수 있고 숫자도 들어갈 수 있는 새로운 메모리 구조가 있었으면 좋겠는데?
그래서 나온 게 C언어에서는 구조체
자바에서는 저런 거 없으니까 지금부터 너가 만들어. 그게 바로 클래스.

Person 이라는 클래스를 만들자
변수를 3개 모아서 묶는 거임
다차원 배열이랑 좀 비슷한데?

public class Person {
    String name;
    String phone;
    int age;
}

변수 3개가 선언됨

자바에서는 새로운 데이터 타입이 필요
원하는 타입의 데이터를 묶어서 보관하고 싶으면
붕어빵의 틀이 필요
자바스크립트랑 제일 다른 부분임
클래스를 둘로 나눠서 봐야 됨
클래스를 데이터 때문에 만드는 건지, 로직 때문에 만드는 건지

문법 보지 말고 개념만 보기

Person[] arr = {
    new Person("홍길동", "111", 16),
    new Person("고길동", "111", 16),
    new Person("신형만", "111", 16),
}

자바에서는 불가능. 자바는 타입을 따짐.
자바 입장에서는 다양한 데이터를 묶으려면 새로운 데이터 타입이 필요함
문자열과 숫자를 같이 묶을 수 있는 새로운 데이터의 타입이 필요
자바에서는 내가 원하는 타입의 데이터를 묶어서 보관하고 싶으면 '뼈대/붕어빵틀'을 만들어줘야 됨
이 부분이 자바스크립트와 자바의 가장 다른 점 중 하나
클래스를 둘로 나눠서 봐야 됨
데이터 때문에 클래스를 만드는 건지, 로직 때문에 클래스를 구성해야 되는 건지
정확하게 알고 만들어야 됨
자바에서 클래스의 의미란 내가 만드는 사용자가 정의하는 새로운 타입
문자열 2개랑 숫자 1개를 하나의 덩어리로 묶고 싶어
근데 자바에서는 이걸 할 수 있는 방법이 없어
그래서 일단 뼈대를 만든 거. 이런 메모리 구조가 있었으면 좋겠어
내가 새로운 메모리 구조를 만든 거
틀을 하나 만든 거
이 틀로 메모리를 찍어낸 다음에 거기에 데이터를 넣어준다
그게 바로 new
new로 새로 메모리 공간 만듦. 새로 찍어 낸 거
그 안에는 문자열 2개와 숫자 1개가 있다
끄집어 낼 때 어떻게 끄집어 내냐
점으로 접근할 수 있음
arr[0] → arr[0].name
그림을 이해하는 게 중요

arr이라는 배열이 있고 홍길동, 고길동, 신형만 3개가 있고 또 거기엔 name, phone, age가 있다

구조를 보면 다차원 배열이랑 똑같은 거

다차원 배열에서 점프하는 법
arr의 0번째의 0번째 arr[0][0]

근데 이제는 인덱스 번호 대신 key가 있음

arr[0][0] → arr[0].name

꺾쇠[]로 접근하던 게 점.으로 바뀐 거

근데 자바는 강한 타입의 언어라서 다양한 종류를 섞어 쓸 수 없으니까 새로운 타입을
새로운 데이터를 만들고 싶으면 타입부터 정의해야 되는 거
자바에서는 내가 새로운 타입을 만들고 싶으면 타입부터 만들어야 됨

java how to make horse

horse factroy부터 만든다 (클래스부터 만들어야 됨)

자바스크립트는
const person = {name: "홍길동", phone: "111", age: 16}
이게 끝
클래스 만들 필요 없음
console.log(person.name) // 홍길동
오늘 수업에서 제일 중요한 내용이 이거 ★★★★★

const person = {name: "홍길동", phone: "111", age: 16}

console.log(person.name)

5교시 시작

객체 리터럴

자바와 자바스크립트의 가장 큰 차이점
자바는 타입이 제한적으로 사용
여러 종류의 데이터를 한 번에 묶을 수 있는 게 필요함
클래스 : 사용자가 정의하는 새로운 타입

자바의 경우 타입이 없으면 아무것도 못 하기 때문에 타입을 먼저 정의해야 되고
자바스크립트는 그냥 중괄호를 이용해서 키 값 만들어주면 충분함
'객체 리터럴'이라고 표현한다

거리 구하기 프로그램

좌표
이름 (x, y)
이름, x, y ← 3개의 데이터가 필요

최고 점수를 받은 사람의 이름과 성적을 출력하시오.

구조화된 데이터
데이터가 구조를 가지는 거

좌표
이름 (x, y)
이름, x, y ← 3개의 데이터가 필요

이거를 자바로 만들고 싶으면
문자열 1개, 숫자 2개
클래스를 하나 만들어야 됨

자바스크립트는 그럴 필요가 없음
객체 리터럴이라는 애가 있어서 걔한테 키랑 값만 주면

A (3, 10)
B (7, 6)
C (3, 2)
D (6, 2)

나중에 위치를 찍으라고 하라고 할 거

가장 가까운 곳이 어디인지
지도 프로그램 짤 거임

HTML 페이지를 웹스톰으로 띄우고 우리 핸드폰에서 볼 수 있게 한다.

카카오 지도 쓸 거임

맛집 찾는 거

좌표 4개

좌표의 배열

좌표의 배열을 선언한다

const pointArr = [
    {name: 'A', xpos: 3, ypos: 10},
    {name: 'B', xpos: 7, ypos: 6},
    {name: 'C', xpos: 3, ypos: 2},
    {name: 'D', xpos: 6, ypos: 2},
]

그림을 그리는 게 중요함
그림을 그려서 이해할 수 있다는 얘기는 안다는 거
그 다음에 코딩해도 안 늦음

json

웹 애플리케이션

XML / JSON

이쪽에서 보내는 데이터를 받아서 뿌려주는 거
그게 웹앱
웹페이지라고 안 부름
페이지랑 사이트라는 말은 이제 안 씀

거리를 계산하고 싶어

배열 나오면 루프임

일단 루프 한 번 돌린다

const pointArr = [
    {name: 'A', xpos: 3, ypos: 10},
    {name: 'B', xpos: 7, ypos: 6},
    {name: 'C', xpos: 3, ypos: 2},
    {name: 'D', xpos: 6, ypos: 2},
]

for (let i = 0; i < pointArr.length; i++) {
    const point = pointArr[i]

    console.log(point)
}
-----------------------------------------------
{ name: 'A', xpos: 3, ypos: 10 }
{ name: 'B', xpos: 7, ypos: 6 }
{ name: 'C', xpos: 3, ypos: 2 }
{ name: 'D', xpos: 6, ypos: 2 }

편하게 쓰려고 point라는 변수로 뺐다
객체
메모리를 차지하는 게 객체
구조화된 객체
for루프를 지금까지 이렇게 썼는데 이 코드를 줄여서 쓸 수 있는 방법이 있음

객체 리터럴

for - in

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/for...in

const object = { a: 1, b: 2, c: 3 };

for (const property in object) {
  console.log(`${property}: ${object[property]}`);
}

// expected output:
// "a: 1"
// "b: 2"
// "c: 3"

for - of

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Statements/for...of

const array1 = ['a', 'b', 'c'];

for (const element of array1) {
  console.log(element);
}

// expected output: "a"
// expected output: "b"
// expected output: "c"

const pointArr = [
    {name: 'A', xpos: 3, ypos: 10},
    {name: 'B', xpos: 7, ypos: 6},
    {name: 'C', xpos: 3, ypos: 2},
    {name: 'D', xpos: 6, ypos: 2},
]

// for (let i = 0; i < pointArr.length; i++) {
//     const point = pointArr[i]
//
//     console.log(point)
// }

for (const point of pointArr) {
    console.log(point);
}
------------------------------------------------------
{ name: 'A', xpos: 3, ypos: 10 }
{ name: 'B', xpos: 7, ypos: 6 }
{ name: 'C', xpos: 3, ypos: 2 }
{ name: 'D', xpos: 6, ypos: 2 }

자바에도 이런 거 있음

target(2, 8)에서 A(3, 10)를 찾는다

그 중에서 최솟값을 찾으면 됨

readline-sync

A, B, C, D를 음식점으로 바꿔주면 됨

구글앱에서 좌표 볼 수 있음

유클리드 거리(Euclidean distance)
유클리디안 거리
두 점 사이의 거리를 구하는 공식

https://needjarvis.tistory.com/454

(x1, y1) = (2, 8)
(x2, y2) = (3, 10)

객체 리터럴을 이용하면 키 값으로 마음대로 정보를 구성할 수 있다.
다차원 배열이랑 비슷하더라
정보가 흐트러지 않게 하나로 묶어주는 집합
구조화된 정보라고 한다.
C드라이브
밑에 폴더 있고 그 폴더 안에 또 폴더 있고
폴더를 왜 나눠냤냐
알아보기 쉽고
그것도 정보를 구조화시켜 놓은 거
알아보기 쉽고 정리하려고 쓴 거

const target = {xpos: 2, ypos: 8}

거리 계산 해야겠죠

Math.pow() : 제곱
Math.sqrt() : 제곱근

Math.sqrt(Math.pow(pointArrElement.xpos - target.xpos, 2) + Math.pow(pointArrElement.ypos - target.ypos, 2))

const pointArr = [
    {name: 'A', xpos: 3, ypos: 10},
    {name: 'B', xpos: 7, ypos: 6},
    {name: 'C', xpos: 3, ypos: 2},
    {name: 'D', xpos: 6, ypos: 2},
]

// for (let i = 0; i < pointArr.length; i++) {
//     const point = pointArr[i]
//
//     console.log(point)
// }

const target = {xpos: 2, ypos: 8}

for (const pointArrElement of pointArr) {
    console.log(pointArrElement);

    const distance = Math.sqrt(Math.pow(pointArrElement.xpos - target.xpos, 2) + Math.pow(pointArrElement.ypos - target.ypos, 2))
    console.log(distance)
}

{ name: 'A', xpos: 3, ypos: 10 }
2.23606797749979  -------------> target과 A 사이의 거리
{ name: 'B', xpos: 7, ypos: 6 }
5.385164807134504 -------------> target과 B 사이의 거리
{ name: 'C', xpos: 3, ypos: 2 }
6.082762530298219 -------------> target과 C 사이의 거리
{ name: 'D', xpos: 6, ypos: 2 }
7.211102550927978 -------------> target과 D 사이의 거리

min이나 max 이용해서
제일 가까운 곳, 제일 먼 곳 구하면 됨

머신러닝 알고리즘
K-NN(K-Nearest Neighbor) 알고리즘
가장 근처의 이웃을 보고 데이터를 판단하는 거
암 세포 결과 데이터
48개 항목으로 구성되어 있었고
데이터의 개수는 약 2천개 (2천명의 환자의 검사 결과)
이 조직이 양성인지 악성인지가 구분되어 있다
전체 데이터 중에 80%를 로딩할 것
80%를 로딩해서 나머지 20% 중에 임의의 데이터를 선정해서 집어넣었을 때 예측률을 만드는 거
결과를 예측하는 거

영화 카테고리 분류 프로그램

K는 홀수 - 보통 3, 5, 7로 잡음 (짝수가 되면 판단할 수 없음)
N(Nearest)
N(Neighbor)

가장 가까운 이웃

나에게 주어진 데이터는 키스신의 숫자와 액션신의 숫자밖에 없다
k를 3이라고 했을 때 Nearest Neighbor 3개 다 멜로영화다.
이 영화는 멜로 영화다.

조직 검사할 때 쓰는 방식임

판단하려면 홀수

k가 3일 경우 가장 가까운 게 멜로영화

영화의 제목은 중요하지 않음

A냐 M이냐

키스신의 숫자와 액션신의 숫자가 중요함

종류가 다른 데이터인데
이 데이터가 이렇게 연결되는 건 의미가 없지
이렇게 묶여야지만 의미가 있음
흩어지면 안 되는 데이터
이런 애들이 자바에서 클래스

데이터 때문에, 로직 때문에
데이터 때문에 클래스를 정의하는건지

자바스크립트에서는 클래스를 만들 필요 없음
그냥 객체 리터럴도 만들면 됨

나만의 데이터 만들기

6교시 시작

영화 데이터

정렬

가장 가까운 거 3개를 뽑아내야 돼서 정렬 알아야 됨

정렬하는 방법

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"]

const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

기본 정렬 순서는 문자열의 유니코드 코드 포인트를 따릅니다.

function compare(a, b) {
  if (a is less than b by some ordering criterion) {
    return -1;
  }
  if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

숫자 오름차순 정렬

const numbers = [4, 2, 5, 1, 3];

numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]

화살표 함수를 이용하면 아래와 같이 간단한 형태로 함수 생성 ↓

const numbers = [4, 2, 5, 1, 3];

numbers.sort((a, b) => a - b);
console.log(numbers);

// [1, 2, 3, 4, 5]

화살표 함수
함수 생성 방법 중 하나.
화살표 함수는 function 키워드 대신 화살표(=>)를 사용하며 다음과 같은 형태로 생성하는 간단한 함수이다.

(매개변수) => {
  
} 불 표현식 || 불 표현식이 거짓일 때 실행할 문장

화살표 함수는 다음과 같이 간편하게 사용할 수 있다.

(매개변수) => 리턴값

https://hohoya33.tistory.com/139

const arr = [15, 52, 23, 11, 9]; 

// 오름차순 정렬, 원본 배열 수정
arr.sort((a, b) => a - b);
console.log(arr); // [9, 11, 15, 23, 52] 

// 내림차순 정렬, 원본 배열이 다시 수정 
arr.sort((a, b) => b - a);
console.log(arr); // [52, 23, 15, 11, 9]

40을 기준으로 정렬하고 싶음

int target = 40;

Arrays.sort(arr, (a, b) -> {
    
    int gap1 = Math.abs(target - a);
    int gap2 = Math.abs(target - b);
    
    return gap1 > gap2 ?  1: -1;
});

System.out.println(Arrays.toString(arr));

편지의 내용물
지령
그게 바로 람다

자바8부터 함수형을 지원하기 시작
이런 로직으로 해줘 라고 전달을 할 수 있게 됨

로직을 전달한다는 의미가 얼마나 대단한 일인지

예전에는 이런 식으로
calc(x, y, oper)
if (oper == '+')
if (oper == '-')

이 부분에서 해야 되는 로직을

함수형 언어 스타일

자바는 변수를 만들 땐 항상 앞에 타입을 붙였음

근데 여기 a, b는 없음

심지어 이것도 됨

int target = 40;

Arrays.sort(arr, (a, b) -> Math.abs(target - a) > Math.abs(target - b) ? 1: -1);

System.out.println(Arrays.toString(arr));

상속도 안 쓰고...

그 중에 하나가 람다

람다식이라고 표현

const arr = [4, 3, 21, 43, 77, 22, 11, 45]

arr.sort()

console.log(arr)

[
  11, 21, 22,  3,
   4, 43, 45, 77
]

문자열로 정렬한 거

로직을 전달해주고 싶은 거

이 안에 있는 내용물을 a, b라고 하고

const arr = [4, 3, 21, 43, 77, 22, 11, 45]

arr.sort((a, b) => {
    console.log(`a : ${a}`)
    console.log(`b : ${b}`)
    console.log(a - b)
    console.log("----------------")
    return a - b

})

console.log(arr)

a : 3
b : 4
-1
----------------
a : 21
b : 3
18
----------------
a : 21
b : 4
17
----------------
a : 43
b : 4
39
----------------
a : 43
b : 21
22
----------------
a : 22
b : 21
1
----------------
a : 22
b : 77
-55
----------------
a : 22
b : 43
-21
----------------
a : 11
b : 22
-11
----------------
a : 11
b : 4
7
----------------
a : 11
b : 21
-10
----------------
a : 45
b : 21
24
----------------
a : 45
b : 43
2
----------------
a : 45
b : 77
-32
----------------
[
   3,  4, 11, 21,
  22, 43, 45, 77
]

a와 target과의 거리
b와 target과의 거리
작은 애가 앞으로 가게 해야 됨

const target = {xpos: 2, ypos: 8}

pointArr.sort((a, b) => {
    const distanceA =  Math.sqrt(Math.pow(a.xpos - target.xpos, 2) + Math.pow(a.ypos - target.ypos, 2))
    const distanceB =  Math.sqrt(Math.pow(b.xpos - target.xpos, 2) + Math.pow(b.ypos - target.ypos, 2))
    return distanceA - distanceB
})

console.log(pointArr)

[
  { name: 'A', xpos: 3, ypos: 10 },
  { name: 'B', xpos: 7, ypos: 6 },
  { name: 'C', xpos: 3, ypos: 2 },
  { name: 'D', xpos: 6, ypos: 2 }
]

target 값 변경해서 다시 실행해 보기

const target = {xpos: 6, ypos: 3}

pointArr.sort((a, b) => {
    const distanceA =  Math.sqrt(Math.pow(a.xpos - target.xpos, 2) + Math.pow(a.ypos - target.ypos, 2))
    const distanceB =  Math.sqrt(Math.pow(b.xpos - target.xpos, 2) + Math.pow(b.ypos - target.ypos, 2))
    return distanceA - distanceB
})

console.log(pointArr)

[
  { name: 'D', xpos: 6, ypos: 2 },
  { name: 'B', xpos: 7, ypos: 6 },
  { name: 'C', xpos: 3, ypos: 2 },
  { name: 'A', xpos: 3, ypos: 10 }
]

액션신의 숫자와 키스신의 숫자로 정렬할 수 있음

­1. 영화 데이터를 배열로 만들어준다.
영화의 이름은 중요하지 않다.
키스신의 숫자, 액션신의 숫자, 카테고리만 들어가면 된다.
movies = [{, , , }]

target 영화도 키스신의 숫자, 액션신의 숫자만 있음. 카테고리는 없음.

movies를 정렬한다.

제대로 정렬이 됐다고 가정하면
유사한 영화
3개를 가지고 판단한다고 생각
3개의 데이터를 조사한다.
A가 많은지 M이 많은지
그리고 그 값을 가지고 target의 카테고리를 알아낸다.

'webstorm 외부접속' 검색

과제
영화
객체 리터럴에 대해서 공부하기
함수에 대해서 예습하기
매출 데이터에서 분기만 찾았잖아요
객체 리터럴로 바꾸기
어떻게 바꾸느냐
월 매출금액

[{month: 1, total: 90}, {month: 2, total: 87}]

3분기 8월이 제일 매출이 좋다라는 결과가 나오게끔 짜오기

코딩은 못 해도 되는데 객체 리터럴이 뭔지는 알아야 됨

객체 리터럴을 왜 쓰는지

why

칼질 잘한다고 훌륭한 요리사 아님
배열이라는 칼을 써야 되는지
객체 리터럴이라는 칼을 써야 되는지
변수를 안쪽에 써야 되는지