-- 숫자함수
select ABS(-15.5) from dual; -- 절대값
select floor(15.7) from dual; -- 소숫점 절삭
select round(-15.8) from dual; -- 정수타입으로 반올림
select round(-15.693, 2) from dual; -- 몇번째 자리까지 표시할 것인지 선택
select log(10, 100 ) from dual; -- 로그값(지수)구해줌
select power(3, 2) from dual; -- 제곱
-- 문자함수
select concat('나는', '손흥민입니다.') from dual; -- 두개붙여줌
select concat('저의 이름은', ename) from emp where job='MANAGER'; -- 응용
select LOWER('ABCD') "Lowercase" from dual;
select lower(ename) from emp;
select lpad('page 1',15,'*') from dual; -- 별표로 가려줌
select rpad('910119-2',14,'*') from dual;
select substr('ABCEDFG',3,4) from dual; -- 3번째부터 4개 자른다
select rpad(substr('910119-2000000',1,8),14,'*') from dual; -- 응용
select Ltrim(' =from=','a') from dual; -- 제거
select Rtrim(' =from===== ',' ') from dual;
select trim('=' from '=======from=======') from dual;
select trim(' ' from ' =====from==== ') from dual;
select REPLACE('JACK and JUE','J','BL') "Changes" FROM DUAL; -- J를 BL로 변경
select REPLACE('뽀준','준','선') "Changes" FROM DUAL;
-- 날짜함수
select sysdate from dual; -- 오늘날자
select sysdate+21 from dual; --14일 뒤
select add_months(sysdate, 4) from dual; -- 4개월 더해줌
select last_day(sysdate) from dual; -- 이달의 마지막날 알려줌..
-- 날짜 >문자
select sysdate from dual;
select sysdate, to_char(sysdate, 'YYYY-MM-DD') "바뀐날짜" from dual;
select sysdate, to_char(sysdate, 'YYYY-MM-DD Day dy')from dual;
select sysdate, to_char(sysdate, 'YYYY-MM-DD Day dy AM PM HH HH24 mi ss') from dual;
select to_char(sysdate, 'YYYY.MM.DD. HH24:mi:ss') from dual; -- 네이버st
-- 숫자 > 문자
SELECT TO_CHAR (1230000) FROM DUAL;
select to_char(10000.123, 'L000,000.00') from dual;
select to_char(10000, 'L999,999.99') from dual;
select sal, to_char(sal*1100, 'L00,000,000') from emp;
select sal, to_char(sal*1100, 'L99,999,999') from emp;
select ename,sal, to_char(sal*1100*12+nvl(comm,0)*1100, 'L99,999,999') from emp order by sal desc;
-- 문자 > 날짜
-- 2020.11.01
select TO_DATE('2019/09/05', 'YYYY/MM/DD') from dual;
select TO_DATE('2020.11.01.', 'YYYY.MM.DD.') from dual;
-- 오늘이 2020년 1월 1일에서 몇일이 지났는지 확인해보자 :)
select trunc(sysdate - to_date('20-01-01','YY-MM-DD')) from dual;
-- 문자 > 숫자
select TO_NUMBER('100.00', '999.99') * to_number('10.00', '99.99') from dual;
--사용법
DECODE(컬럼,조건,TRUE 결과값,FALSE 결과값)
--예제
--TYPE 1이면 정규직 2면 비정규직
SELECT
DECODE(TYPE,1,'정규직','비정규직') AS TYPE
FROM
EMP_TABLE
--주민등록번호(MY_NUM)이(가) 1또는3으로 시작하면 남자 아니면 여자
SELECT
DECODE(SUBSTRING(MY_NUM,0,1),1||3,'남','여') AS GENDER
FROM
EMP_TABLE
-- DECODE 함수 : switch 문과 비슷
-- 사원 이름, 부서번호, 부서이름 출력
select ename, deptno,
decode(deptno,
10, 'ACCOUTING',
20, 'RESEARCH',
30, 'SALES',
40, 'OPERATIONS')
as dname
from emp;
-- 8. 직급에 따라 급여를 인상하도록 하자.
-- 직급이 'ANAlYST'인 사원은 5%, 'SALESMAN'인 사원은 10%, 'MANAGER'인 사원은 15%,
-- 'CLERK'인 사원은 20%인 인상한다.
select ename, job, sal,
decode(job,
'ANALYST', sal*1.05,
'SALESMAN', sal*1.1,
'MANAGER', sal*1.15,
'CLERK', sal*1.2)
as sal2
from emp
;
-- CASE 함수
select ename, deptno,
case
when deptno=10 then 'ACCOUNTING'
when deptno=20 then 'RESEARCH'
when deptno=30 then 'SALES'
when deptno=40 then 'OPERATIONS'
end as dname
from emp
order by dname
;
-- 숫자
-- 급여의 오름차순 정렬 / 작은수>>>큰수
SELECT *
FROM emp
ORDER BY sal -- asc; 생략 가능 / 오름차순이 default
;
-- 급여의 내림차순 정렬 / 큰수>>>작은수
SELECT *
FROM emp
ORDER BY sal desc
;
SELECT *
FROM emp
ORDER BY comm -- null 값은 맨 아래로 내려간다 (가장큰수마냥..)
;
-- 문자 [a>z가 디폴트]
SELECT *
FROM emp
ORDER BY ename
;
-- 날짜 [최근> 오래됨이 디폴트]
SELECT *
FROM emp
ORDER BY hiredate desc
;
-- 중복
SELECT *
FROM emp
ORDER BY hiredate desc, sal -- sal은 작은 순서로 [jame/ford\
;
-- 특정 데이터를 추출하는 where 절
-- select 컬럼명 from 테이블명 where 조건
-- 급여가 3000 이상인 사원의 리스트를 출력하자
select ename, job, sal
from emp
where sal >=3000
;
select ename, job, sal
from emp
where sal>4000
;
1)
2)
-- 10번 부서에 소속된 사원들의 리스트 출력
SELECT *
FROM emp
where deptno=10
;
-- 문자 데이터 조회 '' 안의 대문자 소문자 구분함
SELECT empno, ename, sal
FROM emp
where ename = 'FORD'
;
-- 날짜 데이터 조회
SELECT *
FROM emp
where hiredate='81/11/17'
;
-- AND 연산자
-- 10번 부서 소속인 사원들 중에서
-- 직급이 MANAGER인 사람을 검색하여 사원명, 부서번호, 직급을 출력
SELECT ename, deptno, job
FROM EMP
WHERE DEPTNO=10 AND JOB='MANAGER';
-- OR 연산자
-- 10번 부서에 소속된 사원이거나
-- 직급이 MANAGER인 사람을 검색하여 사원명, 부서번호, 직급을 출력합시다.
SELECT ename, deptno, job
FROM emp
where deptno=10 OR JOB='MANAGER';
-- NOT 연산자
-- 부서번호가 10번이 아닌 사원의 이름, 부서번호, 직급을 출력
SELECT ename, deptno, job
FROM emp
WHERE NOT deptno=10;
-- BETWEEN 연산자 (column_name BETWEEN A AND B)
-- 2000에서 3000 사이의 급여를 받는 사원
SELECT *
FROM EMP
WHERE SAL>=2000 AND SAL<=3000;
--1987년에 입사한 사원을 출력
SELECT *
FROM EMP
-- WHERE HIREDATE >= '1987/01/01' AND HIREDATE <= '1987/12/31';
WHERE HIREDATE BETWEEN '1987/01/01' AND '1987/12/31';
-- IN 연산자
-- 커미션이 300이거나 500 이거나 1400인 사원 검색
SELECT *
FROM emp
-- where comm=300 or comm=500 or comm=1400
where comm in(300,500,1400);
-- LIKE연산자 ( column_name LIKE pattern )
-- 와일드카드(%) 사용하기
-- F로 시작하는 사람 찾기
SELECT *
FROM emp
WHERE ename LIKE 'F%';
-- D로 끝나는 사람 찾기
SELECT *
FROM emp
WHERE ename LIKE '%D';
-- 이름중에 A가 들어간 사람 찾기
SELECT *
FROM emp
WHERE ename LIKE '%A%';
-- 와일드카드(_) 사용하기
-- _는 한문자에 대해서만 와일드카드 역할을 한다.
-- 이름의 두번째 글자가 A인 사람
SELECT *
FROM emp
WHERE ename LIKE '_A%';
-- 찾으려는 이름이 F로 시작 하는 것은 알지만 그 뒤의 문자는 모를 경우
select *
from emp
-- where ename like 'F%' --F로 시작하고 뒤는 어떤 문자가 와도 상관 없음
-- where ename like '%S' --F로 시작하고 뒤는 어떤 문자가 와도 상관 없음
-- where ename like '%A%' -- 이름에 A문자를 포함하는 이름을 검색
-- where ename like '_A%' -- 첫 번째 문자는 어떤 문자든 상관없고 두 번째 자리는 반드시 A가 오는 이름 검색
where ename like '__R%' -- 첫번째 세번째 문자는 아무거나 상관없고 세 번째 자리에 R이 오는 이름 검색.
-- 000000-1000000 > '_______1%' = 주민등록번호에서 남자찾기
-- '1987/12/18' > '_____12%' = 생일이 12월인 사람 찾기
-- NOT LIKE
-- 이름에 A가 들어가지 않는 사람 찾기
SELECT *
FROM emp
WHERE ename NOT LIKE '%A%';
-- 커미션을 받지 않는 사원 검색
SELECT *
from emp
where comm is null or comm=0
;
-- 커미션을 받는 사원 검색
SELECT *
from emp
where comm is not null and comm>0
;
-- SELECT 절의 컬럼의 사칙연산
-- 임시테이블 dual : 컬럼은 x를 가지는 테이블
select 100+200, 200-100, 100*10, 100/10
from dual
;
SELECT ename, sal, sal*12
FROM emp
;
-- 연봉의 계산을 sal*12+comm으로 계산하자
SELECT ename, sal, sal*12, comm, sal*12+comm
FROM emp
;
-- null : 값은 존재하나 정해지지 않은 값
-- 연산이 불가 : 사칙/비교 연산
-- nvl 함수 : 컬럼의 값이 nulㅣ 일때 대체값으로 치환해준다.
-- nvl(컬럼, 대체값) 컬럼과 같은 타입의 대체값
select ename, comm, sal*12+comm,nvl(comm, 0), sal*12+nvl(comm, 0)
from emp;
-- 데이터 베이스 sql 내부의 문자열 처리는 대부분 ''
-- 별칭 처리는 "" but 에러날 수 있으니 영문처리 하자
select ename, comm, sal*12+comm sall2, nvl(comm, 0) as com, sal*12+nvl(comm, 0) "12개월 연봉"
from emp;
-- Concatenation 연산자의 정의와 사용
select ename || ' is a ' || job as "||연산자"
from emp;
-- DISTINCT 중복되는것을 생략해준다
-- DISTINCT 뒤에는 다른 컬럼을 쓸 수 없다!
select distinct deptno
from emp;
--2020.11.09
--select 기본
-- scott 계정으로 로그인
-- scott 계정이 소유한 테이블 객체를 확인
-- : tab > 테이블의 정보를 알려주는 데이터 딕셔너리
select*from tab;
-- DESC : 테이블 구조 확인
-- 테이블의 데이터를 검색하기 전 구조를 확인할 때
DESC emp;
desc dept;
select hiredate from emp;
-- 데이터의 조회 명령 : select
-- SELECT의 컬럼명,... FROM 테이블 이름(조회의대상) > 기본 문법
-- SELECT의 결과는 > TABLE이다.
SELECT
* -- 컬럼 이름들을 기술해준다. 기술하는 순서에 따라 결과도 순서에 맞게 출력이 된다.
FROM emp -- 조회하고자 하는 테이블 이름을 기술
; --- SQL의 종료
-- 부서 테이블의 모든 데이터를 조회하자
SELECT *
FROM dept
;
-- 부서테이블에서 > FROM
-- 부서의 이름과 위치를 출력 > SELECT
SELECT dname, loc
FROM dept
;
SELECT loc, dname
FROM dept
;
-- 모든 사원의 정보를 출력하자
SELECT *
FROM emp
;
-- 사원의 이름, 사번, 직급(직무)를 포함하는 리스트 출력
SELECT ename, empno, job
FROM emp
;
소켓은 TCP를 위한 구조이다. TCP를 사용하여 응용 프로그램끼리 통신을 하기 위해서는 먼저 연결을 하여야 하는데 연결을 하기 위해서느 연결 끝점(End point)가 있어야 한다. 이 연결끝점이 바로 Socket이다.
Socket 클래스
생성자
설명
Socket (String host, int port)
호스트 이름이 host이고 포트 번호가 port인 새로운 소켓을 생성한다
Socket (InetAddress address, int port)
InetAddress에 기술된 주소로 새로운 소켓을 생성한다
메소드
설명
InputStream getInputStream()
소켓이 사용하는 입력 스트림을 반환한다
OutputStream getOutputStream()
소켓이 사용하는 출력 스트림을 반환한다
Inetaddress getInetAddress()
소켓이 연결되어 있는 인터넷 주소를 반환한다
public int getLocalPort()
소켓이 연결되어 있는 포트 번호를 반환한다
public int getPort()
원격 컴퓨터의 포트번호를 반환한다
pbulic InetAddress getLocalAddress()
소케싱 연결되어 있는 인터넷 주소를 반환한다
ServerSocket 클래스
생성자
설명
public ServerSocket(int port) throws IOException
포트번호 Port에 대해 ServerSocket의 새로운 인스턴스를 만든다. 포트번호 0은 비어있는 포트번호를 사용한다는 의미이다. queue는 서버가 받을 수 있는 입력 연결의 개수를 의미한다. (디폴트는 50연결이다) address는 컴퓨터의 인터넷 주소를 나타낸다.
public ServerSocket(int port, int queue) throws IOException
public ServerSocket(int port, int queue, InetAddress address ) throws IOException
메소드
설명
public socket accept()
접속요청을 받는다
public void close()
ServerSocket을 닫는다
public Inetaddress getInetAddress()
소켓이 연결되어 있는 인터넷 주소를 반환한다
public int getSoTimeout()
소켓에 대한 타임아웃값을 밀리 초로 반환하거나 설정한다.
소켓클래스를 이용한 채팅방
서버)
package network;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class TCPIPChatMultichatServer {
// 접속 사용자 정보를 저장 : 메세지를 전체에게 보내기 위해서
// 저장정보 : name, OutputStream
// Map<String, Object>로 저장
HashMap<String, Object> clients;
public TCPIPChatMultichatServer() {
clients = new HashMap<String, Object>();
Collections.synchronizedMap(clients); // 스레드 동기화에 안전한 상태로 해주는메서드
}
public void start() throws IOException {
// Server Socket 생성
// 사용자의 요청이 있으면 Socket 생성해서 연결 > Clients 사용자 정보를 저장
// 연결 > Clients 사용자 정보를 저장 스레드로 처리
ServerSocket serverSocket = new ServerSocket(7777);
System.out.println("Chatting Server Start!");
Socket socket = null;
while(true) {
// 요청이 들어올 때까지 대기 하다가 요청이 들어오면 새로운 소켓을 생성해서 반환
socket = serverSocket.accept();
// map에 정보저장, 접속한 사람들에게 메세지를 전송
System.out.println("["+socket.getInetAddress()+socket.getPort()+"] 사용자 접속");
ServerReceiver receiver = new ServerReceiver(socket);
receiver.start();
}
}
void SendToAll(String msg) {
// 일괄처리 - Map은 순서가 없다 - Map이 가지고 있는 key를 Set으로 만든다.
Set<String> keys = clients.keySet();
Iterator<String> itr = keys.iterator();
while (itr.hasNext()) {
DataOutputStream out = (DataOutputStream) clients.get(itr.next()); // 키값가져오기
try {
out.writeUTF(msg);
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 내부클래스 : 데이터 받아서 저장, 메시지 전체 발송
private class ServerReceiver extends Thread {
// Socket, InputStream, OutputStream
Socket socket;
DataOutputStream out;
DataInputStream in;
public ServerReceiver(Socket socket) {
this.socket = socket;
try {
in = new DataInputStream(socket.getInputStream());
out = new DataOutputStream(socket.getOutputStream());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
String name=null; // 접속한 사용자 이름
try {
name= in.readUTF(); // 이름을 스트림을 통해 받는다
clients.put(name, out); // map에 사용자 정보 저장
SendToAll(">>>>>>>>>> " +name+"님이 접속하셨습니다.");// 내부클래스에서는 외부 클래스의 멤버를 참조할 수 있다.
while(in !=null ) {
SendToAll(in.readUTF());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clients.remove(name);
System.out.println(name+"님이 나가셨습니다.");
}
}
}
public static void main(String[] args) throws IOException {
new TCPIPChatMultichatServer().start();
}
}
클라이언트)
package network;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import thread.threadMain;
public class TCPIPMulitiChatClient {
public static void main(String[] args) {
String serverIp = "192.168.0.32"; // localhost > 호스트자신의 주소
//Socket연결
try {
Socket socket = new Socket(serverIp, 7777);
// 메세지를 받는 스레드
Thread receiver = new ClientReceiver(socket);
// 메세지를 보내는 스레드
Thread sender = new ClientSenderThread(socket, "포그바");
sender.start();
receiver.start();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientSenderThread extends Thread{
// 보내기 스레드는 Socket, OutputStream, name도 필요하다.
Socket socket;
DataOutputStream out;
String name;
public ClientSenderThread(Socket s, String name) {
this.socket = s;
try {
out = new DataOutputStream(s.getOutputStream());
this.name = name;
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
Scanner sc = new Scanner(System.in);
try {
// 접속하면 이름을 서버에 전송
if(out != null) {
out.writeUTF(name);
}
while(out!=null) {
out.writeUTF("["+name+"]"+sc.nextLine());
}
}catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientReceiver extends Thread {
// 메세지를 받아서 콘솔에 출력
// Socket, InputStream, 필요
Socket socket;
DataInputStream in;
public ClientReceiver(Socket socket) {
this.socket = socket;
try {
in = new DataInputStream(socket.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while (in != null){
try {
System.out.println(in.readUTF());
} catch (IOException e) {
}
}
}
}
– 자바에서 스레드를 사용하는 이유는 비동기적 작동 방식(독립스레드)에 대한 개념이 없음 • 프로그래밍 방식이 자바에서는 사용이 가능하지 않음 • 비동기적 작동 방식 구현 : ‘스레딩 기술의 사용 방법’ 숙지 – 자바가 실행되는 기반인 자바가상머신(Java virtual machine, 이하 JVM) 자체가 하나의 프로세스임 • 언어적 차원 : 스레드의 동기화 지원 가능 • 다중 스레드 프로그램을 쉽고 명료하게 만들 수 있음
다중 쓰레드
– 시분할 기법(Time-Shared) • 멀티태스킹 및 멀티스레드를 가능하게 하는 기법 • 아주 짧은 시간 간격을 두고 여러 개의 프로그램을 전환하면서 실행 • 빠른 속도 때문에 두 개 이상의 프로그램이 동시에 실행되는 것처럼 느껴짐 • 프로그램의 실행을 전환하는 것은 OS가 담당함
– 다중 스레드의 이점 • 자원을 효율적으로 사용할 수 있음 • 사용자에 대한 응답성이 향상됨 • 작업이 분리되어 코드가 간결함
– 다중 스레드의 단점 • 동기화에 주의해야 함 • 교착상태가 발생하지 않도록 주의해야 함 • 각 스레드가 효율적으로 고르게 실행될 수 있게 해야 함
–다중 스레드의 사용 예
• 스마트폰 게임 – 메인스레드 : 게임을 하기 위한 UI부분을 그려줌 – 그래픽 부분 담당 코드 : 순차적으로 실행, UI를 그리는 서버통신을 담당하는 소켓부분을 방치하는 수 밖에 없음. – 통신을 담당하는 스레드를 따로 하나를 두어 일정한 시간단위로 체크할 수 있도록 해야 함.
• 영상통신
– 영상을 받아 화면에 출력해 주는 코드와 영상을 생성하여 보내주는 코드를 만드는 경우
> 적어도 2개의 작업이 동시에 일어난다는 것을 알 수 있음 – 두 가지 이상의 일을 구현하기 위해 다중 스레드를 사용함
< 스레드 사용 방법 >
예제 extends Thread
package thread;
// 쓰레드 클래스의 정의는 thread클래스를 상속해서 정의
public class showThread extends Thread {
String threadName;
public showThread(String name) {
this.threadName=name;
}
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println("안녕하세요" + threadName + "입니다.");
try {
// object클래스의 sleep() 메서드 : 현재 스레드를 1/1000초 간격으로 멈춤
sleep(100);// 100/1000초 > 1/10초
} catch (InterruptedException e) {
e.printStackTrace();
}
} System.out.println(threadName + " 종료 ★");
}
}
package thread;
public class threadMain {
public static void main(String[] args) {
// Thread 생성
showThread st1 =new showThread("1번 스레드");
showThread st2 =new showThread("2번 스레드");
st1.start();
st2.start();
for(int i=0; i<100; i++) {
System.out.println("메인스레드");
}
System.out.println("★끝★");
}
}
< 출력 >
main스레드에 Thread.sleep(100)을 똑같이 넣어주면 셋이 번갈아서 실행됨
예제 implements Runnable
package thread;
// 쓰레드 클래스 정의할 때 상속이 필요한 경우 Runnable 인터페이스를 구현해서 스레드를 생성할 수 있다.
public class ShowRunnable implements Runnable {
public void run() {
for(int i=0; i<100; i++) {
System.out.println("러너블스레드");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("★끝★");
}
}
package thread;
public class threadMain2 {
public static void main(String[] args) {
// Runnable 인터페이스를 이용한 스레드
Runnable target = new ShowRunnable();
Thread st3 = new Thread(target);
st3.start();
for(int i=0; i<100; i++) {
System.out.println("메인스레드");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("★끝★");
}
}
<출력 / 100개 반복>
스레드 우선순위 설정
// 우선순위 설정 1-10 : 기본5
st1.setPriority(Thread.MAX_PRIORITY);
st2.setPriority(Thread.MIN_PRIORITY);
<출력> ~ 속도가 빨라서 별차이가 없지만 방법은 ARADUZA ~
t1.join(); // t1 스레드가 종료될때까지 다른 스레드는 멈춘상태
예제)
package thread;
public class Sum {
int num;
Sum(){
num=0;
}
void addNum(int n) {
num+=n;
}
int getNum() {
return num;
}
public void run() {
// TODO Auto-generated method stub
}
}
package thread;
public class Adderthread extends Sum implements Runnable {
int start;
int end;
Adderthread(int n1, int n2){
start=n1;
end=n2;
}
@Override
public void run() {
for(int i=start; i<=end;i++) {
addNum(i);
}
}
}
package thread;
public class AdderThreadMain {
public static void main(String[] args) {
Adderthread at1 = new Adderthread(1, 500000);
Adderthread at2 = new Adderthread(500000, 1000000);
// 쓰래드 생성
Thread t1 = new Thread(at1);
Thread t2 = new Thread(at2);
t1.start();
t2.start();
try {
t1.join(); // t1 쓰래드가 종료될 때 까지 다른 쓰래드는 멈춤상태
t2.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("1~100 합은 : " + (at1.getNum()+at2.getNum()) );
}
}
<출력>
1~100 합은 : 1784793664
멀티스레드 예제
package thread;
import javax.swing.JOptionPane;
public class ThreadTestMain1 {
// 다른 스레드에서도 참조가 가능한 클래스 변수
public static boolean check = false; // 10초 지나면 꺼지게하려고 만듦 (안에서사용하려고)
public static void main(String[] args) {
// String age= JOptionPane.showInputDialog("나이를 입력해주세요");
// int ageNumber=Integer.parseInt(age);
// System.out.println("저의 나이는 " + age + "세 입니다.");
// for(int i=10; i>0; i--) {
// System.out.println(i);
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// } // 나이쓰는 창뜨고 > 숫자셈
InputAgeThread iat= new InputAgeThread();
CountDownThread cdt=new CountDownThread();
iat.start();
cdt.start();
}
}
class InputAgeThread extends Thread{
@Override
public void run() {
System.out.println("10초 안에 입력하세요.");
String age= JOptionPane.showInputDialog("나이를 입력해주세요");
System.out.println("저의 나이는 " + age + "세 입니다.");
ThreadTestMain1.check=true;
}
}
class CountDownThread extends Thread {
@Override
public void run() {
for(int i=10; i>0; i--) {
if(ThreadTestMain1.check) {
break; // 입력되면 숫자세기 STOP
}
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.exit(0);
}
}
'
스레드 동기화
Note that this implementation is not synchronized API 문서에는 해당 클래스의 인스턴스가 둘 이상의 쓰레드가 동시에 접근을 해도 문제가 발생하지 않는지를 명시하고 있다. 따라서 쓰레드 기반의 프로그래밍을 한다면, 특정 클래스의 사용에 앞서 쓰레드에 안전한지를 확인 해야 한다.
ex) String buffer / builder
쓰레드의 동기화 - synchronized - 한 번에 하나의 쓰레드만 객체에 접근할 수 있도록 객체에 락(lock)을 걸어서 데이터의 일관성을 유지하는 것.
아래 예제)
Sum 클래스의 Void addNum에 synchronized가 없으면 동기화가 되지 않아서 매번 값이 다르다..
그러나 엄청난 성능의 감소를 동반한다.
package thread;
public class Sum {
int num;
Sum(){
num=0;
}
// 동기화~!
synchronized void addNum(int n) {
num+=n;
}
int getNum() {
return num;
}
public void run() {
// TODO Auto-generated method stub
}
}
package thread;
public class AdderThread1 extends Thread {
Sum sum;
int start;
int end;
public AdderThread1(Sum sum, int start, int end) {
this.sum = sum;
this.start = start;
this.end = end;
}
@Override
public void run() {
for (int i = start; i <= end; i++) {
sum.addNum(i);
}
}
}
package thread;
public class AdderThreadhMain2 {
public static void main(String[] args) {
Sum sum = new Sum();
AdderThread1 t1 = new AdderThread1(sum, 1, 5000);
AdderThread1 t2 = new AdderThread1(sum, 5001, 10000);
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1-100합 "+ sum.getNum());
}
}
<출력>
1-100합 50005000
동기화블럭
public class Calculator {
int opplCnt=0; // 몇번의 연산을 했나요?
int opmiCnt=0;
public int add(int n1, int n2) {
synchronized (this) { // key
opplCnt++;
}
// opCnt++;
return n1+n2;
}
public int min(int n1, int n2) {
synchronized (obj) { // 참조값이 달라서 다르다.
opmiCnt++;
}
// opCnt++;
return n1-n2;
}
Object obj = new Object(); // 새로운 동기화 키 생성
}
만약 opplCnt / opmiCnt가 아니라 똑같이 opCnt++;를 사용하면 똑같이 this(둘다같은거면OK)를 넣으면 된다
num1도 쓰고 num2도 쓰기 위해(효율성) 두개의 Key로 분리해 주는 것이라고 생각하면 되는듯하다.
package io;
import java.io.File;
public class FileMove {
public static void main(String[] args) {
// File 클래스는 경로를 저장한다.
// 파일의 경로, 폴더의 경로
// 파일 또는 폴더의 속성을 변경하거나 삭제, 생성이 가능하다.
// 현재 존재하는 파일의 경로를 생성
File myFile = new File("C:"+File.separator+"myJava\\my.bin");
// myFile.delete();
if(!myFile.exists()) {
System.out.println("원본 파일이 준비되어 있지 않습니다.");
System.out.println("프로그램을 종료합니다.");
return;
}
System.out.println("파일 존재");
File reDir = new File("c:\\yourJava");
reDir.mkdir(); // 해당 경로에 폴더가 있으면 그대로 유지, 없으면 생성
System.out.println("폴더 생성 성공");
//파일을 이동할 새로운 경로 생성
File refile = new File(reDir, "Your.bin");
System.out.println("파일 존재 유무 : " + refile.exists());
//파일 이동
myFile.renameTo(refile);
if(refile.exists()) {
System.out.println("파일 이동 성공");
}
}
}
package io;
import java.io.Serializable;
public class Circle implements Serializable{
//implements Serializable : 직렬화의 대상이다. 인스턴스 저장이 가능하다.
// 직렬화를 하기 위해서는 반드시 해줘야함..
int x;
int y;
double rad;
public Circle(int x, int y, double r) {
this.x=x;
this.y=y;
this.rad=r;
}
public void showCircleInfo() {
System.out.printf("[%d,%d]", x,y);
System.out.println("rad : " + rad);
}
}
package io;
import java.io.Serializable;
public class Circle2 implements Serializable {
// implements Serializable : 직렬화의 대상이다. 인스턴스 저장이 가능하다.
// 직렬화를 하기 위해서는 반드시 해줘야함..
// transient Point p; 직렬화대상에서 제외
Point p;
double rad;
public Circle2(int x, int y, double r) {
p = new Point(x, y);
this.rad = r;
}
public void showCircleInfo() {
System.out.println("rad : " + rad);
}
}
package io;
import java.io.Serializable;
public class Point implements Serializable {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectSerializable {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
// 인스턴스 저장을 위한 스트림 생성
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Object.ser"));
// 인스턴스를 저장
out.writeObject(new Circle(1,1,2.4));
out.writeObject(new Circle(2,2,4.8));
out.writeObject(new String("String class implements Serializable"));
// String 클래스도 직렬화 가능
out.writeObject(new Circle2(3,3,6.9));
out.close(); // 저장~!
// 인스턴스 복원
ObjectInputStream in = new ObjectInputStream(new FileInputStream("Object.ser"));
// Circle c1 = (Circle) in.readObject(); // 형변환
Object o1 = in.readObject();
Circle c1 =null;
if(o1 instanceof Circle) {
c1 = (Circle)o1;
}
Circle c2 = (Circle) in.readObject();
String str= (String) in.readObject();
Object o2 = in.readObject();
Circle2 c3=null;
if(o2 instanceof Circle2) {
c3= (Circle2)o2;
}
// 복원된 인스턴스 출력
c1.showCircleInfo();
c2.showCircleInfo();
System.out.println(str);
c3.showCircleInfo();
}
}
예제2)
package io;
import java.beans.Transient;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class PersonInfo implements Serializable {
String name;
transient String secretInfo;
int age;
transient int secretNum;
public PersonInfo(String name, String secretInfo, int age, int secretNum) {
this.name = name;
this.secretInfo = secretInfo;
this.age = age;
this.secretNum = secretNum;
}
public void showInfo() {
System.out.println("name : " + name);
System.out.println("secretInfo : " + secretInfo);
System.out.println("age : " + age);
System.out.println("secretNum : " + secretNum);
}
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
// 인스턴스 저장 스트림 생성
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("PersonInfo.ser"));
PersonInfo info = new PersonInfo("김태형", "뽀선이애인", 24, 1);
info.showInfo();
// 인스턴스 저장
out.writeObject(info);
out.close();
// 인스턴스 복원을 위한 스트림 생성
ObjectInputStream in = new ObjectInputStream(new FileInputStream("PersonInfo.ser"));
// 복원
PersonInfo reInfo = (PersonInfo) in.readObject();
// 복원된 인스턴스의 정보 출력
reInfo.showInfo();
}
}
•유니코드로 된 문자를 입·출력 하는 스트림 •2바이트를 입·출력 - 세계 모든 언어로 구성된 파일을 입·출력 하기에 적합 •이미지, 동영상과 같은 바이너리 데이터는 입·출력 할 수 없음 •문자 데이터만 입·출력 가능
Reader의 대표적인 메소드
public int read() throws IOException public abstract int read(char[] cbuf, int off, int len) throws IOException
Writer의 대표적인 메소드
public int write(int c) throws IOException
public abstract void write(char[] cbuf, int off, int len) throws IOException
BufferedWriter
package io;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class StringWriter {
public static void main(String[] args) throws IOException {
// 필터스트림 : 기본 스트림 writer가 필요하다.
Writer writer = new FileWriter("String.txt"); // 기본스트림
BufferedWriter out = new BufferedWriter(writer); // 필터스트림
out.write("Cos ah ah I’m in the stars tonight");
out.newLine();
out.write("So watch me bring the fire and set the night alight");
out.newLine();
out.write("Shining through the city with a little funk and soul");
out.newLine();
out.write("So I’mma light it up like dynamite, woah");
out.newLine();
out.newLine();
out.write("BTS - Dynamite");
// 스트림닫기
out.close();
}
}
BufferedReader
package io;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.BufferedReader;
public class StringReader {
public static void main(String[] args) throws IOException{
// 문자 기반 기본 스트림 인스턴스 생성
Reader reader = new FileReader("String.txt");
// 필터스트림
BufferedReader in = new BufferedReader(reader);
// 한행의 문자열을 담을 변수
String str=null;
while(true) {
//한줄씩 읽어 문자열을 반환, 없으면 null
str=in.readLine();
if(str==null) {
break;
}
System.out.println(str);
}
}
}
문자 필터 스트림 PrintWriter
package io;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterStream {
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new FileWriter("Print.txt"));
out.printf("안녕하세요 저는 %d살 %s입니다.",12,"철수");
out.println();
out.print("저는 자바를 좋아합니다");
out.println("IO 재미있네요.");
out.close();
System.out.println("파일작성 완료");
}
}
스트림(stream)이란? - 데이터를 운반(입출력)하는데 사용되는 연결통로 - 연속적인 데이터의 흐름을 물(stream)에 비유해서 붙여진 이름 - 하나의 스트림으로 입출력을 동시에 수행할 수 없다.(단방향 통신) - 입출력을 동시에 수행하려면, 2개의 스트림이 필요하다.
•자바의 스트림 –입·출력 장치와 프로그램을 연결하며, 이들 사이의 데이터 흐름을 처리하는 소프트웨어 모듈 –데이터를 처리하기 위한 공통된 방법을 제공함 –입력 스트림 : 입력 장치로부터 자바 프로그램으로 전달되는 데이터의 흐름 혹은 데이터 전송 소프트웨어 모듈 –출력 스트림 : 자바 프로그램에서 출력 장치로 보내는 데이터의 흐름 또는 데이터 전송 소프트웨어 모듈
자바 입·출력 스트림의 특징 –스트림은 FIFO 구조 • FIFO : 먼저 들어간 것이 먼저 나오는 형태 → 데이터의 순서가 바뀌지 않음 –스트림은 단방향 • 읽기, 쓰기가 동시에 되지 않음 • 읽는 스트림과 쓰는 스트림을 하나씩 열어 사용해야 함 –스트림은 지연될 수 있음 • 스트림은 넣어진 데이터가 처리되기 전까지는 스트림에 사용되는 스레드가 지연상태에 빠짐 • 네트워크 내에서는 데이터가 모두 전송되기 전까지 네트워크 스레드는 지연상태를 유지함
•InputStream 클래스의 대표적인 두 메소드
public abstract int read() throws IOException
public void close() throws IOException
•OutputStream 클래스의 대표적인 메소드
public abstract void write(int b) throws IOException
public void close() throws IOException
자바 입·출력 스트림의 종류
–바이트 스트림
•문자 단위/바이트 단위 •바이트 스트림은 1바이트를 입·출력 할 수 있는 스트림 •자바에서 입·출력 스트림을 통해 흘러가는 데이터의 기본 단위 •일반적으로 바이트로 구성된 파일을 처리하기에 적합
•바이트 스트림 클래스 –JAVA . IO 패키지 포함 –InputStream/OutputStream
>추상 클래스로써 바이트 입·출력 스트림을 다루는 모든 클래스의 슈퍼 클래스 –FileInputStream/FileOutputStream
>파일로 부터 바이트 단위로 읽거나 저장하는 클래스
>바이너리 파일을 입·출력을 할 때 사용
package io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class ByteFileCopy {
public static void main(String[] args) throws IOException {
// 읽어올 대상 파일의 InputStream 인스턴스를 생성한다.
InputStream in = new FileInputStream("org.pdf");
// 출력 대상 파일의 OutpurStream 인스턴스 생성
OutputStream out = new FileOutputStream("org_copy.pdf");
// 필터스트림 인스턴스 생성
BufferedInputStream bin = new BufferedInputStream(in, 1024*3);
BufferedOutputStream bout = new BufferedOutputStream(out, 1024*3);
int copyByte=0; // 복사한 사이즈
int bData=0; // 원본에서 복사한 byte 사이즈의 데이터
// byte[] buf = new byte[1024]; // 1kb 버퍼생성
// int readLength = 0; // 얼마만큼 읽어왔는지.
System.out.println("복사를 시작합니다.");
while(true) {
bData = in.read(); // 더이상 가져올 데이터가 없으면 -1을 반환
// readLength = in.read(buf);
if(bData==-1) {
// if(readLength==-1) {
break;
}
out.write(bData); // 출력 : 파일에 바이터리 코드를 쓴다.
// out.write(buf,0,readLength);
// copyByte+= readLength;
copyByte++;
}
in.close(); // 스트림 인스턴스 소멸
out.close();
System.out.println("복사가 완료되었습니다.");
System.out.println("복사된 사이즈 : " + copyByte + "byte");
}
}
2개의 문자열을 비교하여(A coomparTo B) 같으면 0, A가 B보다 크면 양수, 적으면음수를 반환
맨 첫자리부터 차례대로 비교한다.
(역주: "A"는 feff0041, "B"는 feff0042) 비교는 스트링내의 각각의 문자의 Unicode 값에 근거해 행해집니다. String 객체에 의해 나타내지는 문자열이, 인자로 전달 받은 스트링의 문자열과 사전적으로 비교됩니다. String 객체가 사전적으로, 전달받은 스트링보다 전에 있는 경우는, 결과는 음의 정수가 됩니다.
equals(Object) 메소드가 true 를 돌려줄 때, compareTo 는 0 을 돌려줍니다.
"사전적의 순서"의 정의는 다음과 같습니다. 2 개의 스트링이 다르다고 한다면, 서로 다른 문자가 문자열 중에 있거나, 2 개의 스트링의 길이가 다르거나, 혹은 그 두 경우 다 해당되는 상황입니다.
만일 하나 또는 그 이상의 위치 (index) 에서 문자가 서로 다를 때, index 중 가장 작은 숫자를 k 라고 가정합니다. k 위치에 있는 두 문자를 < 연산자 로 비교하면, 두 문자중 하나는 다른 문자보다 작습니다. 이 문자를 가진 문자열을 사전적으로 (역주: "A"가 "B"보다 앞에 있는것 처럼) 앞에 있다고 합니다. 이 경우, compareTo 는 2 개의 스트링에서 위치 k 에 있는 2 개의 문자의 값의 차이를 돌려줍니다. 식으로 표현하면 다음과 같습니다.
this.charAt(k) - anotherString.charAt(k)
유효한 모든 인덱스 위치에 있어서의 문자가 같은 경우는, 짧은 길이의 스트링이 사전적으로 앞이 됩니다. 이 경우 compareTo 는 스트링의 길이의 차이를 돌려줍니다. 식으로 표현하면 다음과 같습니다.
* this.length() - anotherString.length()
정의: compareTo in interface Comparable<string></string> 파라미터: 'anotherString - 비교 대상의 String' 반환값 인수 스트링이 스트링과 동일한 경우는 0. 스트링이 주어진 스트링보다 사전식에서 작은 경우는 음수. 주어진 스트링보다 스트링이 사전식에서 큰 경우는 양수.
package Chapter15_Overriding;
public class CompareTo {
public static void main(String[] args) {
String a = "ABC";
String b = "ABC";
String c = "BCD";
String d = "ABCDEF";
System.out.println(a.compareTo(b));
//출력결과 : 0
System.out.println(a.compareTo(c));
//출력결과 : -1
System.out.println(a.compareTo(d));
//출력결과 : -3
}
}
List<E>를 구현하는 클래스들과 달리 Set<E>를 구현하는 클래스들은 데이터의 중복저장을 허용하지 않는다.
(단, 동일 데이터에 대한 기준은 프로그래머가 정의)
package Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetTest {
public static void main(String[] args) {
// HashSet 인스턴스 생성 : 인스턴스를 저장하기 위한 저장 공간 생성
// set : 집합, 저장순서 유지하지않는다.
Set<String> set = new HashSet<String>();
set.add("First");
set.add("Second");
set.add("Third");
set.add("First"); // 중복이라 저장되지 않는다.
System.out.println("set 요소의 개수 : "+ set.size());
Iterator<String> itr=set.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
}
}
<출력>
set 요소의 개수 : 3 Second Third First
// Set<e>는 저장하는 순서를 가지지 않기 때문에 // 일괄처리를 위해서는 Iterator<E> 인스턴스를 이용해서 처리한다. // Collection<E>에는 Iterater() 메서드를 가지고 있고 Iterator<E>를 반환한다.
HashSet<E>클래스의 동등비교
String에는 Hashcode() 가 있어서 지 알아서 중복 분류해주지만 나머지는 해시코드를 만들어줘야한다
package Collection;
public class SimpleNumber {
int num;
public SimpleNumber(int num) {
this.num = num;
}
@Override
public String toString() {
return String.valueOf(num);
}
}
package Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SimpleNumberMain {
public static void main(String[] args) {
// set 인스턴스 생성
Set<SimpleNumber> set=new HashSet<SimpleNumber>();
set.add(new SimpleNumber(10));
set.add(new SimpleNumber(20));
set.add(new SimpleNumber(10));
System.out.println("Set 요소의 개수 : "+set.size());
Iterator<SimpleNumber> itr = set.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
}
}
<출력>
Set 요소의 개수 : 3 10 10 20
<SimpleNumber 수정>
쉬프트 알트 o > gernerate hashcode() and equals()
package Collection;
public class SimpleNumber {
int num;
// Set 동등 비교를 위한 Hashcode(), equals() 오버라이딩
@Override
public int hashCode() {
// final int prime = 31;
// int result = 1;
// result = prime * result + num;
return num%3; // 0 or 1 or 2
}
@Override
public boolean equals(Object obj) {
if (this == obj) // 참조 주소값 == 전달받은 참조 주소값
return true;
if (obj == null) // 들어오는 객체가 null ex) set.add(null)인 경우
return false;
if (getClass() != obj.getClass()) // 클래스 이름비교, 같은 타입인가
return false;
SimpleNumber other = (SimpleNumber) obj;
if (num != other.num)
return false;
return true;
}
public SimpleNumber(int num) {
this.num = num;
}
@Override
public String toString() {
return String.valueOf(num);
}
}
기본 자료형 정보를 이용해서 제네릭 인스턴스 생성 불가능! 따라서 Wraper클래스를 기반으로 컬렉션 인스턴스를 생성한다. (Int 말고 ⭕Integer⭕)
- ArrayList <어떤Type> 이름
형식
기능
이름.get(index)
index에 저장된 저장값 불러오기
이름.size
저장된 요소의 갯수
이름.remove(index)
index에 저장된 것 삭제
이름.add(추가할값)
추가
이름.add(index, 추가할값)
index에 추가할 값을 추가 (그 뒤는 index 하나씩 알아서 뒤로 밀림)
이름.containts(어떤값)
어떤값이 추가하는지 true/false 반환
이름.set(index,수정값)
index 자리에 있는 값을 수정값으로 수정
이름.indexOf(특정값)
특정값이 잇는 index를 반환
이름.isEmpty();
값을 가지고 있으면 true 아니면 false
이름clear();
모든 원소 삭제
package Collection;
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
// 인스턴스 저장을 목적으로 하는 클래스
// List<E> : 저장 순서 유지 (반복문이용 용이), 중복저장 허용
//ArrayList<Integer> list = new ArrayList<Integer>();
//List<Integer> list = new ArrayList();
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println("list의 첫번째 요소의 값 : " + list.get(0));
System.out.println("list 요소의 갯수 : " + list.size());
System.out.println("list 출력");
for (Integer i : list) {
System.out.println(i);
}
// 삭제
list.remove(2);
System.out.println("삭제 후 list 출력");
for (Integer i : list) {
System.out.println(i);
}
}
}
<출력>
list의 첫번째 요소의 값 : 1 list 요소의 갯수 : 4 list 출력 1 2 3 4 삭제 후 list 출력 1 2 4
