없는 값을 체크 할 때 위의 둘을 쓰게 되는데

뭐가 다를까?

1. isEmpty()

인스턴스는 생성 되어있는 상태

but 안에 값은 비어있는 상태(정확하게는 ""으로 값이 들어가있는 상태)

    -  null과 공백데이터는 엄연히 다르다

java 1.6버젼에서 추가됨

ex) 빈 항아리

2. == null

null은 인스턴스가 생성되지 않은 상태

즉, 아무런 주소값을 가지고 있지 않는 상태이며, 값 자체가 존재하지 않음

ex)항아리 자체가 없음

직접 테스트해보자

// isEmpty() vs == null 차이
String testEmpty = "";
String testNull = null;

// 1. 공백값 & isEmpty() 체크
if(testEmpty.isEmpty()){
    System.out.println("1 : "+testEmpty);
}  

// 2. null & isEmpty() 체크
if(testNull.isEmpty()){
    System.out.println("2 : "+testNull);
} 

// 3. 공백값 & null 체크
if(testEmpty == null){
    System.out.println("3 : " + testEmpty);
}  

// 4. null & null 체크
if(testNull == null){
    System.out.println("4 : "+ testNull);
}

2번인 13라인에 NullPointerException 발생

공백 값이지만 값을 체크하는 거기 때문에 애초에 값 자체가 들어오지 않았기 때문에 NullPointerException이 발생한 것

2번을 주석처리하고 다시 돌려보면

조건이 true인 것만 발동하니 1,4번만 출력되는 걸 알 수 있다

3번은 공백에 null을 체크한거라 애초에 인스턴스가 존재하기 때문에 null 자체가 아니니 false이다

※ 비슷한 주제

 == vs equals

배열에 객체가 들어가다보니 기존 배열보다 좀 까다롭다는 느낌이 들었다

배열 안에 있는 객체 속성값에 접근해서 출력하는게 기존과는 달라서 좀 헤맸다는 것

기존 기본형 자료타입들과 다르게 객체타입이다보니 헷갈리는게 많았다는 것

아직은 숙련도가 많이 부족해서 계속 반복해서 내 손발처럼 될 수 있게 연습해야겠다

package chap06_objectArray.controller;

import java.util.Arrays;

import chap06_objectArray.model.vo.Person;

public class Person02Controller {
	
	public void objectArr00() {
		
		// 예제
		// 출처 :http://daplus.net/java-java%EB%A1%9C-%EA%B0%9D%EC%B2%B4-%EB%B0%B0%EC%97%B4-%EB%A7%8C%EB%93%A4%EA%B8%B0/
		
		// 1.선언 및 인스턴스화
		A[ ] arr = new A[4];
		
		// 2.객체 초기화
		// 방법1
		arr[0] = new A();
		arr[1] = new A();
		arr[2] = new A();
		arr[3] = new A();
		
		// 방법2
		for( int i=0; i<4; i++ ) {
			  arr[i] = new A();
		}
		// 방금 만든 객체에서 기존 메소드 호출 가능해짐
		// 방법1
		int x = arr[1].getNumber();
		// 방법2
		arr[1].setNumber(x);
		
	}
	
	public void objectArr01() {
		
		// 객체배열
		//
		// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
		// 배열 할당 : heap 영역에 공간 생성
		// 배열 초기화 : 인덱스,중괄호,for문
		// 배열 삭제 : null
		// 배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드
		
		
		
		
		// 배열 선언 - stack 영역에 생성
		String objArr;
		
		// 배열 할당 - heap 영역에 생성
		Person[] objArr01 = new Person[3];
		
		// 초기화
		//	1)인덱스
		objArr01[0] = new Person();
		objArr01[1] = new Person("김철수", 20, 'M', 170.5, 70);
		objArr01[2] = new Person("이순신", 40,'M', 180.5, 85.5); 

// vo Person		
//		private String name;
//		private int age;
//		private char gender;
//		private double height;
//		private double weight;
		
		// 	2) 중괄호
		Person objArr02 = new Person("안중근", 30,'M', 175.5, 75.3);
		Person[] objArr03 = {new Person("유관순", 18,'F', 160.2, 45.5),
							 new Person("신사임당", 40,'F', 157.5, 43.2),
							 new Person("세종대왕", 55, 'M', 180.5, 80.5)
							};
		System.out.println(objArr02); // chap06_objectArray.model.vo.Person@6d06d69c
		System.out.println(Arrays.toString(objArr03)); // 객체주소값 출력 : [chap06_objectArray.model.vo.Person@6d06d69c, chap06_objectArray.model.vo.Person@7852e922, chap06_objectArray.model.vo.Person@4e25154f]

//		System.out.println(Arrays.toString(objArr02[0])); // The type of the expression must be an array type but it resolved to Person
//		for(int i=0; i < objArr02.length; i++) { // 
//			System.out.println(objArr02[i]);	// The type of the expression must be an array type but it resolved to Person
//		}										// for문 출력은 int나 int로 자동형변환되는 소수들이 가능
		
		
		// 	3) for문
		Person[] objArr04 = new Person[3];
		for(int i=0; i < objArr04.length; i++) {
			objArr04[i] = 
		}
		
		
		// 객체 주소값 출력
		for(int i=0; i < objArr03.length; i++) {
			System.out.println("objArr03 = "+objArr03[i]);
//				objArr03 = chap06_objectArray.model.vo.Person@7852e922
//				objArr03 = chap06_objectArray.model.vo.Person@4e25154f
//				objArr03 = chap06_objectArray.model.vo.Person@70dea4e
		}
		// vo클래스 toString()을 이용한 객체속성값 출력
		for(int i=0; i < objArr03.length; i++) {
			System.out.println(objArr03[i].personInfo());
//				유관순, 18, F, 160.2, 45.5
//				신사임당, 40, F, 157.5, 43.2
//				세종대왕, 55, M, 180.5, 80.5
		}
//		System.out.println(Arrays.toString(objArr03.personInfo())); // Cannot invoke personInfo() on the array type Person[]
//		System.out.println(Arrays.toString(objArr03[0].personInfo())); // The method toString(long[]) in the type Arrays is not applicable for the arguments (String)
//		System.out.println(Arrays.personInfo()); // toString빼고 바로 출력할려했으나 에러 : The method personInfo() is undefined for the type Arrays
		
		// 삭제
		objArr03 = null;
		System.out.println(objArr03); // null
		System.out.println(Arrays.toString(objArr03)); // null
		for(int i=0; i < objArr03.length; i++) {
			System.out.println(objArr03[i].personInfo()); // Exception in thread "main" java.lang.NullPointerException
		}
		
		
	}
	
	
	
}

하나의 값만 저장하는 공간인 변수는 하나만 저장이 가능하기에 배열이 만들어짐

배열이란?

같은 자료형의 데이터의 여러개의 값을 저장할 수 있는 공간

배열 선언

자료형[] 배열명; // 자바식. 대부분 이쪽 사용
자료형 배열명[]; // C언어식.

int[] arr;

배열은 선언만해서는 쓸 수 없고 할당까지 해야함

배열은 기본자료형이 아니며 참조자료형처럼 사용

구조가 참조자료형처럼 되어있어 주소값을 갖는다

기본형, 참조형 구분 기준 : call by value & call by reference

즉, 주소값을 가져오느냐 값 자체를 그대로 복사해서 가져오느냐

* Stack 영역에 공간 생성

배열 할당

heap 메모리 영역에 공간을 생성하는 것

(변수의 선언 : stack에 공간 차지)

자료형[] 배열명 = new 배열명[배열길이]
자료형 배열명[] = new 자료형[배열길이]

메모리 영역에 공간을 생성해주는 역할을 new 연산자가 실행

new 연산자가 배열 할당하는 역할+heap영역에 생성된 공간에 대한 주소값을 발생시킴

배열의 크기 변경 가능할까?

배열은 크기 변경 불가

새로운 배열을 만들고 바꿔치기하거라 주소값이 바뀐다(0x100→0x200)

System.out.print("새로 할당할 배열의 길이 입력 : ");
		int size = sc.nextInt();
		
		double[] dArr = new double[size];
		System.out.println("dArr의 길이 : "+dArr.length);
		System.out.println("dArr의 주소값 : "+ dArr); // [D@74a14482
		
		dArr = new double[5];
		System.out.println("변경 후 dArr의 길이 : " + dArr.length);// 배열 길이 변경 가능
		System.out.println("변경 후 dArr의 주소값 : " + dArr);		 // but 길이 변경 후 주소값 달라짐 [D@1540e19d
		System.out.println();								 // 
		// 주소값하면 new 연산자가 떠올라야. 
		// dArr[30]에서 new연산자가 쓰이면서 새로운 공간생성과 함께 주소값 생성하기에 주소값이 달라짐

그래서 주소값이 바뀌는 것(0x100→0x200)

기존 배열 유지x

new연산자에 의해 heap영역에 새로운 배열의 공간이 생성되고 그에 따라 stack에 있는 변수명 dArr의 참조 변수값(주소값)도 0x100→0x200 바뀜

new 연산자 역할

1)배열 할당 : heap 메모리 영역에 공간 생성

2)heap 영역에 생성된 공간에 대한 주소값 생성

-배열 한칸이 아닌 배열 한덩이 전체에 대한 주소값

ex)주소값 0x100

heap이 컴퓨터와 사용자가 같이 사용하는 공간인 것

배열명에 담긴게 heap메모리 영역에 생성된 주소값을 담은 것

주소를 통해서 실제 데이터를 가리키는 것이다.

배열 초기화

1)인덱스 이용

1. 중괄호{}를 이용
2. for문 이용

1)인덱스 이용

배열명[인덱스] 값;
ex) 
int[] iArr = new int[3];
iArr[0] = 1;
iArr[1] = 2;
iArr[2] = 3;
iArr[3] = 4; // error : 배열이 3칸 할당됬는데 없는 4칸째에 값을 할당하려해서 

2) 중괄호{} 이용

자료형[] 배열명 = {값,값};
ex)
int[] arr = {1,2,3,4}; // 값 수에 따라 알아서 배열 칸 지정하고 생성함

3) for문 이용

내가 초기화할 값에 ‘규칙’이 존재할 경우 사용가능

for문 인덱스 이용한거라 int만 가능

for(int i=0; i<str.length; i++) {   
    arr[i] = i + 1;
}

배열 삭제

null 상태로 만드는게 삭제

**dArr = null;**

null을 넣으면 0x100→0x200 바뀐주소가 null로 바뀌면서 0x200과 연결이 끊어지면서 0x200의 데이터는사리지고 사실상 삭제 효과가 나타난다

배열 선언 
배열 할당
배열 초기화 : 인덱스,중괄호,for문
배열 삭제 : null
배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
배열 복사 : shallow copy & deep copy

코드 익히기 & 배운 것들

배열 크기 변경 불가(삭제하고 새로 만들기에 주소값이 변경됨)
배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
dArr[3] = 3; // 3.0으로 출력 -> 자동형변환(int to double) 
초기화 for문 방법은 int만 가능하나, 실수로 형변환 가능한 int면 for문 가능 -> int인 i가 실수로 변환 가능한 수이기에 

public void arrayPractice() {
    // 배열 선언 
    // 배열 할당
    // 배열 초기화 : 인덱스,중괄호,for문
    // 배열 삭제 : null
    // 배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
    // 배열 복사 : shallow copy & deep copy
    //
    // 		배열 크기 변경 불가(삭제하고 새로 만들기에 주소값이 변경됨)
    //		배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
    //		dArr[3] = 3;	// 3.0으로 출력 -> 자동형변환(int to double) 
    // 		초기화 for문 방법은 int만 가능하나, 실수로 형변환 가능한 int면 for문 가능 -> int인 i가 실수로 변환 가능한 수이기에 
    // 		null인 배열값 확인 시, for문방법은 널포인트익셉션 쓰므로 Arrays.toString() 사용해야함

    //배열 선언
    String[] arr; // Stack 영역에 공간 생성

    //배열 할당
    String[] sArr1 = new String[3];
    String sArr2[] = new String[3];

    // 배열 초기화
    // 방법1 : 인덱스
    sArr1[0] = "a";
    sArr1[1] = "b";
    sArr1[2] = "c";

    // 방법2 : 중괄호 {} 이용
    // 선언과 동시에 초기화
//		sArr2 = {"a","b","c"}; // error : 중괄호 타입은 자료형부터 풀로 적어주는 형태에만 가능
    String[] sArr3 = {"a","b","c"};

    // 방법3 : for문
    // 배열이 int타입인 경우만 사용가능
    // 		double로 형변환 가능한 int면 for문 가능할까?  
    // 		가능. int인 i가 실수로 변환 가능한 수이기에
    int[] intArr = new int[5];
    for(int i=0; i < intArr.length;i++) {
        intArr[i] = i + 1;
    }
    for(int i=0; i < intArr.length; i++) {
        System.out.print(intArr[i]+" "); 	// 1 2 3 4 5
    }

    // 배열 삭제
    intArr = null;
    System.out.println(Arrays.toString(intArr)); // null

    // 배열 값 출력하는 방법
    //  1)for문
    //  2)Arrays.toString()

    // 1)for문
//		int[] baseArr = {1,2,3,4,5};
//		for(int i=0; i<baseArr.length;i++) {
//			System.out.print(baseArr[i] + " "); // 1 2 3 4 5
//		}
    //  2)Arrays.toString()
//		System.out.println(Arrays.toString(baseArr)); // [1, 2, 3, 4, 10]


/******************************practice 2nd ************************************/

    // 배열 선언
    char[] cArr;

    // 배열 할당
    char[] cArr1 = new char[3];
    char[] cArr2 = new char[3];

    // 배열 초기화(추가)
    // 방법1 : 인덱스
    cArr1[0] = 'a';
    cArr1[1] = 'b';
    cArr1[2] = 'c';
//		cArr1[3] = 'd';
//		System.out.println(Arrays.toString(cArr1));
    // 방법2 : 중괄호
    char[] cArr11 = {'a','b','c'};
    char[] cArr22 = {'ㄱ','ㄴ','다'};
    char[] cArr3 = {'a','b','c'};
    // 방법3 : for문
    // int배열만 사용가능
//		char[] cArr4 = new char[4];
//		for(int i=0; i < cArr4.length; i++) {
//			cArr4[i] = i + 1; // int배열만 사용가능하기에 error : Type mismatch: cannot convert from int to char
//			System.out.print(cArr4[i] + " ");
//		}

    int[] cArr4 = new int[4];
    for(int i=0; i < cArr4.length; i++) {
        cArr4[i] = i + 1;
        System.out.print(Arrays.toString(cArr4)+'\n'); // [1, 0, 0, 0][1, 2, 0, 0][1, 2, 3, 0][1, 2, 3, 4]
    }
    System.out.println(Arrays.toString(cArr4)); // [1, 2, 3, 4]

    // 배열 삭제
    cArr4 = null; 
    System.out.println(Arrays.toString(cArr4));
    System.out.println(Arrays.toString(cArr3));
    cArr3 = null;
    System.out.println(Arrays.toString(cArr3));


System.out.println("===practice 3rd===");		


/******************************practice 3rd ************************************/
    // 배열 선언
    float[] fArr;
    float[] floatArr;	// Stack 영역에 공간 생성

    // 배열 할당
    float[] fArr1 = new float[5];
    double[] dArr = new double[5];

    // 배열 초기화
    // 방법 1 : 인덱스
    dArr[0] = 0.1;
    dArr[1] = 0.2;
    dArr[2] = 3.0;
    dArr[3] = 3;	// 3.0으로 출력 -> 자동형변환
    System.out.println(Arrays.toString(dArr));

    // 방법2 : 중괄호
    double[] dArr2 = {0.1,0.2,0.3};
    System.out.println(Arrays.toString(dArr2)); // [0.1, 0.2, 0.3] -> 배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
    // 방법3 : for문
    double[] dArr3 = new double[3];
    // double로 형변환 가능한 int면 for문 가능할까?  
    // 가능. int인 i가 실수로 변환 가능한 수이기에
    for(int i=0; i < dArr3.length; i++) {
        dArr3[i] = i + 1;
        System.out.print(dArr3[i]+" "); // 1.0 2.0 3.0 
    }
    System.out.println();


    dArr3 = null;
//		for(int i = 0; i < dArr3.length; i++) {
//			System.out.println(dArr3); // null인 배열값 확인 시, for문방법은 널포인트익셉션 쓰므로 Arrays.toString() 사용해야함
//		}
    System.out.println(Arrays.toString(dArr3)); // null


}

제목과 내요을 넣고 게시물 등록 눌렀는데 왜 db에는 null이 들어왔을까?

화면단 만드느라 정신팔려서 서버로 데이터를 보내는 값을 만들어주지 않았기 때문

--BETWEEN
-- 반대로 급여를 3500000미만 6000000초과를 받는 사원의 사번, 이름, 급여, 부서코드, 직급코드 조회

SELECT EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE
FROM EMPLOYEE
--WHERE SALARY BETWEEN 3500000 AND 6000000;
WHERE SALARY NOT BETWEEN 3500000 AND 6000000;
-- 1.EMPLOYEE 테이블에 고용일이 90/01/01 ~ 01/01/01인 사원의 전체 내용을 조회 (BETWEEN 사용)
SELECT *
FROM EMPLOYEE
--WHERE HIRE_DATE >= '90/01/01' AND HIRE_DATE <= '01/01/01';
WHERE HIRE_DATE BETWEEN '90/01/01' AND '01/01/01';

-- LIKE
--EMPLOYEE 테이블에서 이메일 중 _의 앞 글자가 3자리인 이메일 주소를 가진 사원의 사번의 사번, 이름, 이메일 주소 조회
SELECT EMP_ID, EMP_NAME, EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE '___^_%' ESCAPE '^';

-- NULL
-- EMPLOYEE 테이블에서 부서 배치를 받지 않았지만 보너스를 지급받는 직원의 이름,  보너스, 부서코드 조회
SELECT EMP_NAME, BONUS, DEPT_CODE
FROM EMPLOYEE
WHERE DEPT_CODE IS NULL AND BONUS IS NOT NULL;

-- IN
-- 직급코드가 J1, J2, J3, J4인 사람들의 이름, 직급코드, 급여 조회
SELECT EMP_NAME, JOB_CODE, SALARY
FROM EMPLOYEE
WHERE JOB_CODE = 'J1' OR JOB_CODE = 'J2' OR JOB_CODE = 'J3' OR JOB_CODE = 'J4';


-----------실습문제-----------
--1.EMPLOYEE 테이블에서 이름 끝이 '연'으로 끝나는 사원 이름 조회
--2.EMPLOYEE 테이블에서 전화번호 처음 세자리가 010이 아닌 사원의 이름, 전화번호 조회
--3.EMPLOYEE 테이블에서 메일주소 _의 앞이 4자이면서 DEPT_CODE가 D9 또는 D6이고
--  고용일이 90/01/01 ~ 00/12/01이고, 급여가 2700000만 이상인 사원의 전체 정보 조회

SELECT EMP_NAME
FROM EMPLOYEE
WHERE EMP_NAME LIKE '%연';

SELECT EMP_NAME, PHONE
FROM EMPLOYEE
WHERE PHONE NOT LIKE '010%';

SELECT  *
FROM EMPLOYEE
WHERE EMAIL LIKE '____!_%' ESCAPE '!' 
        AND (DEPT_CODE 'D9' OR DEPT_CODE 'D6')
        AND HIRE_DATE '90/01/01' AND '00/12/01'
        AND SALARY >= 2700000;

public class practice_everyday13 {
	public static void main(String[] args) {
		
		// 배열
		// 같은 자료형의 데이터의 여러개의 값을 저장할 수 있는 공간
		
		// 배열 선언
		int[] arr;
		
		// 배열 할당

		int[] arr1 = new int[3]; // 방법1 : 주로 Java에서 사용
		int arr2[] = new int[3]; // 방법2 : 주로 C에서 사용
		
		// 배열 초기화
		// 1)인덱스
		// 2)중괄호 {}
		// 3)for문 이용
		
		// 1)인덱스
		arr1[0] = 1;
		arr1[1] = 2;
		arr1[2] = 3;
		
		System.out.println(arr1[0]); // 1
		System.out.println(arr1[1]); // 2
		System.out.println(arr1[2]); // 3
		
		
		// 2)중괄호 {}
		int[] arr3 = {1,2,3};
//		int arr3[] = {1,2,3}; // error
		for(int i=0; i<arr3.length; i++) {
			System.out.print(arr3[i]+ " "); // 1 2 3
		}
		System.out.println();
		
		// 3)for문
		// 초기화할 값에 ‘규칙’이 존재할 경우 사용가능
		int[] arr4 = new int[3];
		for(int i=0; i<arr4.length; i++) {
			arr4[i] = i+3;
			System.out.print(arr4[i]+" ");
		}
		System.out.println();
		
		// 배열 수정(크기 변경)?
		int size = 5;
		int[] dArr = new int[size];
		System.out.println("dArr길이:"+dArr.length);
		System.out.println("dArr주소:"+dArr);// [I@6d06d69c
		dArr = new int[5]; // 같은 배열 길이
		System.out.println(dArr); // [I@7852e922 주소값이 다르다
		dArr = new int[4]; // 배열길이 4로 수정. 과연 주소값이 같을까?
		System.out.println(dArr); // [I@4e25154f
		// 전부 다른 주소값이 나왔다. 보이기에는 길이가 수정된 것처럼 보이나
		// 실제로는 새로 만든 값으로 대체시킨 것
		
		
		// 배열 삭제
		// 배열 삭제 = null
		dArr = null;
		// 배열에 null을 넣게되면 기존 주소값이 null로 바뀌면서 연결된 값도 끊어지면서
		// 사실상 삭제 효과가 나타난다
        
       }
}