new int[5]; 주소값 정수가 5개담겨져 있는 공간의
hashCode() 주소값을 확인하기위한
한번 할당된 배열을 지울수 없다.
int[][] iarr1; 2차원 배열
무조건 생성할때 방의크기를 지정해야함 첫번째칸은
뒤에는 가변배열
iarr2 = new int[3][5] 정변배열
iarr.length = 3 iarr[0].length =5
중괄호를 열고 닫는거로 직접 선언해서 배열을 쓸 수 있다.
배열 복사에는 얕은 복사와 깊은 복사가 있다.
얕은 복사는 공유한다는 개념 stack의 주소값만 복사 주소값은 1개
내가사용한 메소드의 반환형을 확인해라
application3
깊은복사
cloneOf() 똑같은걸 하나 더만드는 거
arraycopy()성능면에서 더좋음
copyOf() 많이 쓰이는
같은 클래스내에 있는 static 메소드는 클래스명 생략해도 출력가능
originArr으로 반복을 돌리는 이유는 값이 있어서 효율이 있다
F3번 누르면 상세하게 들어갈수 있는 내용을 볼 수 있다.
Object 타입 모든 최상위 클래스 타입은 object 어떤 타입이 들어올지 몰라서
일단 최상위 타입으로 지정되어있음
Pos도착지의 약자 destPos 도착지
Arrays.copyOf(originArr, 7);
복사할 내용 , 7은 얼만큼 공간을 만들건지
7 = newLength 방의 크기를 만드는거
Math.min = 두수중에서 가장 작은 값을 넣어주는 것
origin length = 5 newLength= 7
package com.greedy.section03.array_copy;
import java.util.Arrays;
public class Application3 {
public static void main(String[] args) {
/* 깊은 복사 */
/*
* 깊은 복사는 heap에 생성된 배열이 가지고 있는 값을
* 또 다른 배열에 복사를 해 놓은 것이다
*
* 서로 같은 값을 가지고 있지만, 두 배열을 서로 다른 배열이기에
* 하나의 배열에 변경을 하더라도 다른 배열에는 영향을 주지 않는다.
* */
/* 깊은 복사를 하는 방법 4가지*/
/* 1. for문을 이용한 동이란 인덱스의 값 복사
* 2. Object의 clone()을 이용한 복사
* 3. System의 arraycopy()를 이용한 복사
* 4. Arrays의 copyOf()를 이용한 복사
* */
int[] originArr = new int[] {1, 2, 3, 4, 5};
print(originArr);
/* 1. for문을 이용한 동일한 인덱스 값 복사 */
int[] copyArr1 = new int[10];
for(int i = 0; i < originArr.length; i++) {
copyArr1[i] = originArr[i];
}
/* 원본 배열과 복사한 값은 같은 값을 가지고 나머지 인덱스는 다른 값 , 다른 주소를 가지고 있다. */
print(copyArr1);
/* 2. Object의 clone()을 이용한 복사 */
int[] copyArr2 = originArr.clone();
/* 동일한 길이, 동일한 값을 가지는 배열이 생성되어 복사되며, 다른 주소를 가지고 있다. */
print(copyArr2);
/* 3. System의 arraycopy()를 이용한 복사 */
int[] copyArr3 = new int[10];
/*
* arraycopy의 각 위치별 사용값
* 1번째 : 원본배열
* 2번째 : 복사를 시작할 인덱스
* 3번째 : 복사본 배열
* 4번째 : 복사를 시작할 인덱스
* 5번째 : 복사할 길이
* */
System.arraycopy(originArr, 0, copyArr3, 3, originArr.length);
/* 복사한 만큼의 값은 같지만 길이도 다르고 주소도 다르다. */
print(copyArr3);
/* 4. Arrays의 copyOf()를 이용한 복사 */
int[] copyArr4 = Arrays.copyOf(originArr, 7);
/* 복사한만큼의 값은 같지만 길이도 다르고 주소도 다르다. */
print(copyArr4);
}
/**
* <pre>
* 배열을 매개변수로 전달받아
* 모든 인덱스에 저장되어 있는 값을 출력하는 기능을 제공
* </pre>
* @param iarr 저장된 값을 출력하기 위한 정수 배열
*/
public static void print(int[] iarr) {
/* 전달받은 배열의 hashCode 출력 */
System.out.println("iarr의 hashCode : " + iarr.hashCode());
/* 전달받은 배열의 값 출력 */
for(int i = 0; i < iarr.length; i++) {
System.out.print(iarr[i] + " ");
}
System.out.println();
}}
-> iarr의 hashCode : 1023487453
1 2 3 4 5
iarr의 hashCode : 1651191114
1 2 3 4 5 0 0 0 0 0
iarr의 hashCode : 1586600255
1 2 3 4 5
iarr의 hashCode : 474675244
0 0 0 1 2 3 4 5 0 0
iarr의 hashCode : 932583850
1 2 3 4 5 0 0
Application4
향상된 for문 순차가 정해져있는 내용의 값을 가지고올때 많이 사용
조회용도로 사용
내가 어떤값을 출력할지 처음에 줄세워놓음
일반 for문보다 빠름
int i : arr2
왼쪽편은 변수를 선언했다 임시적으로
arr2에는 반복할 대상
package com.greedy.section03.array_copy;
public class application4 {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = arr1.clone();
for(int i = 0; i < arr1.length; i++) {
arr1[i] += 10;
}
for(int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + " ");
}
System.out.println();
/* 향상된 for문 : jdk 1.5 버전부터 추가되었다.
* 배열 인덱스에 하나씩 차례로 접근해서 담긴 값을 임시로 사용할 변수에 담고 반복문을 실행한다.
* */
for(int i : arr2) {
i += 10;
}
for(int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + " ");
}
System.out.println();
/* 주의 : 향상된 for문은 배열에 인덱스에 차례로 접근할 때는 편하게 사용할 수 있지만
* 값을 변경할 수는 없다. 대신 변경하는 것이 아니고 사용하는것이 목적이라면
* 조금 더 편하게 사용할수 있다.
* */
for(int i : arr2) {
System.out.print(i + " ");
}
System.out.println();
}}
->11 12 13 14 15
1 2 3 4 5
1 2 3 4 5
package com.greedy.section04.array_sort;
public class Application1 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
System.out.println("num1 : " + num1);
System.out.println("num2 : " + num2);
int temp;
temp = num1;
num1 = num2;
num2 = temp;
System.out.println("num1 : " + num1);
System.out.println("num2 : " + num2);
int[] arr = {2, 1, 3};
int temp2;
temp2 = arr[0];
arr[0] = arr[1]; //{1, 1, 3}
arr[1] = temp2; // {1, 2, 3}
/* {1, 2, 3} -> 오름차순정렬(ASC)
* {3, 2, 1} -> 내림차순정렬(DESC)
* */
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}}
-> num1 : 10
num2 : 20
num1 : 20
num2 : 10
1 2 3
applicaiton2
순차정렬
{2,5, 4, 6, 1, 3}
1회전 : i:1, j=0
iarr[1] < iarr[0] -> 5 < 2 -> 교환x
2회전 : i:2, j=0
-> iarr[2] < iarr[0] -> 4 < 2 -> 교환x
-> iarr[2] < iarr[1] -> 4 < 5 -> 교환o {2,4,5,6,1,3}
{2,4,5,6,1,3}
3회전 : i:3, j=0
-> iarr[3] < iarr[0] -> 6 < 2 -> 교환x
-> iarr[3] < iarr[1] -> 6 < 4 -> 교환x
-> iarr[3] < iarr[2] -> 6 < 5 -> 교환x
4회전 : i:4, j=0
-> iarr[4] < iarr[0] -> 1 < 2 -> 교환
{1,4,5,6,2,3}
-> iarr[4] < iarr[1] -> 2 < 4 -> 교환
{1, 2, 5, 6, 4, 3}
-> iarr[4] < iarr[2] -> 4 < 5 -> 교환
{1, 2, 4, 6, 5, 3}
-> iarr[4] < iarr[3] -> 5 < 6 -> 교환
{1, 2, 4, 5, 6, 3}
if(iarr [i] < ia ㄴ 부등호를 반대로 바꿔주면 내림차순으로 변경함
package com.greedy.section04.array_sort;
public class Application2 {
public static void main(String[] args) {
/* 순차 정렬
*
* 순차정렬이란 정렬 알고리즘에서 가장 간단하고 기본이되는 알고리즘으로
* 배열의 처음과 끝을 탐색하면서 차순대로 정렬하는 가장 기초적인 정렬 알고리즘이다.
* */
int[] iarr = {2, 5, 4, 6, 1, 3};
for(int i = 1; i < iarr.length; i++) { //5
for(int j =0; j < i; j++) {
/* 오름차순 정렬을 위한 처리 (<)
* 내림차순은 부등호만 반대로 처리하면 된다.(>)
* */
if(iarr [i] < iarr[j]) { // i:1 ->5 , j:0 -> 2
int temp;
temp = iarr[i];
iarr[i] = iarr[j];
iarr[j] = temp;
}
}
}
for(int i = 0; i < iarr.length; i++) {
System.out.print(iarr[i] + " ");
}
}}
-> 1 2 3 4 5 6
application3
https://codepumpkin.com/category/algorithms/
[bubble sort]
{2,5,4,6,1,3}
1회전 : i:5
j:0
0-> iarr[0] > iarr[1] -> 2 > 5 -> 교환x
1-> iarr[1] > iarr[2] -> 5 > 4 -> 교환
{2,4,5,6,1,3}
2 -> iarr[2] > iarr[3] -> 5 > 6 -> 교환x
3->iarr[3] > iarr[4] -> 6 > 1 -> 교환
{2,4,5,1,6,3}
4->iarr[4] > iarr[5] -> 6 > 3 -> 교환
{2,4,5,1,3,6}
2회전 : i:4
j:0
-> iarr[0] > iarr[1] -> 2 > 4 교환x
-> iarr[1] > iarr[2] -> 4 > 5 교환x
-> iarr[2] > iarr[3] -> 5>1 교환o
{2,4,1,5,3,6}
-> iarr[3] > iarr[4] -> 5 > 3 교환
{2,4,1,3,5,6}
3회전 : i:3
j:0
-> iarr[0] > iarr[1] -> 2 > 4 교환 X
-> iarr[1] > iarr[2] -> 4 > 1 교환
{2, 1, 4, 3, 5, 6}
-> iarr[2] > iarr[3] -> 4 > 3 교환
{2,1,3,4,5,6}
package com.greedy.section04.array_sort;public class Application3 {
public static void main(String[] args) {
/* 버블 정렬 (bubble sort)
*
* 인접한 두 개의 원소를 검사하여 정렬하는 방법
* 구현이 쉽다는 장점이 있으며, 이미 정렬된 데이터를 정렬할 때 가장 빠르다.
* 하지만 다른 정렬에 비해 정렬 속도가 느리며, 역순으로 정렬할 때 가장 느린 속도를 가진다.
* */
int[] iarr = {2,5,4,6,1,3};
int temp;
for(int i = iarr.length - 1; i >= 0; i--) {
for(int j =0; j < i; j++) {
//오름 차순 정렬은 >로 구분하고
//내림차순 정렬은 <로 구분한다.
if(iarr[j] > iarr[j+1]) {
temp = iarr[j];
iarr[j] = iarr[ j + 1 ];
iarr[j + 1] = temp;
}
}
}
for(int i =0 ; i < iarr.length; i++) {
System.out.print(iarr[i] + " ");
}
}}
-> 1 2 3 4 5 6
첫시간
변수 ---> 기본자료형에 따라 변하는 수를 담는 공간
기본자료형
정수 byte short int long
실수 float double
문자 char
논리 boolean
배열 ----> 같은 자료형 끼리의 묶음
클래스는 서로다른 자료형의 데이터들을 사용자(개발자) 정의로 하나로 묶어 새로운 타입을 정의
(배열과 달리 다른 자료형들의 값을 하나로 묶을 수 있음)
int[] iarr = new int[5];
iarr -> 참조형변수
다른곳에서 클래스의 필드에 접근하기 위해 '.'(참조연산자)를 활용
자료형타입(사용자 정의타입) 참조변수(변수명) = new 자료형타입();
Student std = new Student();
chap06-class-and-object-lecture-source
package com.greedy.section01.user_type;
class Application1
window- show view - tasks // TODO 내일질문해야지
package com.greedy.section01.user_type;
public class Application1 {
public static void main(String[] args) {
/* 회원 정보를 관리하기 위해 회원의 여러 정보(아이디, 비밀번호, 이름, 나이, 성별, 취미)
* 를 취급하여 관리하려고 한다.
* */
String id = "user01";
String pwd = "pass01";
String name = "홍길동";
int age = 20;
char gender = '남';
String[] hobby = new String[] {"축구", "볼링", "테니스"};
System.out.println("id : " + id);
System.out.println("pwd : " + pwd);
System.out.println("name : " + name);
System.out.println("age : " + age);
System.out.println("gender : " + gender);
System.out.print("hobby : " );
for(int i = 0; i < hobby.length; i++) {
System.out.print(hobby[i] + " ");
}
System.out.println();
/*
* 이렇게 각각의 변수로 관리하게 되면 여러 가지 단점이 있다.
* 1. 변수명을 다 관리해야 하는 어려움이 생긴다.
* 2. 모든 회원 정보를 인자로 메소드 호출 시 값을 전달해야 하면 너무 많은 값들을
* 인자로 전달해야 해서 한 눈에 안들어온다.
* 3. 리턴은 1개의 값만 가능하기 때문에 회원정보를 묶어서 리턴값으로 사용할 수 없다.
* (서로 다른 자료형들이기 때문에)
* */
/* 자바에서는 서로 다른 자료형의 데이터를 사용자(개발자) 정의로 하나로 묶어서
* 새로운 타입을 정의할 수 있는 방법을 제공해준다.
*
* 필요로 하는 자료형이 추가로 존재하는 경우 자바에서는 클래스라는 매커니즘을 이용해서
* 사용자 정의의 자료형을 만들 수 있게 한다.
* */
/* 사용자 정의 자료형 사용하기 */
/* 1. 변수 선언 및 객체 생성 */
/* 자료형 변수명 = new 클래스명(); <-- 이 구문은 객체(instance)를 생성하는 구문 */
/* 사용자 정의의 자료형인 클래스를 이용하기 위해서는 new 연산자로 heap에 할당을 해야 한다.
* 객체를 생성하게되면 클래스에 정의한 필드와 메소드 대로 객체(instance)가 생성된다.
* 아이디, 비밀번호,이름, 나이, 성별, 취미를 연속된 메모리 주소에서
* 사용하도록 heap에 공간을 만든다.(클래스에 작성한 내용 대로 생성한다.)
* */
Member member = new Member();
/* 위와 같이 객체를 생성하고 나면 서로 다른 자료형들을 하나의 member,라는
* 이름으로 관리할 수 있도록 공간을 생성한 것이다.
* (heap에 생성되기 때문에 jvm 기본값을 초기화된다.)
* */
/*
* 필드에 접근하기 위해서는 레퍼런스변수명.필드명으로 접근한다.
* '.'은 참조연산자라고 하는데, 레퍼런스변수가 참고하고 있는 주소로 접근한다는 의미를
* 가진다. 각 공간은 필드명으로 접근한다.
* (배열은 인덱스로 접근. 객체는 필드명으로 접근이다.)
* */
System.out.println("member.id : " + member.id);
System.out.println("member.pwd : " + member.pwd);
System.out.println("member.name : " + member.name);
System.out.println("member.age : " + member.age);
System.out.println("member.gender : " + member.gender);
System.out.println("member.hobby : " + member.hobby);
/* 2. 필드에 접근해서 변수 사용하듯 사용 할 수 있다. */
System.out.println("변경 후 member.id : " + member.id);
System.out.println("변경 후 member.pwd : " + member.pwd);
System.out.println("변경 후 member.name : " + member.name);
System.out.println("변경 후 member.age : " + member.age);
System.out.println("변경 후 member.gender : " + member.gender);
System.out.println("변경 후 member.hobby : " + member.hobby);
for(int i =0; i < member.hobby.length; i++) {
System.out.print(member.hobby[i] + " ");
}
System.out.println();
}}
->
id : user01
pwd : pass01
name : 홍길동
age : 20
gender : 남
hobby : 축구 볼링 테니스
member.id : null
clas member
필드(변수)
Member <-- 클래스
속성 : 아이디, 패스워드, 이름, 나이 , 성별, 취미
Member mem1 = new Member();
클래스는 참조연산자 .을 통해 찾아가고
배열은 인덱스를 통해 찾아감
package com.greedy.section01.user_type;
public class Member {
/* 클래스 내부에는 메소드를 작성하지 않고 바로 변수를 선언할 수 도 있다.
* 이것을 전역변수(필드 == 인스턴스변수 == 속성)라고 부른다.
* */
String id;
String pwd;
String name;
int age;
char gender;
String[] hobby;}
package com.greedy.section02.encapsulation.problem1;
public class Application1 {
public static void main(String[] args) {
/* 필드에 바로 접근할 때 발생할 수 있는 문제점1
* 필드에 올바르지 않은 값이 들어가도 통제가 불가능해진다.
* */
Monster monster1 = new Monster();
monster1.name = "두치";
monster1.hp = 200;
System.out.println("monster1 name : " + monster1.name);
System.out.println("monster1 hp : " + monster1.hp);
Monster monster2 = new Monster();
monster2.name = "뿌꾸";
monster2.hp = -200;
System.out.println("monster2 name : " + monster2.name);
System.out.println("monster2 hp : " + monster2.hp);
Monster monster3 = new Monster();
monster3.name = "드라큘라";
monster3.setHP(200);
System.out.println("monster3 name : " + monster3.name);
System.out.println("monster3 hp : " + monster3.hp);
Monster monster4 = new Monster();
monster4.name = "프랑켄슈타인" ;
monster4.setHP(-200);
System.out.println("monster4 name : " + monster4.name);
System.out.println("monster4 hp : " + monster4.hp);
}}
->monster1 name : 두치
monster1 hp : 200
monster2 name : 뿌꾸
monster2 hp : -200
양수값이 입력되어 몬스터의 체력을 입력한 값으로 변경합니다.
monster3 name : 드라큘라
monster3 hp : 200
0보다 작거나 같은 값이 입력되어 몬스터의 체력을 0으로 변경합니다.
monster4 name : 프랑켄슈타인
monster4 hp : 0
class Monster
new연산자를 만나면 주소값이생성됨
this는 몬스터 클래스를 가지고 생성한
내부에서 자기 자신에 대한 내용을 나타낼때
new monster가 생성될 당시 그대로 가지고 있구나
this 생성할 당시의 주소 값
monster에는 주소값이 있음
this.hp 주소값의 필드를 찾아감
전역에 있는거랑 지역에 있는거를 구분할때
this는 전역변수에 있는 거 찾아갈때이고
지역변수로 찾아갈때는 그대로 int
package com.greedy.section02.encapsulation.problem1;
public class Monster {
String name; // 몬스터 이름
int hp; //몬스터 체력
/**
* <pre>
* 매개변수로 전달받은 정수를 이용해 hp의 값을 변경해주는 메소드
* 단, 매개변수로 전달받은 값이 양수인 경우에만 전달받은 값으로 변경하고,
* 0보다 작거나 같은 경우에는 0으로 변경한다.
* </pre>
* @param hp
*/
public void setHP(int hp) {
if(hp > 0) {
System.out.println("양수값이 입력되어 몬스터의 체력을 입력한 값으로 변경합니다.");
this.hp = hp;
} else {
System.out.println("0보다 작거나 같은 값이 입력되어 몬스터의 체력을 0으로 변경합니다.");
this.hp = 0;
}
}}
package com.greedy.section02.encapsulation.problem2;
public class Application
package com.greedy.section02.encapsulation.problem2;
public class Application {
public static void main(String[] args) {
// Monster monster1 = new Monster();
// monster1.name = "드라큘라";
// monster1.hp = 200;
//
// Monster monster2 = new Monster();
// monster2.name = "프랑켄슈타인";
// monster2.hp = 300;
//
// Monster monster3 = new Monster();
// monster3.name = "미이라";
// monster3.hp = 400;
//
// System.out.println("monster1 name : " + monster1.name);
// System.out.println("monster1 hp : " + monster1.hp);
// System.out.println("monster2 name : " + monster2.name);
// System.out.println("monster2 hp : " + monster2.hp);
// System.out.println("monster3 name : " + monster3.name);
// System.out.println("monster3 hp : " + monster3.hp);
Monster monster1 = new Monster();
monster1.setInfo("드라큘라");
monster1.setHp(100);
Monster monster2 = new Monster();
monster2.setInfo("프랑켄슈타인");
monster2.setHp(200);
System.out.println(monster1.getInfo());
System.out.println(monster2.getInfo());
}}
monster
package com.greedy.section02.encapsulation.problem2;
public class Monster {
String name; // 몬스터 이름
int hp; //몬스터 체력// String kind; // 몬스터 이름
// int hp; //몬스터 체력
public void setInfo(String name) {
this.name = name;
}
public void setHp(int hp) {
if(hp > 0 ) {
this.hp = hp;
}else {
this.hp = 0;
}
}
public String getInfo() {
return "몬스터의 이름은" + this.name + " 이고, 체력은" + this.hp + " 입니다.";
}}
package com.greedy.section02.encapsulation.problem3;
public class Application
public 전체 허용
캡슐화 기호 암기
package com.greedy.section02.encapsulation.problem3;
public class Application {
public static void main(String[] args) {
Monster monster1 = new Monster();// monster1.kinds = "프랑켄슈타인";
// monster1.hp = 200;
/* 선언한 필드대로 공간은 생성되어 있지만 직접 접근하지 못하고
* public으로 접근을 허용한 메소드만 이용할수 있도록 해 놓은것
* 이것을 캡슐화 (encapsulation)이라고 부른다.
* */
monster1.setkinds("프랑켄슈타인");
monster1.setHp(200);
System.out.println(monster1.getInfo());
/*
* 캡슐화는 유지보수성을 증가시키기 위해 필드의 직접 접근을 제한하고
* public 메소드를 이용해서 간접적으로 접근하여 사용할 수 있도록 만든 기술이다.
* 클래스 작성 시 특별한 목적이 아닌 이상 캡슐화가 기본 원칙으로 사용되고 있다.
* */
}}
-> 몬스터의 종류는 프랑켄슈타인 이고, 체력은 200 입니다.
class package com.greedy.section02.encapsulation.problem3;
public class Monster {
/* 접근제한자
*
* 클래스 혹은 클래스의 멤버에 참조연산자로 접근할 수 있는 범위를 제한하기 위한 키워드이다.
*
* 1. public : 모든 패키지에 접근 허용
* 2. protected : 동일 패키지에 접근허용 . 단 , 상속관계에 있는 경우 다른 패키지에서도 접근 가능
* 3. default : 동일 패키지에서만 접근허용(작성하지 않는 것이 default)
* 4. private : 해당 클래스 내부에서만 접근 허용
*
* 위의 네가지 접근제한자는 클래스의 멤버(필드, 메소드)에 모두 사용 가능하다.
* 단, 클래스 선언시 사용하는 접근제한자는 public과 default만 사용가능하다.
* */
private String kinds; // 몬스터 이름
private int hp; //몬스터 체력
public void setkinds(String kinds) {
this.kinds = kinds;
}
public void setHp(int hp) {
if(hp > 0) {
this.hp = hp;
}else {
this.hp = 0;
}
}
public String getInfo() {
return "몬스터의 종류는 " + this.kinds + " 이고, 체력은 " + this.hp + " 입니다.";
}}
