728x90

 

 

함수(FUNCTION)

함수(FUNCTION) 두 종류
A.단일 행 함수
B.그룹 함수

A.단일 행 함수
    1.문자 관련 함수 : LENGTH, INSTR,LPAD,LTRIM,TRIM,SUBSTR, CONCAT,REPLACE
    2.숫자 관련 함수 : ABS,MOD,ROUND,CEIL,FLOOR/TRUNC
    3.날짜 관련 함수 : MONTHS_BETWEEN, ADD_MONTHS, NEXT_DAY,LAST_DAT,EXTRACT
    4.형변환 함수 : TO_CHAR, TO_DATE, TO_NUMBER
    5.null처리 함수 : NVL, NVL2, NULLIF 
    6.선택 함수 : DECODE, CASE WHEN THEN
    
B.그룹함수
SUM, AVG, MIN/MAX, COUNT

---------------------------------------------------------------------------
---------------------------------------------------------------------------


 1.단일 행 함수
n개의 데이터를 넣으면 n개가 나오는 것
n개의 값을 읽어서 n개의 결과 리턴

2.그룹 함수
n개의 데이터를 넣으면 1개 나오는 것
n개의 값을 읽어 1개의 결과 리턴


Q. SELECT절에 단일 행 함수와 그룹 함수를 함께 사용할 수 있다/없다?
A. 없다

WHY?
result set의 결과는 테이블이었다
단일행 쓰면 여러 결과가 나오는데 그룹은 하나의 테이블이 나온다
같이 쓰면 테이블 하나가 제대로 안나오게 됨

-- SELECT절에 단일 행 함수와 그룹함수를 함께 사용할 수 없다
결과 행의 개수가 다르기 때문


함수를 사용할 수 있는 위치
SELECT 절
WHERE 절
GROUP BY 절
HAVING 절
ORDER BY 절
( 사실상 프론트빼고 다 가능)


<SELECT문 실행순서 및 사용형식>
1. FROM 테이블명 - 조회 대상 컬럼이 있는 테이블명 기술
2. WHERE 컬럼명 연산자 조건 - 행을 선택하는 조건을 기술
3. GROUP BY 컬럼명 } 계산식 - 그룹묶을 컬럼명, 계산식 기술
4. HAVING 그룹함수 연산자 비교값 - 그룹묶은 값들을 그룹함수로 계산후 선택을 위한 조건기술
5. SELECT * | [DISTINCT] 컬럼명, 계산식 [AS] 별칭
6. ORDER BY 컬럼명 | 별칭 | 컬럼순서 [ASC] | DESC
 
*/
------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- 1.단일 행 함수
-- 1)문자 관련 함수
-- LENGTH / LENGTHB
-- 인자 : 문자,숫자,특수기호, 컬럼명 
-- B = BYTE
-- LENGTH  : 길이
-- LENGTHB : 글자의 바이트 사이즈 반환 
--      한글 : 3 byte
--      영어, 숫자, 특수기호 : 1 byte


SELECT LENGTH('AAAB') FROM DUAL;   -- 4
SELECT LENGTHB('AAAB') FROM DUAL;  -- 4
SELECT LENGTH('컴퓨터') FROM DUAL;  -- 3
SELECT LENGTHB('컴퓨터') FROM DUAL; -- 9

SELECT LENGTH(EMAIL), LENGTH(EMAIL) FROM EMPLOYEE;
-- 리터럴값도 가능하지만 컬럼도 가능

SELECT LENGTH(EMP_NAME), LENGTH(EMAIL) FROM EMPLOYEE;  -- 3	   15
-- 이름, 이메일 -> 길이, 바이트 사이즈

SELECT LENGTHB(EMP_NAME), LENGTHB(EMAIL) FROM EMPLOYEE; -- 9	15
SELECT EMP_NAME, LENGTHB(EMP_NAME), LENGTHB(EMP_NAME) FROM EMPLOYEE; -- 길이B 9
        
SELECT EMP_NAME, LENGTH(EMP_NAME), LENGTHB(EMP_NAME),
        EMAIL, LENGTH(EMAIL), LENGTHB(EMAIL)
FROM EMPLOYEE;



------------------------------------------------------------------------------
------------------------------------------------------------------------------


--  INSTR
-- 해당 문자열이 처음 나온 위치 인덱스번호 반환(ZERO-INDEX X)
-- INSTR(’문자열’or컬럼명, ‘찾아낼 문자‘,  시작 index, 2번째인자인 문자가 몇번째 나오는 문자인지)

--1번째 인자 : 찾을 문자열 or 컬럼명
--2번째 인자 : 첫번째 중에 찾고 싶은 문자
--3번째 인자 : 몇번째부터 읽기 시작할 것이냐. 안적으면 1부터 시작
--4번째 인자 : ' '의 문자가 세번째인자로부터 세기 시작해서 "몇번째로 나오는 문자인가”
--    1,2번째 인자는 리터럴( ‘ ‘ )로 감싼다
 
-- 없는 문자열은 0반환 // 만약, 제로인덱스였다면 -1반환
-- AABAACAABBAA
SELECT INSTR('AABAACAABBAA','A') FROM DUAL;   -- 1
SELECT INSTR('AABAACAABBAA','A',3) FROM DUAL; -- 4
SELECT INSTR('AABAACAABBAA','A',1,3) FROM DUAL; -- 4
SELECT INSTR('AABAACAABBAA','A',1,2) FROM DUAL; -- 2

SELECT INSTR('AABAACAABBAA','B') FROM DUAL;     -- 3
SELECT INSTR('AABAACAABBAA','B',1,1) FROM DUAL; -- 3
SELECT INSTR('AABAACAABBAA','B',1,2) FROM DUAL; -- 9
SELECT INSTR('AABAACAABBAA','B',9,2) FROM DUAL; -- 10

-- 코딩해설 : 7번쨰부터 읽기 시작해서 B가 처음 나올 때까지 읽어서, 처음 나오는 B의 위치 반환해
 SELECT INSTR('AABAACAABBAA','B',7,1) FROM DUAL; -- 9
 
 
-- 마이너스(-): 거꾸로 읽기
SELECT INSTR('AABAACAABBAA','B',-1) FROM DUAL; -- 10
SELECT INSTR('AABAACAABBAA','B',-1,1) FROM DUAL; -- 10
SELECT INSTR('AABAACAABBAA','B',-1,2) FROM DUAL; -- 9
SELECT INSTR('AABAACAABBAA','B',-1,3) FROM DUAL; -- 3

SELECT INSTR('AABAACAABBAA','B',-1,-1) FROM DUAL; -- ERROR : 4번째 인자는 양수만 가능
SELECT INSTR('AABAACAABBAA','B',-1,0) FROM DUAL;  -- ERROR : 4번째 인자는 양수만 가능
-- 역순 뒤에서 찍은 기준점 기준으로 왼쪽으로 세고 인덱스번호는 맨왼쪽에서 오른쪽으로


-- 1에서부터 두번째 있는 'B'를 찾아라
SELECT INSTR('AABAACAABBAA','B',1,2) FROM DUAL; -- 9

SELECT INSTR('AABAACAABBAA','B',1,2) FROM DUAL; -- 9


-- EMPLOYEE테이블에서 이메일의 @위치 반환

SELECT EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE '___@%';


------------------------------------------------------------------------------
------------------------------------------------------------------------------


-- LPAD / RPAD
-- 왼쪽 공백 / 오른쪽 공백
-- 오른쪽 정렬 / 왼쪽 정렬
-- LPAD(컬럼명, 문자 총 길이,공백 대신 대체할 문자)
-- 주어진 값에 임의의 문자열을 왼쪽/오른쪽에 덧붙여 길이 n개의 문자열 반환
-- 전체 길이에서 남은 공간에 공백으로 채움


--      sun_di@kh.or.kr// 세팅 :20
SELECT LPAD('sun_di@kh.or.kr',20) FROM DUAL;
-- sun_di@kh.or.kr     //
SELECT RPAD('sun_di@kh.or.kr',20) FROM DUAL;



-- 값보다 지정한 총길이가 짧으면 뒤부터 짤림
SELECT LPAD('sun_di@kh.or.kr',5) FROM DUAL;
-- 공백대신 대체할 문자 삽입
SELECT LPAD('sun_di@kh.or.kr',20,'^') FROM DUAL;

------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- LTRIM / RTRIM
-- 좌/우에서부터 지정한 문자를 제거한 나머지 반환
--      문자를 지정하지 않을 경우, 공백 제거
-- LTRIM : 왼쪽부터 순서대로 제거
-- RTRIM : 오른쪽부터 순서대로 제거


-- 자바 STRING클래스에서 TRIM은 공백제거 메소드

-- KH//
SELECT LTRIM('   KH   ') FROM DUAL; -- KH   //
--    KH//
SELECT RTRIM('   KH   ')FROM DUAL; --    KH//

-- 000123456
-- 0만 제거하고 나머지를 반환
SELECT LTRIM('000123456',0) FROM DUAL;

-- 0001230456
-- 중간에 껴있는 해당 문자는 제거X
SELECT LTRIM('000123456',0) FROM DUAL;

-- ACABACCKH // KH
-- 'ABC' 묶여진 문자 하나로 보는게 아니라, A 또는 B 또는 C가 있으면 다 지우는 것
-- 'ABC' 안에 순서 상관X
SELECT LTRIM('ACABACCKH','ABC') FROM DUAL; -- KH

-- KH   // KH
-- 오른쪽부터 공백제거
SELECT LTRIM('KH   ') FROM DUAL; -- KH   //
SELECT RTRIM('KH    ') FROM DUAL; -- KH//

-- 01230456000 // 01230456
SELECT RTRIM('01230456000',0) FROM DUAL;
-- KHACABACC // KH
-- 오른쪽부터 지우기 시작
SELECT RTRIM('KHACABACC','ABC') FROM DUAL; -- KH



------------------------------------------------------------------------------
------------------------------------------------------------------------------


-- TRIM
-- 앞/뒤/양쪽에서 지정한 문자를 제거한 나머지 반환
-- TRIM(제거방향 '제거할 문자 1개' FROM '찾을 문자열OR컬럼명')
-- LEADING : 앞부터 제거
-- TRAILING : 뒤부터 제거
-- BOTH : 양쪽에서부터 제거


--    KH   // KH // A는 별칭
SELECT TRIM('   KH   ') FROM DUAL; -- KH
SELECT TRIM(BOTH FROM '   KH   ') FROM DUAL; -- KH//
SELECT TRIM(BOTH ' ' FROM '   KH   ') FROM DUAL; -- KH//
SELECT TRIM(BOTH FROM '   KH   ') FROM DUAL; -- KH// 2번인자 제거할 문자 : 생략가능
SELECT TRIM(LEADING 'K' FROM '   KH   ') FROM DUAL; --    KH   // 공백에서 멈춰 K안지워짐
SELECT TRIM(TRAILING 'K' FROM '   KH   ') FROM DUAL; --    KH   //공백에서 멈춰 K안지워짐
SELECT TRIM(TRAILING ' ' FROM '   KH   ') FROM DUAL; --    KH//



-- ZZZKHZZZ // KH
SELECT TRIM(BOTH 'Z' FROM 'ZZZKHZZZ') FROM DUAL; -- KH
-- 123KH123123 // error : trim set should have only one character
-- TRIM은 제거할 문자 1개만 받는다
-- ZZZKHZZZ // KHZZZ
-- LEADING 앞부터 제거
SELECT TRIM(LEADING 'Z' FROM 'ZZZKHZZZ') FROM DUAL; -- KHZZZ

-- ZZZKHZZZZ // ZZZKH
-- TRAILING 뒤부터 제거
SELECT TRIM(TRAILING 'Z' FROM 'ZZZKHZZZZ') FROM DUAL; -- ZZZKH

-- ZZZKHZZZZ //KH
-- BOTH 양쪽에서부터 제거
SELECT TRIM(BOTH 'Z' FROM 'ZZZKHZZZ') FROM DUAL;  -- KH

--LTRIM/RTRIM처럼 인자 추가 형식이 아닌 
--코드 구조를 바꿔서 써야함 
--제거를 지우겠다 어디서부터? 컬럼명부터


------------------------------------------------------------------------------
------------------------------------------------------------------------------

--SUBSTR
-- String.substring()
--SUBSTR(컬럼명, 시작위치 인덱스, 시작위치부터 값을 반환할 길이)


-- HELLOMYGOODFRIENDS // YGOODFRIENDS
-- 7번째서부터 끝까지 반환
SELECT SUBSTR('HELLOMYGOODFRIENDS',7) FROM DUAL;

-- HELLOMYGOODFRINEDS // OM
-- 5번째 문자부터 2개만 반환
SELECT SUBSTR('HELLOMYGOODFRIENDS',5,2) FROM DUAL;

-- HELLOMYGOODFRINEDS // (null)
-- 5번쨰 문자부터 0개 반환 // 0개 반환이 불가능하기에 NULL 출력됨
SELECT SUBSTR('HELLOMYGOODFRIENDS',5,0) FROM DUAL; -- --(NULL)
-- HELLOMYGOODFRINEDS // HELLOM
SELECT SUBSTR('HELLOMYGOODFRIENDS',0,5) FROM DUAL; -- HELLO // 0부터 시작해도 1부터 적용
SELECT SUBSTR('HELLOMYGOODFRIENDS',1,5) FROM DUAL; -- HELLO // 0부터 시작해도 1부터 적용


-- HELLOMYGOODFRINEDS //  DFR
-- 뒤에서 8번째(D)부터 오른쪽으로 3개의 문자 반환
-- 위에서 마이너스(-)였으면 기준점이 뒤에서부터 세고 왼쪽방향으로 카운팅했지만 얘는 오른쪽으로 카운팅
SELECT SUBSTR('HELLOMYGOODFRIENDS',-8,3) FROM DUAL; -- DFR
-- HELLOMYGOODFRINEDS // OO
SELECT SUBSTR('HELLOMYGOODFRIENDS',-10,2) FROM DUAL;  -- OO
SELECT SUBSTR('HELLOMYGOODFRIENDS',-10,-2) FROM DUAL; -- 3RD 인자 몇번째문자인지가 -이면 NULL값


-- EMPLOYEE 테이블에서 이름, 이메일, 이메일의 아이디 조회
-- (이메일의 @ 도메인말고 아이디까지만)
SELECT EMP_NAME, EMAIL, SUBSTR(EMAIL,1,INSTR(EMAIL,'@')-1)
FROM EMPLOYEE;
-- 문제풀이 사고과정
-- 1.이메일 아이디의 규칙은 항상 @이 앞에 있음
-- 2. @ 위치 파악
-- 3. 1~@앞까지 찾기

-- EMPLOYEE 테이블에서 이름, 이메일, 이메일의 아이디 조회
-- (이메일의 @ 도메인말고 아이디까지만)
SELECT EMP_NAME, EMAIL,SUBSTR(EMAIL,1,INSTR(EMAIL,'@')-1)
FROM EMPLOYEE;


-- 주민등록번호를 이용하여 이름과 성별을 나타내는 부분 조회
-- EMPLOYEE 테이블에서 남자만 조회(사원명, '남')
-- EMPLOYEE 테이블에서 여자만 조회(사원명, '여')
SELECT EMP_NAME 사원명, CASE WHEN SUBSTR(EMP_NO,8,1)=1 THEN '남'
                            WHEN SUBSTR(EMP_NO,8,1)=2 THEN '여'
                       END 성별 
FROM EMPLOYEE;

SELECT EMP_NAME 사원명, DECODE(SUBSTR(EMP_NO,8,1),1,'남',2,'여') 성별
FROM EMPLOYEE;



-- EMPLOYEE테이블에서 직원들의 주민번호를 이용하여 사원명, 생년, 생월, 생일 조회
SELECT EMP_NAME 사원명,  SUBSTR(EMP_NO,1,2) 생년, SUBSTR(EMP_NO,3,2) 생월, SUBSTR(EMP_NO,5,2) 생일
FROM EMPLOYEE;



------------------------------------------------------------------------------
------------------------------------------------------------------------------


-- LOWER / UPPER / INITCAP
-- INITCAP :각 단어의 첫글자만 대문자

-- 예제 Welcome To my World
-- welcome to my world
SELECT LOWER('Welcome To my World') FROM DUAL;
-- WELCOME TO MY WORLD
SELECT UPPER('Welcome To my World') FROM DUAL;
-- Welcome To My World
SELECT INITCAP('Welcome To my World') FROM DUAL;


------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- CONCAT
-- 문자열 이어붙이기

-- 가나다라123
SELECT CONCAT('가나다라','123') FROM DUAL;
SELECT CONCAT(DEPT_CODE, '-333') FROM EMPLOYEE; -- D9-333
SELECT CONCAT(JOB_CODE, ' BY S') FROM JOB; -- J1 BY S
SELECT CONCAT(DEPT_CODE, JOB_CODE) FROM EMPLOYEE; -- D9J1
-- 연결연산자 사용 : 가나다라123
-- 연결연산자 : ||
SELECT '가나다라' || '123' FROM DUAL; -- 가나다라123


------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- REPLACE
-- REPLACE(컬럼명,바꿔질 단어, 바꿀 단어)
-- 값 교체

-- 서울시 강남구 역삼동 // 서울시 강남구 삼성동
SELECT REPLACE('서울시 강남구 역삼동','역삼동','삼성동') FROM DUAL;

-- 강사님은 오라클을 수업중이다 // 선생님은 오라클을 수업중이다
-- 띄어쓰기 상관없이 적용가능
SELECT REPLACE('강사님은 오라클을 수업중이다','강사님','선생님') FROM DUAL;

-- 케이크 달다. 케이크 싫은사람? // 공부 달다. 공부 싫은사람?
-- 여러개 들어있어도 복수로 교체가능. 일치만 하면 전부 교체함
SELECT REPLACE('케이크 달다. 케이크 싫은사람?','케이크','단 거') FROM DUAL;

-- EMPLOYEE테이블에서 사원명, 주민번호 조회
-- 주민번호의 뒷자리는 *로 바꿔서 조회(EX.001122-*******)


-- REPLACE+SUBSTR

-- REPLACE+SUBSTR+INSTR


/*
REPLACE(EMP_NO,SUBSTR(EMP_NO,8,14/2)
SELECT REPLACE(EMP_NO,SUBSTR(EMP_NO,8,14/2)) FROM EMPLOYEE;
SELECT REPLACE(EMP_NO,SUBSTR(EMP_NO,8,LENGTH(EMP_NO)/2)) FROM EMPLOYEE;
SELECT LENGTH(EMP_NO)/2 FROM EMPLOYEE;
*/

-- RPAD+SUBSTR
SELECT EMP_NAME, RPAD(SUBSTR(EMP_NO,1,7),14,'*******')
FROM EMPLOYEE;


-- 방법1
-- REPLACE+SUBSTR 끝수 지정 & 미지정 


-- 방법2
-- RPAD+SUBSTR
SELECT EMP_NAME, REPLACE(EMP_NO,SUBSTR(EMP_NO,8,7),'*******') 주민번호
FROM EMPLOYEE;

-- RPAD+SUBSTR+INSTR
SELECT EMP_NAME, REPLACE(EMP_NO,SUBSTR(EMP_NO,8,7),'*******')
FROM EMPLOYEE;

-- RPAD+SUBSTR+INSTR+LENGTH
SELECT EMP_NAME, REPLACE(EMP_NO,SUBSTR(EMP_NO,INSTR(EMP_NO,'-')+1,LENGTH(EMP_NO)/2),'*******')
FROM EMPLOYEE;

-- 방법3
-- REPLACE+SUBSTR+INSTR+LENGTH


-- 방법4
-- SUBSTR+연결연산자(||)
SELECT EMP_NAME, SUBSTR(EMP_NO, 1, 7) || '*******' 주민번호
FROM EMPLOYEE;



------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- 2) 숫자 관련 함수


-- ABS
-- 절대값 반환
SELECT ABS(FLOOR(1.234)) FROM DUAL;
-- 10.9	10.9	10	10
-- 전부 양수 출력
SELECT ABS(-10.9), ABS(10.9), ABS(-10) FROM DUAL;

-- MOD
-- 모듈러
-- 나머지 구하기
-- MOD(나눠지는수 ,나누는 수)

-- 1	-1	1	-1	1.9
-- 내가 나누어지는 수에 대한 부호를 따라가게 됨
SELECT MOD(10,3), MOD(-10,3), MOD(10,-3), MOD(-10,-3), MOD(10.9,3) FROM DUAL;


-- ROUND
-- 몇번째 자리에서 반올림할지 소수점 자리수 지정가능
-- 123.456
-- 123	124	123	123.5	123.46	120	100
-- 소수점 자리지정 반올림
-- 소수점 -의 반올림
SELECT ROUND(123.456,0),ROUND(123.456), ROUND(123.456,1),ROUND(123.456,2), ROUND(123.456,-1) FROM DUAL;
SELECT ROUND(123.456,-1), ROUND(123.456,-2) FROM DUAL;

-- -11
-- 마이너스(-)의 반올림은?
-- 마이너스는 숫자가 클수록 작은 수 ex) -11이 -10보다 작은 수
-- -10.61에서 .61이 5이상이라 반올림이 되는데 -11로



-- CEIL
-- 124
-- 무조건 1의 자리에서 올림하게 되어있음
-- 자릿수 지정 불가. 다른 인자값 집어넣으면 에러
SELECT CEIL(123.456) FROM DUAL;


-- FLOOR / TRUNC
-- FLOOR : 수학적 내림(배웠던 수학의 내림) // 자릿수 지정 불가
-- TRUNC : 버림. 절삭. 몇번째 자리까지 버리겠다 // 자릿수 지정가능
SELECT FLOOR(123.456), TRUNC(123.456) FROM DUAL;
SELECT FLOOR(123.456), TRUNC(123.456,1) FROM DUAL;

-- 123	123	123.7
-- TRUNC : 몇번째 자리까지 버리겠다 자릿수 지정가능
-- 파이썬에서 FLOOR가 -쪽으로 내리고 TRUNC가 0쪽으로 수렴하는 것과 같은 개념
-- math.trunc(-3.14)   #결과는 -3
-- math.floor(-3.14)   #결과는 -4

 

 

 

728x90
반응형
728x90

String 클래스

 

String Class의 메소드들

1)charAt ()

charAt(int index):char

 

2) concat()

concat(String str):String
원래 문자열 끝에 매개변수로 들어온 값을 이어붙인 문자열 반환

 

3) equals()

equals(Object anObject):boolean

 

4)substring()

substring(int beginIndex):String
해당 인덱스 넘버부터 문자열 시작
substring(int beginIndex, int endIndex):String

 

5)replace()

replace(char oldChar, char newChar):String

 

 

public class practice_everyday01 {
	public static void main(String[] args) {	
		
		// String class : representative methods
		String str = "힘을 내라";
		
		// 1)charAt ()
		// charAt(int index):char
		char cheer = str.charAt(0);
		System.out.println("1."+cheer); // 힘
		
		// 2) concat()
		// concat(String str):String
		// 원래 문자열 끝에 매개변수로 들어온 값을 이어붙인 문자열 반환
		String cstr = str.concat(" cheer up");
		System.out.println("2."+cstr );
		
		
		// 3) equals()
		// equals(Object anObject):boolean
		System.out.println("3."+str.equals("equal"));
		
		// 4)substring()
		// substring(int beginIndex):String
		// 해당 인덱스 넘버부터 문자열 시작
		// substring(int beginIndex, int endIndex):String
		// A to B 사이의 문자열 일부 반환
		
		System.out.println("4.1."+str.substring(0,3));
		System.out.println("4.2."+str.substring(2));
		
		
		// 5)replace()
		// replace(char oldChar, char newChar):String
		
		System.out.println("5."+str.replace('힘','손'));
	}	
}

 

 

728x90
반응형
728x90

 

연습문제 풀이

 

 



-- EMPLOYEE 테이블의 사번,이름,급여 조회
SELECT EMP_ID, EMP_NAME, SALARY FROM EMPLOYEEL

--EMPLOYEE 테이블의 모든 정보 조회
SELECT * FROM EMPLOYEE;

/*
-- 실습 문제 --
1.JOB 테이블의 모든 정보 조회
2.JOB 테이블의 직급 이름 조회
3.DEPARTMENT 테이블의 모든 정보 조회
4.EMPLOYEE 테이블의 직원명, 이메일, 전화번호, 고용일 조회
5.EMPLYEE 테이블의 고용일, 사원이름, 월급 조회
*/

--1.JOB 테이블의 모든 정보 조회
-- 방법1
SELECT * FROM JOB;

-- 방법2
SELECT JOB_CODE,JOB_NAME FROM JOB; 


--2.JOB 테이블의 직급 이름 조회
SELECT JOB_NAME FROM JOB;

--3.DEPARTMENT 테이블의 모든 정보 조회
-- 방법1
SELECT * FROM DEPARTMENT;

-- 방법2
SELECT DEPT_ID, DEPT_TITLE, LOCATION_ID FROM DEPARTMENT;

--4.EMPLOYEE 테이블의 직원명, 이메일, 전화번호, 고용일 조회
SELECT EMP_NAME,EMAIL,PHONE,HIRE_DATE FROM EMPLOYEE;

--5.EMPLYEE 테이블의 고용일, 사원이름, 월급 조회
SELECT HIRE_DATE, EMP_NAME,SALARY FROM EMPLOYEE;



--컬럼 값 산술 연산
--EMPLOYEE테이블에서 직원명, 연봉 조회(연봉 = 급여*12)
SELECT EMP_NAME, SALARY*12 연봉 FROM EMPLOYEE;

--EMPLOYEE테이블에서 직원명, 연봉, 보너스를 추가한 연봉 조회
-- 방법1
SELECT EMP_NAME, SALARY*12 연봉, SALARY*(1+BONUS) FROM EMPLOYEE;
--  수식에 NULL이 있으면 결과값에 NULL이 나옴 
-- 방법2
SELECT EMP_NAME 이름, SALARY * 12 연봉, SALARY*(1+BONUS)*12 AS 보너스
FROM EMPLOYEE;


/*
------------실습문제------------
1.EMPLOYEE테이블에서 이름, 연봉, 총수령액(보너스포함), 실수령액(총수령액-(연봉*세금3%)) 조회
2.EMPLOYEE테이블에서 이름, 고용일, 근무일수(오늘 날짜 - 고용일) 조회 
 - 오늘날짜 SYSDATE
*/
--(SALARY+SALARY*BONUS)*12
SELECT EMP_NAME 이름, SALARY * 12 연봉,SALARY *(1+BONUS)*12 "총수령액(보너스포함)", 
        SALARY *(1+BONUS)*12 - SALARY*12*0.03 AS 실수령액
FROM EMPLOYEE;




 

-- 컬럼 별칭
-- 컬럼명  AS 별칭 / 컬럼명 AS “별칭” / 컬럼명 별칭 / 컬럼명 “별칭”



/*
리터럴(literal)
값 자체 ‘ ‘

오라클에서는 문자,문자열,데이트 상관없이 다 싱글쿼테이션(’ ‘)으로 감싸준다
데이터 타입에 상관없이 별칭(””) 외에는 다 싱글쿼테이션으로 감싼다
*/ 

-- EMPLOYEE 테이블에서 직원의 직원 번호, 사원명, 급여, 단위 조회




-- 별칭 : "" 
-- 리터럴을 싱글쿼테이션으로 처리한다 : ' '
-- '원'이라는 컬럼을 보여주고 싶지않으면 더블쿼테이션""으로 단위써주자



-- EMPLOYEE테이블에서 직원의 직급 코드 조회

-- bang으로 시작하는 email 다 조회
-- 결과 : 방명수 bang ns@kh.kr
SELECT EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE 'bang%';

-- 결과 : 없음
SELECT EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE 'Bang%';
-- 리터럴은 대소문자 철저히 구별하기에 대문자 BANG으로 시작하는 EMAIL이 없어서 안나온 것



-- EMPLOYEE 테이블에서 직원의 부서 코드를 중복 없이 조회
SELECT DISTINCT DEPT_CODE
FROM EMPLOYEE;


-- DISTINCT는 한번만 쓸 수 있다
--SELECT DISTINCT DEPT_CODE, DISTINCT DEPT_CODE -- error
--FROM EMPLOYEE;



/*
SELECT 컬럼명 -- 조회하고자 하는 컬럼명 기술
FROM 테이블명 -- 조회하고자 하는 컬림이 포함된 테이블명 기술
WHERE 조건식; -- 행을 선택하는 조건 기술, 조건을 만족하는 행만 반환
             -- 조건식 복수로 붙여서 사용가능. 복수라도 WHERE절 한개만 기술


--비교연산자
>, <, >=, <=, = ,!= 

크다, 작다, 크거나 같다
같다 : =
같지않다 : != , ^= , <>
*/

--EMPLOYEE테이블에서 부서코드가 'D9'인 직원의 이름, 부서코드 조회
SELECT  EMP_NAME, DEPT_CODE
FROM EMPLOYEE
WHERE DEPT_CODE = 'D9';



-- '' 없이 D9만 쓰면 컬럼으로 인지하게 됨
-- 'd9'라고 써도 안됨. 리터럴은 대소문자 구분



--급여가 4000000이상인 직원의 이름, 급여 조회
-- ''로 감싸도 숫자로 인지잘한다. '' 없어도 됨
SELECT EMP_NAME, SALARY
FROM EMPLOYEE
WHERE SALARY >= 4000000;




-- EMPLOYEE테이블에서 부서코드가 D9이 아닌 사원의 사번, 이름, 부서코드조회
SELECT EMP_ID, EMP_NAME, DEPT_CODE
FROM EMPLOYEE
WHERE DEPT_CODE != 'D9';
--WHERE DEPT_CODE ^= 'D9';
--WHERE DEPT_CODE <> 'D9';



-- EMPLOYEE 테이블에서 퇴사 여부가 N인 직원을 조회하고 근무 여부를 재직중으로 표시
-- 사번,이름, 고용일, 근무여부 조회
SELECT EMP_ID, EMP_NAME, HIRE_DATE, '근무 여부' 재직중
FROM EMPLOYEE
WHERE ENT_YN = 'N';




-------------- 실습문제 --------------
--1.EMPLOYEE테이블에서 월급이 3000000이상인 사원의 이름, 월급, 고용일 조회
--2.EMPLOYEE테이블에서 SAL_LEVEL이 S1인 사원의 이름, 월급, 고용일, 연락처 조회
--3.EMPLOYEE테이블에서 실수령액(총수령액-(연봉*세금3%))이 5천만원 이상인 
--  사원의 이름, 급여, 실수령액, 고용일 조회

SELECT EMP_NAME, SALARY, HIRE_DATE
FROM EMPLOYEE
WHERE SALARY >= 3000000;

SELECT EMP_NAME, SALARY, HIRE_DATE, PHONE
FROM EMPLOYEE
WHERE SAL_LEVEL = 'S1';

SELECT EMP_NAME, SALARY, SALARY+SALARY*(SALARY*BONUS)-(SALARY*12*0.03)실수령액, HIRE_DATE
FROM EMPLOYEE
WHERE SALARY+SALARY*(SALARY*BONUS)-(SALARY*12*0.03) >= 5000000;

------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------



-- 논리 연산자 AND OR
-- EMPLOYEE 테이블에서 부서코드가 D6이고 급여를 3000000보다 많이 받는 직원의 이름, 부서코드, 급여 조회
SELECT EMP_NAME, DEPT_CODE,SALARY  
FROM EMPLOYEE
WHERE DEPT_CODE = 'D6' AND SALARY > 3000000;


-- EMPLOYEE 테이블에서 부서코드가 D6이거나 급여를 3000000보다 많이 받는 직원의 이름,부서코드, 급여조회
SELECT  EMP_NAME, DEPT_CODE,SALARY 
FROM EMPLOYEE
WHERE   DEPT_CODE = 'D6' OR SALARY > 3000000;




-- 1.EMPLOYEE 테이블에서 월급이 4000000이상이고 JOB_CODE가 J2인 사원의 전체 내용 조회
-- 2.EMPLOYEE 테이블에 DEPT_CODE가 D9이거나 D5인 사원 중에 고용일이 02년 1월 1일보다 빠른 사원의
--   이름, 부서코드, 고용일 조회
SELECT *  
FROM EMPLOYEE
WHERE SALARY >= 4000000 AND JOB_CODE ='J2';

SELECT EMP_NAME, DEPT_CODE, HIRE_DATE
FROM EMPLOYEE
WHERE DEPT_CODE = 'D9' OR HIRE_DATE < '02/01/01';

--- 다시풀이
SELECT *
FROM EMPLOYEE
WHERE SALARY >= 4000000 AND JOB_CODE = 'J2';

SELECT  EMP_NAME, DEPT_CODE, HIRE_DATE 
FROM EMPLOYEE
WHERE  (DEPT_CODE = 'D9' OR DEPT_CODE = 'D5')
        AND HIRE_DATE < '02/01/01' ;

-- 이 코드는 틀린 코드
-- 기준일보다 작은게 빠른 것. 오늘보다 내일이 더 큰 숫자
-- 날짜를 기준으로 조건식을 쓴다면 ''로 감싸줘야한다
-- 자바나 SQL이나 OR AND는 AND가 우선순위로 먼저 연산
-- OR를 먼저 연산하고 싶다면 소괄호를 쳐줄 것





------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------


-- BETWEEN AND
-- ~이상 ~이하

-- EMPLOYEE 테이블에서 급여를 3500000이상 6000000이하를 받는 사원의 사번, 이름, 급여, 부서코드, 직급코드 조회
SELECT EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE
FROM EMPLOYEE  
WHERE SALARY >= 3500000 AND SALARY <= 6000000;

SELECT EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE
FROM EMPLOYEE 
WHERE SALARY BETWEEN 3500000 AND 6000000;

---다시 풀이
SELECT  EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE 
FROM EMPLOYEE
WHERE SALARY BETWEEN 3500000 AND 6000000;
SELECT  EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE 
FROM EMPLOYEE
WHERE SALARY>=3500000 AND SALARY <=6000000;


-- 반대로 급여를 3500000미만 6000000초과를 받는 사원의 사번, 이름, 급여, 부서코드, 직급코드 조회
SELECT EMP_ID, EMP_NAME, SALARY, DEPT_CODE, JOB_CODE
FROM EMPLOYEE
--WHERE SALARY < 3500000 OR SALARY > 6000000; 
--WHERE SALARY NOT BETWEEN 3500000 AND 6000000;
WHERE NOT SALARY BETWEEN 3500000 AND 6000000;

-------실습문제-------
-- 1.EMPLOYEE 테이블에 고용일이 90/01/01 ~ 01/01/01인 사원의 전체 내용을 조회
-- 시간의축을 가로선상에 놓고 보면 시간과 연산자 사용계산이 쉬워짐

SELECT *
FROM EMPLOYEE
WHERE HIRE_DATE >= '90/01/01' AND HIRE_DATE <= '01/01/01';

SELECT *
FROM EMPLOYEE
WHERE HIRE_DATE BETWEEN '90/01/01' AND  '01/01/01';

-- WHERE HIRE_DATE >= '90/01/01' AND HIRE_DATE <= '01/01/01';

---다시풀이
SELECT *
FROM EMPLOYEE
WHERE HIRE_DATE BETWEEN '90/01/01' AND '01/01/01';
SELECT *
FROM EMPLOYEE
WHERE HIRE_DATE >= '90/01/01' AND HIRE_DATE <='01/01/01';


------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------

/*
-- LIKE
비교하려는 값이 특정 패턴을 만족시키는지 조회
ex) 이멜에 i가 들어가는 것을 조회, 이름이 김씨가 들어간 사람들 조회

와일드카드 2종류
 _ : 1글자
 % : 0글자 이상

ex)
'_' (한글자)
'__' (두글자)
'___' (세글자)

 '글자%' : 글자로 시작하는 값
    글자 뒤로 뭐가와도 ok
    ex) 글자최고, 글자(공백), 글자왕, 글자
 '%글자' : 글자로 끝나는 값
    글자 앞에 뭐가와도 ok
    ex) 먹글자, 한글은 글자, (공백)글자
 '글%자' : 글로 시작해서 자로 끝나는 값
    글과 자 사이 뭐가와도 ok
    ex)글씨를 잘쓰자, 글자, 글과자, 글(공백)자
 '%글자%' : 글자가 포함되어있는 값
        ex) 한글자값, 먹글자, 글자, 한두글자

*/

--EMPLOYEE 테이블에서 성이 전씨인 사원의 사번, 이름, 고용일 조회
SELECT EMP_ID, EMP_NAME, HIRE_DATE
FROM EMPLOYEE
WHERE EMP_NAME LIKE '전%';
-- WHERE EMP_NAME LIKE '전__';
-- 도 가능하나 이름이 세글자인 사람들만 가능해서 이름이 두글자나 네글자이상이면 정확도가 떨어짐



--EMPLOYEE 테이블에서 이름이 '하'가 포함된 직원의 이름, 주민번호, 부서코드 조회
SELECT EMP_NAME, EMP_NO, DEPT_CODE
FROM EMPLOYEE
WHERE EMP_NAME LIKE '%하%';


--EMPLOYEE 테이블에 전화번호 4번째 자리가 9로 시작하는 사원의 사번, 이름, 전화번호 조회
-- 전번 양식 : 01012345678
-- 01X 세자리 + 9로 시작하는 네번지째 자릿수
SELECT EMP_ID, EMP_NAME, PHONE
FROM EMPLOYEE
WHERE PHONE LIKE '___9%';

---RE
SELECT EMP_ID, EMP_NAME,PHONE
FROM EMPLOYEE
WHERE PHONE LIKE '___9%';


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

--RE
SELECT EMP_ID, EMP_NAME, EMAIL
FROM EMPLOYEE
WHERE EMAIL LIKE '___!_%' ESCAPE '!';



/*
LIKE를 쓸 때 패턴!
와일드카드 : _ %
각각 한글자,와 0글자 이상을 나타내는 와일드 카드

세글자 자릿수 언더바 3개 + 검색하고자 하는 데이터로의 언더바 1개 = 총4개의 언더바
검색하고자 하는 패턴의 문자와 와일드 카드가 일치할 경우에는 패턴과 와일드 카드를 구분하지 못하기 때문에
ESCAPE OPTION을 통해 구분해준다
 - 패턴(데이터)으로 쓸 것 앞에 구분기호 사용

*/


------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------



--  ESCAPE 식별자

-- EMPLOYEE테이블에서 김씨 성이 아닌 직원의 사번, 이름, 고용일 조회
SELECT EMP_ID, EMP_NAME, HIRE_DATE
FROM EMPLOYEE
--WHERE EMP_NAME NOT LIKE '김%';
WHERE NOT EMP_NAME LIKE '김%';

---RE
SELECT EMP_ID, EMP_NAME, HIRE_DATE
FROM EMPLOYEE
WHERE EMP_NAME NOT LIKE '김%';

--WHERE NOT EMP_NAME LIKE '김%';
-- NOT 순서 : 해당 컬럼명 앞뒤 둘 다 가능

/*
WHERE EMP_NAME != '김%'; 
 = 혹은 != '김%'으로 검색하면 '김%' 데이터자체를 검색
LIKE '김%' 뒤에 어떤게 오든 상관없다
LIKE와 사용하는 % _ 는 와일드카드 적용받는다    
    LIKE는 문자에 대한 패턴 검색하는 것

!= '김%'에서는 이름이 김%인 사람을 찾는 것(리터럴 김% 데이터를 찾는 것)
    여기서 %는 와일드카드로 적용이 되지 않고 그냥 순수 기호 %인 것

*/

-----------실습문제-----------
--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 HIRE_DATE <= '00/12/01')
        AND HIRE_DATE BETWEEN '90/01/01' AND '00/12/01'
        AND SALARY >= 2700000;


---RE
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 BETWEEN '90/01/01' AND '00/12/01'
            AND SALARY >= 2700000;

------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- IS NULL
-- IS NOT NULL
-- 컬럼값이 NULL이냐
-- 컬럼값이 NULL이 아니냐

--EMPLOYEE 테이블에서 보너스를 받지 않는 사원의 사번, 이름, 급여, 보너스 조회
SELECT EMP_ID, EMP_NAME,SALARY,BONUS
FROM EMPLOYEE
WHERE BONUS IS NULL;
---RE
SELECT EMP_ID, EMP_NAME,SALARY,BONUS
FROM EMPLOYEE
WHERE BONUS IS NULL;

--WHERE BONUS = NULL; 값 안나옴
--WHERE BONUS = (null); 값 안나옴

--EMPLOYEE 테이블에서 보너스를 받는 사원의 사번, 이름, 급여, 보너스 조회
SELECT EMP_ID, EMP_NAME,SALARY,BONUS
FROM EMPLOYEE
WHERE BONUS IS NOT NULL;
WHERE NOT BONUS IS NULL;
---RE
SELECT EMP_ID, EMP_NAME,SALARY,BONUS
FROM EMPLOYEE
WHERE BONUS IS NOT NULL;

-- WHERE NOT BONUS IS NULL; 
-- NOT은 컬렴명 앞에 붙어도 가능

--WHERE BONUS NOT LIKE '%(null)%';


-- EMPLOYEE 테이블에서 관리자도 없고 부서 배치도 받지 않은 직원의 이름, 관리자, 부서코드 조회
-- EMPLOYEE 테이블에서 부서 배치를 받지 않았지만 보너스를 지급받는 직원의 이름,  보너스, 부서코드 조회
SELECT EMP_NAME, MANAGER_ID, DEPT_CODE
FROM EMPLOYEE
WHERE MANAGER_ID IS NULL AND DEPT_CODE IS NULL;


SELECT EMP_NAME, BONUS, DEPT_CODE
FROM EMPLOYEE
WHERE DEPT_CODE IS NULL AND BONUS IS NOT NULL;

---RE
SELECT EMP_NAME, MANAGER_ID, DEPT_CODE
FROM EMPLOYEE
WHERE MANAGER_ID IS NULL AND DEPT_CODE IS NULL;

SELECT EMP_NAME, BONUS, DEPT_CODE
FROM EMPLOYEE 
WHERE DEPT_CODE IS NULL AND BONUS IS NOT NULL;


------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------


--IN
-- 목록에 일치하는 값이 있으면 TRUE가 되어 값 반환
-- 목록에 일치하는 값이 있으면 TRUE를 반환


-- D6부서와 D9부서원들의 이름, 부서코드, 급여 조회
-- 직급코드가 J1, J2, J3, J4인 사람들의 이름, 직급코드, 급여 조회
SELECT EMP_NAME, DEPT_CODE, SALARY
FROM EMPLOYEE
WHERE DEPT_CODE = 'D6' OR DEPT_CODE = 'D9';

SELECT EMP_NAME, JOB_CODE, SALARY
FROM EMPLOYEE
--WHERE JOB_CODE = 'J1' OR JOB_CODE = 'J2' OR JOB_CODE = 'J3' OR JOB_CODE =  'J4';
WHERE JOB_CODE IN ('J1','J2','J3','J4'); 

---RE
SELECT EMP_NAME, DEPT_CODE, SALARY
FROM EMPLOYEE
WHERE JOB_CODE IN ('J1','J2','J3','J4');


-- 소괄호로 처음 들어가서 D6를 맞딱들이고 각 조건 체크해서 반환. 다음 D9체크



------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------


-- 연결 연산자 ||
-- 자바에서의 or논리연산자의 기호가 SQL에서는 연결연산자
-- EMPLOYEE테이블에서 사번, 이름, 급여를 연결해서 조회 (EX. 200선동일8000000)
SELECT EMP_ID || EMP_NAME || SALARY 급여
FROM EMPLOYEE;


-- EMPLOYEE테이블에서 ' "사원명"의 월급은 "급여"원입니다' 형식으로 조회
SELECT EMP_NAME ||'명의 월급은' || SALARY ||'원 입니다'
FROM EMPLOYEE;
-- 문장으로 쓰고 싶을 경우 필요

---RE
SELECT EMP_NAME, EMAIL || ' 이메일 주소 '||'힘내'
FROM EMPLOYEE;


------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------




--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';
WHERE JOB_CODE IN ('J1','J2','J3','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;

 

 

 

 

728x90
반응형
728x90

 

 

 바이트 기반+보조 스트림
FileOutputStream, BufferedOutputStream 클래스

FileInputStream, BufferedInputStream 클래스

try catch

 

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class practice_everyday09 {
		
		// 1.바이트 기반+보조
		// 2.문자 기반+보조
		
		
		// 1.바이트 기반+보조 : 입력
	public void Stream_outputByte() {
		// 목적 : 파일에 바이트기반으로 데이터를 빠르게 쓰고 싶다
		FileOutputStream fos;
		BufferedOutputStream bos = null;
		try {
			fos = new FileOutputStream("D:\\test\\test.txt");
			bos = new BufferedOutputStream(fos);
			
			bos.write(65);
			byte[] arr = {66,67,68,69};
			bos.write(arr);
			
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void Stream_inputByte() {
		// 목적 :파일에 있는 데이터를 바이트 기반으로 빠르게 읽어오고 싶다
		FileInputStream fis;
		try {
			fis = new FileInputStream("D:\\test\\test.txt");
			BufferedInputStream bis = new BufferedInputStream(fis);
			
			int val;
			while((val=bis.read()) != -1) {
				System.out.println(val);
			}	
		} catch (IOException e) { // IOE
			e.printStackTrace();
		}
	}	
}

 

 

 

728x90
반응형
728x90

 

 

 

import java.util.Arrays;

public class Array_review2 {
	public static void main(String[] args) {
		
		// 배열
		// 같은 자료형의  여러  데이터 값을 저장할 수 있는 공간
		
		// 배열 선언
		int[] arr;
		
		// 배열 할당
		int[] arr2 = new int[3];
		int arr3[] = new int[3];
		
		// 배열 초기화
		// 1)인덱스
		// 2)중괄호 {}
		// 3)for문 이용
		
		// 1)인덱스
		arr2[0] = 1;
		arr2[1] = 2;
		arr2[2] = 3;
		
		// 2)중괄호 {}
//		int arr3[] = {1,2,3}; // error
		int[] arr4 = {4,5,6};
//		arr4 = {1,2,3}; // error
		char[] arr5 = {'A','B'};
		
		// 3)for문
		// 초기화할 값에 ‘규칙’이 존재할 경우 사용가능
//		char[] Arr = new char[3]; // for문 인덱스 이용한거라 int만 가능
		int[] Arr2 = new int[3];
		for(int i=0; i<Arr2.length; i++) {
			System.out.print(Arr2[i]+" "); // 0 0 0
		} // 배열값을 안 넣어놔서 int의 기본값인 0 출력됨
		System.out.println();
		
		int[] Arr3 = new int[4];
		for(int i=0; i<Arr3.length; i++) {
			Arr3[i] = i+1;
			System.out.print(Arr3[i]+" "); // 1 2 3 4
		} // 배열값을 안 넣어놔서 int의 기본값인 0 출력됨
		System.out.println();
		
		
		// 배열 수정(크기 변경)?
		int[] aaa = new int[2];
		aaa[0] = 0;
		aaa[1] = 1;
		
		System.out.println(aaa);//[I@6d06d69c
		
		aaa = new int[3];
		System.out.println(aaa);//[I@7852e922
		
		// 다른 주소값이 나왔다. 보이기에는 길이가 수정된 것처럼 보이나
		// 실제로는 새로 만든 값으로 대체시킨 것
		
		
		// 배열 삭제
		aaa = null;
		System.out.println(aaa);
		
		Arr3 = null;
		System.out.println(Arr3);
		
		
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
		
		
		// 배열 복사
		// 1)얕은 복사(shallow copy)
		// 2)깊은 복사(deep copy)
		
		// 1)얕은 복사(shallow copy)
		String[] str1 = new String[3];
		String[] str2 = str1;
		
		// arr5의 주소값이 arr6로 그대로 들어가기 때문에 주소값 자체도 복사된다
		// 즉 arr5와 arr6는 같은 주소값을 갖으며,
		// 같은 주소값을 참조하기에 같은 값을 공유하게 된다
		
		// 검증
		System.out.println(str1);//[Ljava.lang.String;@4e25154f
		System.out.println(str2);//[Ljava.lang.String;@4e25154f
		// 같은 주소값 확인

		str1[0] = "A";
		str1[1] = "b";
		str1[2] = "b";

		for(int i=0; i<str1.length; i++) {
			System.out.print(str1[i]+" "); // A b b
		}
		System.out.println();
		for(int i=0; i<str2.length; i++) {
			System.out.print(str2[i]+" "); // A b b
		}
		System.out.println();
		// 원본과 클론 배열 둘의 주소값,값이 동일
		
		// 원본 값을 바꿔서 둘의 차이가 있는지 확인해보자
		str1[1] = "asdf";
		
		for(int i=0; i<str1.length; i++) {
			System.out.print(str1[i]+" "); // A asdf b 
		}
		System.out.println();
		for(int i=0; i<str2.length; i++) {
			System.out.print(str2[i]+" "); // A asdf b 
		}
		System.out.println();
		// 원본과 클론 배열 둘의 주소값,값이 여전히 동일
		
		
		//2)깊은 복사
		// 새로운 배열을 만들어 기존 데이터를 모두 복사해오는 것
		// 방법1:for문
		// 방법2:System.arraycopy()
		// 방법3:Arrays.copyOf()
		
		// 방법1:for문
		int[] srcArr1 = {5,10,15};
		int[] copyArr1 = new int[4];
		
		for(int i=0; i<srcArr1.length;i++) {
			copyArr1[i] = srcArr1[i];
			System.out.print(copyArr1[i]+" ");// 5 10 15 
		}
		
		// 검증
		// 주소값+값 비교
		System.out.println(srcArr1); // [I@70dea4e
		System.out.println(copyArr1);// [I@5c647e05
		// 주소값 다름
		for(int i=0; i<srcArr1.length; i++) {
			System.out.print(srcArr1[i]+" "); // 5 10 15  
		}
		System.out.println();
		for(int i=0; i<copyArr1.length; i++) {
			System.out.print(copyArr1[i]+" "); // 5 10 15 0  
		}
		System.out.println();
		// 값 자체도 다르다
		
		// 원본 값을 바꿔서 둘의 차이가 있는지 확인해보자
		srcArr1[0] = 20;
		System.out.println(srcArr1); // [I@70dea4e
		System.out.println(copyArr1);// [I@5c647e05
		// 원본 값 변경 후, 주소값 다름

		for(int i=0; i<srcArr1.length; i++) {
			System.out.print(srcArr1[i]+" ");  // 20 10 15 
		}
		System.out.println();
		for(int i=0; i<copyArr1.length; i++) {
			System.out.print(copyArr1[i]+" "); // 5 10 15 0  
		}
		System.out.println();
		// 원본 값 변경 후, 서로 값 영향x
		// 얕은 복사로 원본과 카피가 값이 같아졌지만 주소값은 여전히 다름
		
		
		// 방법2:System.arraycopy()
		// 배열길이 자동 수정x
		// 복사된 값의 나머지 공간은 해당 배열의 데이터 타입의 기본값으로 채워진다
		// ex)
		// int 배열값을 복사하고 나머지 공간은 0으로 채워진다
		// double  배열값을 복사하고 나머지 공간은 0.0
		// char 배열값을 복사하고 나머지 공간은 공백
		// String 배열값을 복사하고 나머지 공간은 null
		//
		// System.arraycopy(src, srcPos, dest, destPos, length)
		// src : 원본 배열
		// srcPos : 포지션. 원본배열에서 복사를 시작할 위치
		// dest : 복사 배열
		// destpos: 복사 배열에서 붙여놓기를 시작할 위치
		// length : 얼만큼 복사를 해올지에 대한 복사 길이
		
		int[] srcArr2 = {5,10,15};
		int[] copyArr2 = new int[4];
		
		System.arraycopy(srcArr2, 2, copyArr2, 1, 1);
		
		System.out.println(srcArr2); // [I@33909752
		System.out.println(copyArr2);// [I@55f96302
		// 주소값 다름
		
		for(int i=0; i<srcArr2.length; i++) {
			System.out.print(srcArr2[i]+" ");  // 5 10 15 
		}
		System.out.println();
		for(int i=0; i<copyArr2.length; i++) {
			System.out.print(copyArr2[i]+" "); // 0 15 0 0 
		}
		System.out.println();
		
		
		// int 배열
		int[] srcArr22 = {5,10,15};
		int[] copyArr22 = new int[4];
		System.arraycopy(srcArr22, 0, copyArr22, 0, srcArr22.length);
		
		for(int i=0; i<srcArr22.length; i++) {
			System.out.print(srcArr22[i]+" ");  // 5 10 15 
		}
		System.out.println();
		for(int i=0; i<copyArr22.length; i++) {
			System.out.print(copyArr22[i]+" "); // 5 10 15 0 
		}										// 남은 공간에 인트 기본값 0
		System.out.println();
		
		
		// double 배열
		double[] dSrcArr = {1.1,2.2,3.3};
		double[] dcopyArr = new double[5];
		System.arraycopy(dSrcArr, 0, dcopyArr, 2, dSrcArr.length);
		
		for(int i=0; i<dSrcArr.length; i++) {
			System.out.print(dSrcArr[i]+" ");  // 1.1 2.2 3.3  
		}
		System.out.println();
		for(int i=0; i<dcopyArr.length; i++) {
			System.out.print(dcopyArr[i]+" "); // 0.0 0.0 1.1 2.2 3.3 
		}									   // 남은 공간에 double 기본값 0.0
		System.out.println();
		
		
		// char 배열
		char[] cSrcArr = {'a','b','c'};
		char[] cCopyArr = new char[5];
		System.arraycopy(cSrcArr, 0, cCopyArr, 2, cSrcArr.length);

		for(int i=0; i<cSrcArr.length; i++) {
			System.out.print(cSrcArr[i]+" ");  // a b c 
		}
		System.out.println();
		for(int i=0; i<cCopyArr.length; i++) {
			System.out.print(cCopyArr[i]+" "); //      a b c 
		}									   // 남은 공간에 char 기본값  (공백)
		System.out.println();
		
		
		// String 배열
		String[] sSrcArr = {"어깨","팔","등"};
		String[] sCopyArr = new String[5];
		System.arraycopy(sSrcArr, 0, sCopyArr, 2, sSrcArr.length);		
		
		for(int i=0; i<sSrcArr.length; i++) {
			System.out.print(sSrcArr[i]+" ");  // 어깨 팔 등 
		}
		System.out.println();
		for(int i=0; i<sCopyArr.length; i++) {
			System.out.print(sCopyArr[i]+" "); // null null 어깨 팔 등 
		}									   // 남은 공간에 String(참조형) 기본값  null
		System.out.println();
		
		
		// 방법3:Arrays.copyof()
		
		// Arrays.copyOf(original, newLength)
		// - original : 원본
		// - newLength : 얼마만큼 복사할지
		// 배열 길이만큼 복사해오기에 System.arraycopy()처럼 공간이 남지않는다
		// 원본 길이보다 길게 복사할 경우, 남는 공간은 원본의 데이터타입 기본값으로 채운다
		
		int[] aSrcArr = {1,2,3};
		int[] aCopyArr = new int[5];
		aCopyArr = Arrays.copyOf(aSrcArr, 6);
		
		for(int i=0; i<aSrcArr.length; i++) {
			System.out.print(aSrcArr[i]+" ");  // 1 2 3 
		}
		System.out.println();
		for(int i=0; i<aCopyArr.length; i++) { // 자동 길이추가
			System.out.print(aCopyArr[i]+" "); // 1 2 3 0 0 0 
		}									   // 남은 공간에 int 기본값 0
		System.out.println();
		
		
		// int타입
		// 여분 : 0
		int[] aSrcArr2 = {1,2,3};
		int[] aCopyArr2 = new int[5];
		aCopyArr2 = Arrays.copyOf(aSrcArr2, 7);
		
		for(int i=0; i<aSrcArr2.length; i++) {
			System.out.print(aSrcArr2[i]+" ");  // 1 2 3 
		}
		System.out.println();
		for(int i=0; i<aCopyArr2.length; i++) { // 자동 길이추가
			System.out.print(aCopyArr2[i]+" "); // 1 2 3 0 0 0 0 
		}									   // 남은 공간에 int 기본값 0
		System.out.println();
		
		// double타입
		// 여분 : 0.0d
		double[] dSrcArr2 = {1.1,2.2,3.3};
		double[] dCopyArr2 = new double[5];
		dCopyArr2 = Arrays.copyOf(dSrcArr2, 7);
		
		for(int i=0; i<dSrcArr2.length; i++) {
			System.out.print(dSrcArr2[i]+" ");  // 1.1 2.2 3.3
		}
		System.out.println();
		for(int i=0; i<dCopyArr2.length; i++) { // 자동 길이추가
			System.out.print(dCopyArr2[i]+" "); // 1.1 2.2 3.3 0.0 0.0 0.0 0.0   
		}									   // 남은 공간에 int 기본값 0
		System.out.println();
		
		// char타입
		// 여분 : (공백)
		char[] cSrcArr2 = {'A','B','C'};
		char[] cCopyArr2 = new char[5];
		cCopyArr2 = Arrays.copyOf(cSrcArr2, 6);
		
		for(int i=0; i<cSrcArr2.length; i++) {
			System.out.print(cSrcArr2[i]+" ");  // A B C 
		}
		System.out.println();
		for(int i=0; i<cCopyArr2.length; i++) { // 자동 길이추가
			System.out.print(cCopyArr2[i]+" "); // A B C          (공백)
		}									   // 남은 공간에 int 기본값 0
		System.out.println();
		
		
		// String
		// 여분 : null
		String[] sSrcArr2 = {"사레레","케푸다","라트익"};
		String[] sCopyArr2 = new String[6];
		sCopyArr2 = Arrays.copyOf(sSrcArr2, 6);
		
		for(int i=0; i<sSrcArr2.length; i++) {
			System.out.print(sSrcArr2[i]+" ");  // A B C 
		}
		System.out.println();
		for(int i=0; i<sCopyArr2.length; i++) { // 자동 길이추가
			System.out.print(sCopyArr2[i]+" "); // 사레레 케푸다 라트익 
		}									   // 사레레 케푸다 라트익 null null null 
		System.out.println();
		
		
	}
	
}

 

 

 

 

 

728x90
반응형
728x90

 

 



--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;

 

728x90
반응형
728x90


728x90
반응형

'small steps > 운동 - 체력이 국력' 카테고리의 다른 글

22.03.17 운동기록  (0) 2022.03.17
22.03.15 운동기록  (0) 2022.03.16
22.03.11 운동기록  (0) 2022.03.12
22.03.10 운동기록  (0) 2022.03.11
22.03.08 운동기록  (0) 2022.03.09
728x90

 

배열 복사 - deep copy - System.arraycopy()

System.arraycopy()

 

System.arraycopy(src, srcPos, dest, destPos, length)

src : 원본 배열
srcPos : 포지션. 원본배열에서 복사를 시작할 위치
dest : 복사 배열
destpos: 복사 배열에서 붙여놓기를 시작할 위치
length : 얼만큼 복사를 해올지에 대한 복사 길이

		int[] sourceArr = {10,20,30};
		int[] copyArr = new int[6];
        
        System.arraycopy(sourcArr, 0 , copyArr, 0, 3);

 

 

배열길이 자동 수정x

복사된 값의 나머지 공간은 해당 배열의 데이터 타입의 기본값으로 채워진다

ex)

int 배열값을 복사하고 나머지 공간은 0으로 채워진다
double 배열값을 복사하고 나머지 공간은 0.0
char 배열값을 복사하고 나머지 공간은 공백
String 배열값을 복사하고 나머지 공간은 null

 

 

// 방법2:System.array.copy()
		// 배열길이 자동 수정x
		// int 배열값을 복사하고 나머지 공간은 0으로 채워진다
		// double 배열값을 복사하고 나머지 공간은 0.0
		// char 배열값을 복사하고 나머지 공간은 공백
		// String 배열값ㅇ르 복사하고 나머지 공간은 null
		//
		// System.arraycopy(src, srcPos, dest, destPos, length)
		// src : 원본 배열
		// srcPos : 포지션. 원본배열에서 복사를 시작할 위치
		// dest : 복사 배열
		// destpos: 복사 배열에서 붙여놓기를 시작할 위치
		// length : 얼만큼 복사를 해올지에 대한 복사 길이
		
		
		int[] sourceArr3 = {10,20,30};
		int[] cloneArr3 = new int[3];
		 
		System.arraycopy(sourceArr3, 0, cloneArr3, 0, cloneArr3.length);
		System.out.println(sourceArr3);
		for(int i=0;i<sourceArr3.length;i++) {
			System.out.print(sourceArr3[i]+" "); // 10 20 30
		} 										 // 원본 값
		System.out.println();
		for(int i=0;i<cloneArr3.length;i++) {
			System.out.print(cloneArr3[i]+" ");  // 10 20 30
		} 										 // 클론 값
		System.out.println();
		
		int[] sourceArr4 = {10,20,30,40,50};
		int[] cloneArr4 = new int[3];
		 
		System.arraycopy(sourceArr4, 0, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스0번부터4번까지 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 10 20 30
		} 										// 클론값
		// 
		System.out.println();
		
		System.arraycopy(sourceArr4, 2, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스2번부터4번까지 30 40 50의 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 30 40 50 
		} 										// 클론값
		// 
		System.out.println();
		
		
		
		int[] a = {2,4,6,8,10};
		int[] b = new int [10];
		
		System.arraycopy(a, 3, b, 0, 2);
		// dest의 범위가 0-5까지는 잘나오고 6부터 error
		for(int i=0; i<a.length;i++) {
			System.out.print(a[i]+" "); // 2 4 6 8 10 
		}								// 원본값
		System.out.println();
		for(int i=0; i<b.length;i++) {
			System.out.print(b[i]+" "); // 8 10 0 0 0 0 0 0 0 0 
		}								// 카피값
		System.out.println();
		
		// int 배열
		int[] src = {3,6,9,12};
		int[] clone = new int[8];
		
		System.arraycopy(src, 2, clone, 6, 2);
		// src 2번인덱스부터 길이2를 복사해서 9,12값을 clone의 6번째부터 복사
		for(int i=0; i<src.length;i++) {
			System.out.print(src[i]+" "); // 3 6 9 12 
		}								  // 원본값
		System.out.println();
		for(int i=0; i<clone.length;i++) {
			System.out.print(clone[i]+" ");// 0 0 0 0 0 0 9 12 
		}								   // 카피값
		System.out.println();
		
		int[] src2 = {3,6,9,12};
		int[] clone2 = new int[8];
		System.arraycopy(src2, 2, clone2, 5, 2);
		for(int i=0; i<clone2.length;i++) {
			System.out.print(clone2[i]+" ");// 0 0 0 0 0 9 12 0  
		} // 복사되고 int배열의 공백은 0으로 채워진다       // 카피값
		System.out.println();
		
		
		// double 배열
		double[] dSrc = {1.0,1.5,2.0,2.5};
		double[] dCopy = new double[8];
		
		System.arraycopy(dSrc, 0, dCopy, 4, dSrc.length);
		for(int i=0;i<dCopy.length;i++) {
			System.out.print(dCopy[i]+" ");//0.0 0.0 0.0 0.0 1.0 1.5 2.0 2.5  
		}								   // 복사된 값 외에 나머지 공간 : 0.0
		System.out.println();
		
		// char 배열
		char[] cSrc = {'a','b','c'};
		char[] cCopy = new char[6];
		
		System.arraycopy(cSrc, 0, cCopy, 0, cSrc.length);
		for(int i=0;i<cCopy.length;i++) {
			System.out.print(cCopy[i]+" ");//a b c (공백)
		}								   // // 복사된 값 외에 나머지 공간 : 공백
		System.out.println();
		
		// String 배열
		String[] sSrc = {"A","B","C"};
		String[] sCopy = new String[6];
		
		System.arraycopy(sSrc, 0, sCopy, 0, sSrc.length);
		for(int i=0;i<sCopy.length;i++) {
			System.out.print(sCopy[i]+" ");// A B C null null null 
		}								   // 복사된 값 외에 나머지 공간 : null
		System.out.println();

 

 

 

 

 

 

 

728x90
반응형
728x90



728x90
반응형

'small steps > 운동 - 체력이 국력' 카테고리의 다른 글

22.03.15 운동기록  (0) 2022.03.16
22.03.12 운동기록  (0) 2022.03.13
22.03.10 운동기록  (0) 2022.03.11
22.03.08 운동기록  (0) 2022.03.09
22.03.07 운동기록  (0) 2022.03.08
728x90

 

배열의 복사는 두가지 타입이 있다

1.얕은 복사(shallow copy)

2.깊은 복사(deep copy)

 

 

1.얕은 복사(shallow copy)

int[] sArr = {1,2,3};
int[] cArr = sArr;

주소값 동일 (같은 주소값 참조)

 

2.깊은 복사(deep copy)

새로운 배열을 만들어 기존 데이터를 모두 복사해오는 것

새로 만들어 복사하기에 원본과 복사본의 주소값이 다르고, 원본값이 변해도 복사본에 영향x

 

deep copy의 방법3가지

1) for문

2) System.arraycopy()

3) Arrays.copyof()

 

 

1)for문

int[] sourceArr = {10,20,30};
int[] copyArr = new int[3];

for(int i=0; i<sourceArr.length; i++) {
			copyArr[i] = sourceArr[i]; 
}

 

 

2) System.arraycopy()

System.arraycopy(src, srcPos, dest, destPos, length);

src : 원본 배열

srcPos : 포지션. 원본배열에서 복사를 시작할 위치

dest : 복사 배열

destpos: 복사 배열에서 붙여놓기를 시작할 위치

length : 얼만큼 복사를 해올지에 대한 복사 길이

 

int[] sArr = {1,2,3};
int[] cArr = new int[6];

System.arraycopy(sArr, 0, cArr, 0, sArr.length);

 

복사된 값의 나머지 공간은 해당 배열의 데이터 타입의 기본값으로 채워진다

ex)

int 배열값을 복사하고 나머지 공간은 0으로 채워진다

double 배열값을 복사하고 나머지 공간은 0.0

char 배열값을 복사하고 나머지 공간은 공백

String 배열값을 복사하고 나머지 공간은 null

 

 

3) Arrays.copyof()

Arrays.copyOf(original, newLength)

 - original : 원본

 - newLength : 얼마만큼 복사할지

int[] sArr = {1,2,3};
int[] cArr = new int[6];

cArr = Arrays.copyof(sArr, 3);

 

배열 길이 자동 수정 O

배열 길이만큼 복사해오기에 System.arraycopy()처럼 공간이 남지않는다

원본 길이보다 길게 복사할 경우, 남는 공간은 원본의 데이터타입 기본값으로 채운다

 

 

 

전체코드

import java.util.Arrays;

public class Array_review {
	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로 바뀌면서 연결된 값도 끊어지면서
		// 사실상 삭제 효과가 나타난다
		
		
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
		
		
		// 배열 복사
		// 1)얕은 복사(shallow copy)
		// 2)깊은 복사(deep copy)
		
		// 1)얕은 복사(shallow copy)
		int[] arr5 = new int[2];
		int[] arr6 = arr5;
		// arr5의 주소값이 arr6로 그대로 들어가기 때문에 주소값 자체도 복사된다
		// 즉 arr5와 arr6는 같은 주소값을 갖으며,
		// 같은 주소값을 참조하기에 같은 값을 공유하게 된다
		
		// 검증
		int[] sourceArray = {10,20,30};
		int[] cloneArray = sourceArray;
		//주소값 확인
		System.out.println(sourceArray);//[I@70dea4e
		System.out.println(cloneArray); //[I@70dea4e
		for(int i=0;i<sourceArray.length;i++) {
			System.out.print(sourceArray[i]+" ");
		} // 10 20 30 
		for(int i=0;i<cloneArray.length;i++) {
			System.out.print(cloneArray[i]+" ");
		} // 10 20 30 
		System.out.println();
		// 원본과 클론 배열 둘의 주소값,값이 동일
		
		// 원본 값을 바꿔서 둘의 차이가 있는지 확인해보자
		sourceArray[2] = 40; // 길이는 여전히 3으로 같다
		System.out.println(sourceArray);//[I@70dea4e
		System.out.println(cloneArray); //[I@70dea4e
		
		for(int i=0;i<sourceArray.length;i++) {
			System.out.print(sourceArray[i]+" ");
		} // 10 20 40 
		for(int i=0;i<cloneArray.length;i++) {
			System.out.print(cloneArray[i]+" ");
		} // 10 20 40 
		// 원본과 클론 배열 둘의 주소값,값이 여전히 동일
		
		System.out.println();
		
		//2)깊은 복사
		// 새로운 배열을 만들어 기존 데이터를 모두 복사해오는 것
		// 방법1:for문
		// 방법2:System.array.copy()
		// 방법3:Arrays.copyof()
		
		// 방법1:for문
		int[] sourceArr = {10,20,30};
		int[] cloneArr = new int[3];
		
		// 검증
		// 주소값+값 비교
		System.out.println(sourceArr);// [I@5c647e05
		System.out.println(cloneArr); // [I@33909752
		// 주소값 다름
		for(int i=0;i<sourceArr.length;i++) {
			System.out.print(sourceArr[i]+" ");//10 20 30 
		}
		for(int i=0;i<cloneArr.length;i++) {
			System.out.print(cloneArr[i]+" "); //0 0 0 
		}
		// 값 자체도 다르다
		
		// 원본 값을 바꿔서 둘의 차이가 있는지 확인해보자
		System.out.println();
		System.out.println("========");
		sourceArr[2] = 31;
		System.out.println(sourceArr); // [I@5c647e05
		System.out.println(cloneArr);  // [I@33909752
		// 원본 값 변경 후, 주소값 다름
		for(int i=0;i<sourceArr.length;i++) {
			System.out.print(sourceArr[i]+" ");//10 20 31
		}
		for(int i=0;i<cloneArr.length;i++) {
			System.out.print(cloneArr[i]+" "); //0 0 0 
		}
		// 원본 값 변경 후, 서로 값 영향x
		
		System.out.println();
		for(int i=0;i<sourceArr.length;i++) {
			cloneArr[i] = sourceArr[i];		   // 얇은복사 실행
			System.out.print(cloneArr[i]+" "); // 10 20 31 
		}
		System.out.println();
		System.out.println(sourceArr); // [I@5c647e05
		System.out.println(cloneArr);  // [I@33909752
		// 얕은 복사로 원본과 카피가 값이 같아졌지만 주소값은 여전히 다름
		
		
		// 방법2:System.array.copy()
		// 배열길이 자동 수정x
		// 복사된 값의 나머지 공간은 해당 배열의 데이터 타입의 기본값으로 채워진다
		// ex)
		// int 배열값을 복사하고 나머지 공간은 0으로 채워진다
		// double  배열값을 복사하고 나머지 공간은 0.0
		// char 배열값을 복사하고 나머지 공간은 공백
		// String 배열값을 복사하고 나머지 공간은 null
		//
		// System.arraycopy(src, srcPos, dest, destPos, length)
		// src : 원본 배열
		// srcPos : 포지션. 원본배열에서 복사를 시작할 위치
		// dest : 복사 배열
		// destpos: 복사 배열에서 붙여놓기를 시작할 위치
		// length : 얼만큼 복사를 해올지에 대한 복사 길이
		
		
		int[] sourceArr3 = {10,20,30};
		int[] cloneArr3 = new int[3];
		 
		System.arraycopy(sourceArr3, 0, cloneArr3, 0, cloneArr3.length);
		System.out.println(sourceArr3);
		for(int i=0;i<sourceArr3.length;i++) {
			System.out.print(sourceArr3[i]+" "); // 10 20 30
		} 										 // 원본 값
		System.out.println();
		for(int i=0;i<cloneArr3.length;i++) {
			System.out.print(cloneArr3[i]+" ");  // 10 20 30
		} 										 // 클론 값
		System.out.println();
		
		int[] sourceArr4 = {10,20,30,40,50};
		int[] cloneArr4 = new int[3];
		 
		System.arraycopy(sourceArr4, 0, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스0번부터4번까지 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 10 20 30
		} 										// 클론값
		// 
		System.out.println();
		
		System.arraycopy(sourceArr4, 2, cloneArr4, 0, cloneArr4.length);
		// 원본 인덱스2번부터4번까지 30 40 50의 배열값 복사해서 복제본의 0번째 인덱스부터 붙여넣는다는 의미
		for(int i=0;i<sourceArr4.length;i++) {
			System.out.print(sourceArr4[i]+" ");// 10 20 30 40 50
		} 										// 원본값
		System.out.println();
		for(int i=0;i<cloneArr4.length;i++) {
			System.out.print(cloneArr4[i]+" "); // 30 40 50 
		} 										// 클론값
		// 
		System.out.println();
		
		
		
		int[] a = {2,4,6,8,10};
		int[] b = new int [10];
		
		System.arraycopy(a, 3, b, 0, 2);
		// dest의 범위가 0-5까지는 잘나오고 6부터 error
		for(int i=0; i<a.length;i++) {
			System.out.print(a[i]+" "); // 2 4 6 8 10 
		}								// 원본값
		System.out.println();
		for(int i=0; i<b.length;i++) {
			System.out.print(b[i]+" "); // 8 10 0 0 0 0 0 0 0 0 
		}								// 카피값
		System.out.println();
		
		// int 배열
		int[] src = {3,6,9,12};
		int[] clone = new int[8];
		
		System.arraycopy(src, 2, clone, 6, 2);
		// src 2번인덱스부터 길이2를 복사해서 9,12값을 clone의 6번째부터 복사
		for(int i=0; i<src.length;i++) {
			System.out.print(src[i]+" "); // 3 6 9 12 
		}								  // 원본값
		System.out.println();
		for(int i=0; i<clone.length;i++) {
			System.out.print(clone[i]+" ");// 0 0 0 0 0 0 9 12 
		}								   // 카피값
		System.out.println();
		
		int[] src2 = {3,6,9,12};
		int[] clone2 = new int[8];
		System.arraycopy(src2, 2, clone2, 5, 2);
		for(int i=0; i<clone2.length;i++) {
			System.out.print(clone2[i]+" ");// 0 0 0 0 0 9 12 0  
		} // 복사되고 int배열의 공백은 0으로 채워진다       // 카피값
		System.out.println();
		
		
		// double 배열
		double[] dSrc = {1.0,1.5,2.0,2.5};
		double[] dCopy = new double[8];
		
		System.arraycopy(dSrc, 0, dCopy, 4, dSrc.length);
		for(int i=0;i<dCopy.length;i++) {
			System.out.print(dCopy[i]+" ");//0.0 0.0 0.0 0.0 1.0 1.5 2.0 2.5  
		}								   // 복사된 값 외에 나머지 공간 : 0.0
		System.out.println();
		
		// char 배열
		char[] cSrc = {'a','b','c'};
		char[] cCopy = new char[6];
		
		System.arraycopy(cSrc, 0, cCopy, 0, cSrc.length);
		for(int i=0;i<cCopy.length;i++) {
			System.out.print(cCopy[i]+" ");//a b c (공백)
		}								   // // 복사된 값 외에 나머지 공간 : 공백
		System.out.println();
		
		// String 배열
		String[] sSrc = {"A","B","C"};
		String[] sCopy = new String[6];
		
		System.arraycopy(sSrc, 0, sCopy, 0, sSrc.length);
		for(int i=0;i<sCopy.length;i++) {
			System.out.print(sCopy[i]+" ");// A B C null null null 
		}								   // 복사된 값 외에 나머지 공간 : null
		System.out.println();
		
		
		
		// 방법3:Arrays.copyof()
		
		// Arrays.copyOf(original, newLength)
		// - original : 원본
		// - newLength : 얼마만큼 복사할지
		// 배열 길이만큼 복사해오기에 System.arraycopy()처럼 공간이 남지않는다
		// 원본 길이보다 길게 복사할 경우, 남는 공간은 원본의 데이터타입 기본값으로 채운다
		
		// int타입
		// 여분 : 0
		int[] aSrc = {1,2,3,4,5};
		int[] aCopy = new int[10];
		
		
		aCopy = Arrays.copyOf(aSrc, 4);
		for(int i=0;i<aCopy.length;i++) {
			System.out.print(aCopy[i]+" ");// 1 2 3 4 
		}								   
		System.out.println();
		
		aCopy = Arrays.copyOf(aSrc, 3);
		for(int i=0;i<aCopy.length;i++) {
			System.out.print(aCopy[i]+" ");// 1 2 3
		}								   
		System.out.println();
		
		aCopy = Arrays.copyOf(aSrc, 6);
		for(int i=0;i<aCopy.length;i++) {
			System.out.print(aCopy[i]+" ");// 1 2 3 4 5 0
		}								   
		System.out.println();
		
		
		// double타입
		// 여분 : 0.0d
		double[] adSrc = {1.0,1.5,2.0,2.5,3.0};
		double[] adCopy = new double[10];
		
		
		adCopy = Arrays.copyOf(adSrc, 6);
		for(int i=0;i<adCopy.length;i++) {
			System.out.print(adCopy[i]+" ");// 1.0 1.5 2.0 2.5 3.0 0.0 
		}								   
		System.out.println();
		
		
		// char타입
		// 여분 : (공백)
		char[] acSrc = {'a','b','c'};
		char[] acCopy = new char[6];
		
		acCopy = Arrays.copyOf(acSrc, 6);
		for(int i=0;i<acCopy.length;i++) {
			System.out.print(acCopy[i]+" ");// a b c (공백)
		}								   
		System.out.println();
		
		
		// String
		// 여분 : null
		String[] asSrc = {"a","b","c"};
		String[] asCopy = new String[6];
		
		asCopy = Arrays.copyOf(asSrc, 6);
		for(int i=0;i<asCopy.length;i++) {
			System.out.print(asCopy[i]+" ");// a b c null null null 
		}								   
		System.out.println();
		
		
		
	}
	
}

 

 

 

728x90
반응형

+ Recent posts