[ 서버프로그램 ]


1. server


 - 클라이언트의 접속을 받아들이는 프로그램


 - 서버프로그램의 작성단계

 1) ServerSocket 생성(포트번호필요)

 2) 클라이언트의 접속대기

 3) 클라이언트가 접속해오면 접속을 허용하고 클라이언트와 데이터를 주고받는 Socket생성(accept()메소드)

 4) Socket을 통해 클라이언트와 데이터 주고 받기

 5) 접속종료(소켓닫기)

 


ex> MyServer.java

package test01.net;

import java.io.IOException;

import java.io.InputStream;

import java.net.ServerSocket;

import java.net.Socket;


public class MyServer {

    public static void main(String[] args) {

        ServerSocket server=null;

        Socket sock=null;

        try{

            //1.서버소켓 생성하기

            server=new ServerSocket(3000);

            System.out.println("클라이언트의 접속대기중");


            //2.클라이언트의 접속을 대기하고 클라이언트가 접속해오면 

            //이를 받아들이고 Socket을 생성하기

            sock=server.accept();

            System.out.println("클라이언트가 접속했어요!");


            //상대방으로부터 데이터를 받기위한 스트림객체 얻어오기

            InputStream in=sock.getInputStream();

            byte b[]=new byte[1024];


            //상대방이 보내온 데이터를 읽어와 b배열에 저장.n에는

            //읽어온바이트수크기가 저장된다.

            int n=in.read(b);


            //b배열의 0번째부터 전송한 크기만큼만 String객체로 만들기

            String ss=new String(b,0,n);


            //전송받은 문자열을 화면에 출력하기

            System.out.println("클라이언트가 보내온 메시지:"+ ss);

            

            //4. 접속종료(소켓닫기)      

            sock.close();

            server.close();

        }catch(IOException ie){

            System.out.println(ie.getMessage());

        }

        System.out.println("프로그램이 종료합니다.");

    }

}

 




[ 클라이언트 프로그램 ]


2. client


 - 서버에 접속하는 프로그램

 - 클라이언트 프로그램 작성단계

 1) Socket을 이용하여 서버에 접속(ip주소,포트번호 필요)

 2) Socket을 이용하여 데이터 주고받기(이때 stream을 사용한다.)

 3) 접속끊기(소켓종료)



 

ex>  MyClient.java

package test01.net;

import java.io.IOException;

import java.io.OutputStream;

import java.net.Socket;

import java.net.UnknownHostException;


public class MyClient {

    public static void main(String[] args) {

        Socket sock=null;

        try{

            sock=new Socket("192.168.0.2",3000);

            System.out.println("서버에 접속성공!");


            String msg="반가워요 서버~";


            //상대방에 데이터를 보내기위한 스트림객체 얻어오기

            OutputStream os=sock.getOutputStream();


            //String객체를 바이트배열로 변환해서 데이터 보내기->os가 1바이트처리

            //스트림이므로

            os.write(msg.getBytes());

            os.flush();//버퍼가 다 차지 않아도 데이터 보내라.

            System.out.println("메시지 보내기 성공!");

            

            //소켓닫기

            sock.close();

        }catch(UnknownHostException ue){

            System.out.println(ue.getMessage());

        }catch(IOException ie){

            System.out.println(ie.getMessage());

        }

    }

}



 

 

'JAVA' 카테고리의 다른 글

Network - 채팅 샘플 ( Ⅲ )  (0) 2014.09.12
Network ( Ⅱ )  (0) 2014.09.12
스레드(Thread)  (0) 2014.09.12
재귀 메소드  (0) 2014.09.12
File 클래스  (0) 2014.09.12

 

1. 스레드(Thread) 


- 하나의 응용프로그램에서 여러개의 작업을 경량의 프로세스로 나누어 실행하는것


- 시간이 오래지연되는 작업이나,동시에 실행되어야 하는 작업이 있을때 스레드로 만든다.

 예) 파일복사하기(시간이지연되는작업), 파일다운로드받기(동시에다운받기)

     프린터로출력하기,게임프로그램에서 이미지를동시에이동하기,...


- 만드는 방법


방법1) Thread클래스를 상속받아 만들기

     - Thread클래스를 상속받아 run메소드를 오버라이딩한다.

       스레드를 실행할때는 start메소드를 사용한다.


방법2) Runnable인터페이스를 상속받아 만들기



ex>1.스레드클래스 상속받아 만들기.

package test02.thread;

//방법1)

//1.스레드클래스 상속받기

class MyPrinter extends Thread{

    //2.run메소드 오버라이딩하기

    public void run(){

        for(int i=1;i<=1000;i++){

            System.out.print("프린터로 출력중.....");

            if(i%10==0) System.out.println();

        }

    }

}

public class Test01_Thread {

    public static void main(String[] args){

        //스레드객체 생성하기

        MyPrinter mp=new MyPrinter();


        //스레드로 구동하기==>start메소드가 

        // 내부적으로 run메소드호출

        mp.start();


        //printer();

        for(int i=1;i<=1000;i++){

            System.out.print("문서작업중.....");

            if(i%10==0) System.out.println();

        }

    }

    /-

    public static void printer(){

        for(int i=1;i<=1000;i++){

            System.out.print("프린터로 출력중.....");

            if(i%10==0) System.out.println();

        }

    }*-

}

 


ex>

package test02.thread;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Scanner;

public class Test02_Thread{


    public static void main(String[] args){


        Scanner scan=new Scanner(System.in);


        while(true){

            System.out.println("1.파일복사 2.디렉토리크기 3.종료");

            int n=scan.nextInt();

            switch(n){

                case 1:filecopy();break;

                case 2:long size=getSize(new File("c:\\java"));

                       System.out.println("디렉토리크기:" + size +"bytes");

                       break;

                case 3:System.exit(0);

            }

        }

    }


    //파일복사하는 기능

    public static void filecopy(){

        try{

            FileInputStream fis=new FileInputStream("c:\\java\\java.exe");

            FileOutputStream fos=new FileOutputStream("c:\\java\\copy.exe");

            byte[] b=new byte[50];

            int n=0;

            while((n=fis.read(b))!=-1){

                fos.write(b,0,n);

            }

            fos.close();

            fis.close();

            System.out.println("[[[[[[[[[  파일복사성공!!!!   ]]]]]]]]]]]]");

        }catch(IOException ie){

            System.out.println(ie.getMessage());

        }

    }

    public static long getSize(File f){

        long size=0;

        File list[]=f.listFiles();

        for(File ff:list){

            if(ff.isFile()){

                size+=ff.length();

            }else{

                size+=getSize(ff);

            }

        }

        return size;

    }

}

 

 

 

ex>

package test02.thread;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Scanner;


class FileCopyThread extends Thread{

    public void run(){

        try{

            FileInputStream fis=new FileInputStream("c:\\java\\java.exe");

            FileOutputStream fos=new FileOutputStream("c:\\java\\copy.exe");

            byte[] b=new byte[50];

            int n=0;

            while((n=fis.read(b))!=-1){

                fos.write(b,0,n);

            }

            fos.close();

            fis.close();

            System.out.println("[[[[[[[[[  파일복사성공!!!!   ]]]]]]]]]]]]");

        }catch(IOException ie){

            System.out.println(ie.getMessage());

        }

    }

}

public class Test03_Thread {

    public static void main(String[] args) {

        Scanner scan=new Scanner(System.in);

        while(true){

            System.out.println("1.파일복사 2.디렉토리크기 3.종료");

            int n=scan.nextInt();

            switch(n){

                case 1:FileCopyThread thread=new FileCopyThread();

                       thread.start();

                       break;

                case 2:long size=getSize(new File("c:\\java"));

                       System.out.println("디렉토리크기:" + size +"bytes");

                       break;

                case 3:System.exit(0);

            }

        }    

    }

    

    public static long getSize(File f){

        long size=0;

        File list[]=f.listFiles();

        for(File ff:list){

            if(ff.isFile()){

                size+=ff.length();

            }else{

                size+=getSize(ff);

            }

        }

        return size;

    }

}

 

 


ex> 방법2 >>

package test02.thread;

//1. Runnable 인터페이스 상속받기

class FileCopy implements Runnable{

    //2. run메소드 오버라이딩하기

    public void run() {

        for(int i=1;i<=100;i++){

            System.out.println("파일복사중...");

            try{

                //스레드를 1초동안 지연시키기

                Thread.sleep(1000);

            }catch(InterruptedException ie){

                System.out.println(ie.getMessage());

            }

            if(i%10==0) System.out.println();

        }

        System.out.println("파일복사완료!!!!");

    }

}

public class Test04_Runnable {


    public static void main(String[] args) {    

        //3. Runnable자식객체 생성

        FileCopy fc=new FileCopy();


        //4. Thread클래스를 이용해서 스레드로 구동시키기

        Thread th=new Thread(fc);


        th.start();

        //new Thread(fc).start();


        for(int i=1;i<=100;i++){

            System.out.println("문서작업중...");

            try{

                Thread.sleep(1000);//1초동안 스레드 지연시키기

            }catch(InterruptedException ie){

                System.out.println(ie.getMessage());

            }

            if(i%10==0) System.out.println();

        }

    }

}





ex>  1초에 한번씩 현재 시간을 얻어와 출력하는 스레드와

1초에 한번씩 난수를 얻어와 출력하는 스레드를 만들고 실행시켜 보세요.


package test02.thread;

import java.util.Calendar;

import java.util.Random;


class TimeThread extends Thread{

    public void run() {

        while(true){

            Calendar cal=Calendar.getInstance();

            String t=cal.get(Calendar.HOUR_OF_DAY) + "시" +

                     cal.get(Calendar.MINUTE) +"분" +

                     cal.get(Calendar.SECOND) +"초";

            System.out.println(t);

            try{

                Thread.sleep(1000);

            }catch(InterruptedException ie){

                System.out.println(ie.getMessage());

            }

        }

    }

}

class RndThread implements Runnable{

    public void run(){

        Random rnd=new Random();

        while(true){

            int n=rnd.nextInt(100);

            System.out.println("난수:"+ n);

            try{

                Thread.sleep(1000);

            }catch(InterruptedException ie){

                System.out.println(ie.getMessage());

            }

        }

    }

}

public class Quiz01 {

    public static void main(String[] args) {

        //TimeThread tt=new TimeThread();

        //tt.start();

        new TimeThread().start();

        new Thread(new RndThread()).start();

    }

}



 

ex> Message.java

package test01.thread;
//스레드간에 공유하게 될 클래스
public class Message {
    private String msg="";
    public boolean status=false;
    public void setMsg(String msg){
        this.msg+=msg;
    }
    public String getMsg(){return msg;}
}

Test01_useMsg.java
package test01.thread;
class ReadThread extends Thread{
    private Message msg;
    public ReadThread(Message msg){
        this.msg=msg;
    }
    public void run(){
        for(char a='A';a<='Z';a++){
            msg.setMsg(String.valueOf(a));
        }
        System.out.println("Message객체에 저장 완료!");
    }
}
class WriteThread extends Thread{
    private Message msg;
    public WriteThread(Message msg){
        this.msg=msg;
    }
    public void run(){
        System.out.println("다운로드된 데이터를 출력합니다.");
        System.out.println(msg.getMsg());
    }
}
public class Test01_useMsg {
    public static void main(String[] args) {
        Message msg=new Message();//공유자원이 될 객체
        //스레드생성하기
        ReadThread rt=new ReadThread(msg);
        WriteThread wt=new WriteThread(msg);
        //스레드 구동하기(start메소드로 스레드 구동!!!)
        rt.start();
        wt.start();
    }
}
 
 
 


[ 스레드의 동기화 ]
- 하나의 자원(객체)을 여러개의 스레드가 공유해서 사용할때 하나의 스레드가 객체를 사용중이면 다른 스레드는 사용할 수 없으며 락(lock)을 걸어두는것.
- 동기화처리방법

  방법1) 
  동기화해야할 객체를 synchronized블록으로 묶기
   synchronized(공유객체){
   ...
   }

   방법2)
  동기화될 객체 자체에서 동기화 처리하기-동기화메소드로 만들기
   public synchronized 리턴형 메소드명(매개변수,..){
   ..
   }

ex2> 동기화처리 방법2) 공유자원 객체 자체에서 동기화 처리하기(동기화메소드)
Message.java
package test02.sync;
//스레드간에 공유하게 될 클래스
//동기화처리 방법2) 공유자원 객체 자체에서 동기화 처리하기(동기화메소드)
public class Message {
    private String msg="";
    private boolean status=false;
    public synchronized void setMsg(String msg){
        for(int i=0;i<100000000;i++);//시간지연
        this.msg+=msg;
        status=true;//작업이 완료됨을 표시
        notify();//wait()로 대기중인 객체를 깨움
    }
    public synchronized String getMsg(){
        if(status==false){//아직 임시저장소에 저장하는 작업이 완료되지 않았다면
            try{
                wait();//notify()로 신호가 올때까지 대기상태가 됨
            }catch(InterruptedException ie){}
        }
        return msg;
    }
}

Test02_synchronized.java
package test02.sync;
import test01.thread.Message;

class ReadThread extends Thread{
    private Message msg;
    public ReadThread(Message msg){
        this.msg=msg;
    }
    public void run(){
        //공유자원객체(msg)를 synchronized 블록으로 묶기
        //블록이 끝날때까지 다른 스레드는 msg를 사용하지 못하고 대기상태가 된다.
        synchronized (msg) {
            System.out.println("임시저장소에 데이터를 저장하기 시작!");
            for(char a='A';a<='Z';a++){
                msg.setMsg(String.valueOf(a));
                for(int i=1;i<=1000000000;i++);//시간지연하기
            }
            System.out.println("Message객체에 저장 완료!");
            msg.status=true;//작업이 완료됨을 표시
            msg.notify();//wait중인 다른 스레드를 깨움.
        }
    }
}
class WriteThread extends Thread{
    private Message msg;
    public WriteThread(Message msg){
        this.msg=msg;
    }
    public void run(){
        synchronized(msg){
            if(msg.status==false){//임시저장소에 저장하는 작업이 아직 안끝났으면
                try{
                    msg.wait();//notify로 신호가 올때까지 대기하기
                }catch(InterruptedException ie){
                    System.out.println(ie.getMessage());
                }
            }
            System.out.println("다운로드된 데이터를 출력합니다.");
            System.out.println(msg.getMsg());
        }
    }
}
public class Test02_synchronized {
    public static void main(String[] args) {
        Message msg=new Message();//공유자원이 될 객체
        ReadThread rt=new ReadThread(msg);
        WriteThread wt=new WriteThread(msg);
        rt.start();
        wt.start();
    }
}


Test03_synchronized.java
package test02.sync;
class ReadThread1 extends Thread{
    private Message msg;
    public ReadThread1(Message msg){
        this.msg=msg;
    }
    public void run(){
        msg.setMsg("아리랑");
        System.out.println("Message객체에 저장 완료!");
    }
}
class WriteThread1 extends Thread{
    private Message msg;
    public WriteThread1(Message msg){
        this.msg=msg;
    }
    public void run(){
        System.out.println("다운로드된 데이터를 출력합니다.");
        System.out.println(msg.getMsg());
    }
}
public class Test03_synchronized {
    public static void main(String[] args) {
        //공유자원객체 생성
        Message obj=new Message();
        //스레드 실행하기
        new ReadThread1(obj).start();
        new WriteThread1(obj).start();
    }
}


Test04_ThreadStop.java
package test02.sync;
class MyThread extends Thread{
    private boolean stop=true;
    public void setStop(boolean stop){
        this.stop=stop;
    }
    @Override
    public void run() {
        while(stop){
            System.out.println("1.스레드로 작업수행중!");
            System.out.println("2.스레드로 작업수행중!");
            System.out.println("3.스레드로 작업수행중!");
            System.out.println("스레드로 작업완료!");
        }
    }
}
public class Test04_ThreadStop {
    public static void main(String[] args) {
        MyThread th=new MyThread();
        th.start();
        try{
            //2초후 스레드 지연하기
            Thread.sleep(2000);
        }catch(InterruptedException ie){
            System.out.println(ie.getMessage());
        }
        th.setStop(false);//스레드 멈추기
    }
}




 


 

 

'JAVA' 카테고리의 다른 글

Network ( Ⅱ )  (0) 2014.09.12
Network ( Ⅰ )  (0) 2014.09.12
재귀 메소드  (0) 2014.09.12
File 클래스  (0) 2014.09.12
자바 IO ( Ⅱ )  (0) 2014.09.12

 

1. 재귀메소드 


- 자기자신을 호출하는 메소드


ex>재귀메소드를 사용해서 팩토리얼값 구하는 예제

package test01.file;

public class Test04_재귀메소드 {


    public static void main(String[] args){

        int n=4;

        //팩토리얼값 구해오기

        int num=fac(n);

        System.out.println(n+"!="+num);

    }

    public static int fac(int n){

        return (n>1)?n*fac(n-1):n;

    }

}

 

 





ex> c:\\java\\test 폴더를 삭제해 보세요.


package test01.file;

import java.io.File;

public class Quiz01 {


    public static void main(String[] args){


        File f=new File("c:\\java\\test");

        if(f.exists()){

            //test폴더안의 파일목록들 얻어오기

            File[] list=f.listFiles();

            for(File ff:list){

                if(ff.isFile()){

                    //디렉토리 안의 파일지우기

                    ff.delete();

                }

            }

            if(f.delete()){

                System.out.println("디렉토리 삭제 성공!");

            }

        }

    }

}

 

 



ex> c:\\java\\test 폴더를 삭제해 보세요. 

test폴더안에는 파일도 존재하고 디렉토리도 존재한다.

==>재귀메소드를 사용해 보세요.. 

package test01.file;

import java.io.File;


public class Quiz02 {


    public static void main(String[] args){


        File f=new File("c:\\java\\test");

        if(delDir(f)){

            System.out.println("디렉토리 삭제 성공");

        }else{

            System.out.println("디렉토리 삭제 실패");

        }

    }

    public static boolean delDir(File f){

        //디렉토리 안의 목록들 얻어오기

        File []list=f.listFiles();


        //디렉토리 안의 목록들을 삭제하기

        for(int i=0;i<list.length;i++){

            //목록이 파일이면

            if(list[i].isFile()){

                //파일삭제하기

                list[i].delete();

            }else{

                //목록이 디렉토리면

                //자신의메소드호출

                //(디렉토리안의목록들을삭제하기위해)

                delDir(list[i]);

            }

        }


        //자기자신의 폴더 삭제하기

        if(f.delete()){

            return true;

        }else{

            return false;

        }        

    }

}

 

 

 

 

 

ex>c:\\java\\test 폴더의 크기를 구해 보세요.

- 쉬운방법 : test폴더에 파일만 존재하는 경우

- 어려운방법 : 폴더안에 또 폴더가 존재하는 경우


package test01.file;

import java.io.File;


public class Quiz03 {

    public static void main(String[] args){

        File f=new File("c:\\java\\test");

        long size=getDirSize(f);

        System.out.println("디렉토리 크기:" + size +"bytes");

    }


    public static long getDirSize(File f){

        long fsize=0;

        File[] list=f.listFiles();

        for(int i=0;i<list.length;i++){

            if(list[i].isFile()){

                fsize+=list[i].length();

            }else{

                fsize+=getDirSize(list[i]);

            }

        }

        return fsize;

    }

}   

 

 



 

 

'JAVA' 카테고리의 다른 글

Network ( Ⅰ )  (0) 2014.09.12
스레드(Thread)  (0) 2014.09.12
File 클래스  (0) 2014.09.12
자바 IO ( Ⅱ )  (0) 2014.09.12
자바 IO - Stream ( Ⅰ )  (0) 2014.09.12

 

1. File클래스(*) 


- 파일 또는 디렉토리에 관련된 정보를 갖는 클래스



ex> 특정 경로의 폴더가 존재하는 지 확인 후 삭제/생성하기.

package test01.file;

import java.io.File;

public class Test01_File {


    public static void main(String[] args){

        File f=new File("c:\\java\\test");

        if(f.exists()){

            System.out.println("디렉토리가 존재합니다.");

            if(f.delete()){//디렉토리를 삭제함

                System.out.println("디렉토리를 삭제했어요!");

            }else{

                System.out.println("디렉토리 삭제 실패했어요!");

            }

        }else{

            System.out.println("디렉토리가 존재하지 않아요!");

            f.mkdir();//디렉토리 생성하기

            System.out.println("디렉토리를 생성했습니다.");

        }        

    }

}





ex> 파일크기, 파일이름, 절대경로 얻어오기.

package test01.file;

import java.io.File;

public class Test02_File{


    public static void main(String[] args){


        File f=new File("c:\\java\\movie1.jpg");


        if(f.exists()){

            

            //파일크기 얻어오기

            long size=f.length();

            System.out.println("파일크기:" + size +"bytes");


            //파일이름 얻어오기

            String fileName=f.getName();

            System.out.println("파일명:" + fileName);


            //파일의 절대경로 얻어오기

            String path=f.getAbsolutePath();

            System.out.println("경로를 포함한 파일명:" + path);


        }else{

            System.out.println("존재하지 않는 파일입니다.");

        }

        

        //현재작업디렉토리안에 있는

        //movie1.jpg에 대한 정보를 갖는 File객체

        File f1=new File("movie1.jpg");


        if(f1.exists()){

            System.out.println("파일명:" + f1.getName());

            System.out.println("절대경로:" + f1.getAbsolutePath());

        }

    }

}

 

 

 

ex>파일 정보를 File객체배열에 얻어와 보이기

package test01.file;

import java.io.File;

public class Test03_File{


    public static void main(String[] args){


        File f=new File("c:\\java");


        //디렉토리안의 파일명과 디렉토리명을

        //문자열배열로 얻어옴

        //public String[] list()

        String ss[]=f.list();


        for(int i=0;i<ss.length;i++){

            System.out.println(ss[i]);

        }


        //디렉토리안의 파일명과 디렉토리를

        //File객체배열로 얻어옴

        //public File[] listFiles()

        File[] flist=f.listFiles();


        for(int i=0;i<flist.length;i++){

            //목록이 파일이면

            if(flist[i].isFile()){

                //파일크기 구하기

                long size=flist[i].length();


                System.out.println(flist[i].getName()+",파일크기:"+size+"bytes");

            }else{

                //목록이 디렉토리인경우

                System.out.println(flist[i].getName());

            }

        }        

    }

}

 

 

 

 

'JAVA' 카테고리의 다른 글

스레드(Thread)  (0) 2014.09.12
재귀 메소드  (0) 2014.09.12
자바 IO ( Ⅱ )  (0) 2014.09.12
자바 IO - Stream ( Ⅰ )  (0) 2014.09.12
예외처리 ( Exception )  (0) 2014.09.12

 

1. BufferedOutputStream

- 버퍼기능을 강화시킨 1바이트 출력스트림처리 클래스


EX> public BufferedOutputStream(OutputStream out)
package test01.filter;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test01_BufferedOutputStream
{
    public static void main(String[] args)
    {
        //public BufferedOutputStream(OutputStream out)
        BufferedOutputStream fos=null;

        try
        {
            //화면에 출력하기위한 1바이트 처리스트림객체 얻어오기
            //OutputStream out=System.out;

            //파일에 출력하기위한 1바이트 처리스트림 객체 생성하기
           OutputStream out=new FileOutputStream("test.dat");

            //버퍼의 크기가 1024byte인 출력스트림 생성하기
            //fos=new BufferedOutputStream(out,1024);
            fos=new BufferedOutputStream(out);

            //public void write(byte[] b, int off,int len) throws IOException
            byte[] b={65,66,67,68,69,70};
            //b배열0번째부터 배열을 크기만큼 파일에 출력하기
            fos.write(b,0,b.length);

            //fos.flush();
            fos.close();//스트림닫기
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }
    }
}
  
 

EX> hello.txt라는 파일에 2byte처리 스트림을 사용해서 문자열 출력하기.
package test01.filter;
import java.io.FileNotFoundException;
import java.io.OutputStream;
import java.io.PrintWriter;

public class Test02_PrintWriter
{
    public static void main(String[] args)
    {
        OutputStream os=System.out;

        //화면에 출력하기위한 2바이트 처리스트림객체 생성
        PrintWriter pw=new PrintWriter(os);

        pw.println("안녕하세요!");
        pw.println("반가워요~~~");

        //pw.close();        
        PrintWriter pw1=null;

        try
        {
            //파일에 데이터를 출력하기위한 2바이트 처리스트림객체 생성
            pw1=new PrintWriter("hello.txt");

            //파일에 문자열 출력하기
            pw1.println("안녕!");
            pw1.println("만나서 반가워요~~~");

            pw1.close();
            System.out.println("파일로 저장성공!");
        }catch(FileNotFoundException fe){
            System.out.println(fe.getMessage());
        }        
    }
}
 


 
2. DataOutputStream

 - 기본자료형(int,char,byte,long,double,..) 을 출력하는 기능을 갖는 스트림


EX> 파일에 기본자료형을 출력하기
package test01.filter;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test03_DataOutputStream
{
    public static void main(String[] args)
    {
        int a=100;
        char b='C';
        boolean c=10>5;
        double d=3.45;
        float f=4.5f;
        
        DataOutputStream dos=null;

        try{

            //파일에 기본자료형을 출력하기위한 스트림객체 생성
            dos=new DataOutputStream(new FileOutputStream("data.dat"));

            //int형을 파일에 저장->4바이트로저장
            dos.writeInt(a);

            //char형을 파일에 저장->2바이트로 저장
            dos.writeChar(b);

            //boolean형을 파일에 저장
            dos.writeBoolean(c);

            //double형을 파일에 저장->8바이트로저장
            dos.writeDouble(d);

            //float을 파일에 저장
            dos.writeFloat(f);

            //utf-8인코딩방식으로 문자열 저장하기
            dos.writeUTF("안녕");

            dos.close();
            System.out.println("파일로 저장성공");

        }catch(FileNotFoundException fe){
            System.out.println(fe.getMessage());
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }
    }
}
 
 



3. DataInputStream

 - 기본자료형(int,char,byte,long,double,..) 을 읽어오는 기능을 갖는 스트림

EX> 파일에서 데이터 읽어와 저장된 순서대로 읽기
package test01.filter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test04_DataInputStream
{
    public static void main(String[] args)
    {
        DataInputStream dis=null;
        int a;
        char b;
        boolean c;
        double d;
        float f;

        try{
            //파일에서 기본자료형을 읽어오기위한 스트림객체 생성
            dis=new DataInputStream(new FileInputStream("data.dat"));

            //파일에서 데이터를 읽어올때는 저장된 순서대로 읽어온다.
            //파일에서 int데이터읽어오기(4바이트읽어옴)
            a=dis.readInt();

            //파일에서 char데이터읽어오기(2바이트읽어옴)
            b=dis.readChar();

            //파일에서 boolean데이터읽어오기(1바이트읽어옴)
            c=dis.readBoolean();

            //파일에서 double데이터읽어오기(8바이트읽어옴)
            d=dis.readDouble();

            //파일에서 float데이터읽어오기(4바이트읽어옴)
            f=dis.readFloat();

            String aa=dis.readUTF();
            System.out.println("a:" + a);
            System.out.println("b:" + b);
            System.out.println("c:" + c);
            System.out.println("d:" + d);
            System.out.println("f:" + f);
            System.out.println("aa:" + aa);

            dis.close();
        }catch(FileNotFoundException fe){
            System.out.println(fe.getMessage());
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }
    }
}
 
 
 


4. ObjectOutputStream 

 - 객체를 저장(출력)할때 사용되는 1바이트 처리 스트림
 

EX> 출력스트림 객체(FileOutputStream)를 생성하여 파일에 출력하기.
package test01.filter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Test05_ObjectOutputStream
{
    public static void main(String[] args)
    {
        ObjectOutputStream dos=null;

        try{
            //파일에 객체를 저장하기 위한 출력스트림객체 생성
            dos=new ObjectOutputStream(new FileOutputStream("test.ser"));

            //객체를 파일로 저장하기
            dos.writeObject(new String("hello"));
            dos.writeObject(new Integer(100));
            dos.writeObject(new Date());

            dos.close();
            System.out.println("객체를 파일로 저장성공!");
        }catch(FileNotFoundException fe){
            System.out.println(fe.getMessage());
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }
    }
}
 
 

EX> 파일에서 읽어와(FileInputStream) 화면에 출력하기.
package test01.filter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;

public class Test06_ObjectInputStream
{
    public static void main(String[] args)
    {
       ObjectInputStream ois=null;

        try{
            //파일에서 객체를 읽어오기위한 스트림 객체 생성
           ois=new ObjectInputStream(new FileInputStream("test.ser"));

            //파일에서 객체 읽어오기
            String str=(String)ois.readObject();
            Integer in=(Integer)ois.readObject();
            Date d=(Date)ois.readObject();

            System.out.println(str);
            System.out.println(in);
            System.out.println(d);

            ois.close();

        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }catch(ClassNotFoundException ce){
            System.out.println(ce.getMessage());
        }
    }
}
 
 
 

5. Serialization 

객체의 직렬화 -> 객체를 바이트단위로 일렬로 나열하는 것
 객체의 역직렬화 -> 직렬화된 객체를 다시 조합하는것
 
직렬화가능한 클래스를 만들려면 Serializable인터페이스를 상속받아야 한다.


EX>
package test01.filter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
 
public class Test07_ObjectOutputStream
{
    public static void main(String[] args)
    {
        Person per=new Person("홍길동","123456-4322111");

        ObjectOutputStream oos=null;

        try{
            oos=new ObjectOutputStream(new FileOutputStream("per.ser"));
            oos.writeObject(per);
            oos.close();
            System.out.println("객체저장성공!");
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }
    }
}

 
package test01.filter;
import java.io.Serializable;

//직렬화가능한 클래스 만들기==>Serializable인터페이스를 상속받는다.
//transient : 직렬화가 되지 않는다.
//static : 직렬화가 되지 않음.
public class Person implements Serializable{
    private String name;//이름
    public static final String aa="HongGilDong";
    
    //주민번호.transient가 있으므로 직렬화가 안됨
    private transient String sid;

    public Person(String name,String sid){
        this.name=name;
        this.sid=sid;
    }
    public String getName(){return name;}
    public String getSid(){return sid;}
}

per.ser파일에 저장된 객체를 읽어와 화면에 출력하세요!
package test01.filter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Test08_ObjectInputStream
{
    public static void main(String[] args)
    {
        ObjectInputStream ois=null;

        try{
            ois=new ObjectInputStream(new FileInputStream("per.ser"));
            Person per=(Person)ois.readObject();
            System.out.println("이름:" + per.getName());
            System.out.println("주민번호:" + per.getSid());
            System.out.println(Person.aa);
            ois.close();
        }catch(IOException ie){
            System.out.println(ie.getMessage());
        }catch(ClassNotFoundException ce){
            System.out.println(ce.getMessage());
        }
    }
}
 
 
 

 

 

'JAVA' 카테고리의 다른 글

재귀 메소드  (0) 2014.09.12
File 클래스  (0) 2014.09.12
자바 IO - Stream ( Ⅰ )  (0) 2014.09.12
예외처리 ( Exception )  (0) 2014.09.12
Calendar 클래스  (0) 2014.09.12

+ Recent posts