BA

package IO;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;

public class url {
    public static void main(String[] args){
        String url="http://www.google.com";
        try {
            URL home=new URL(url);
            System.out.println("Port: "+home.getPort());
            System.out.println("Protocol: "+ home.getProtocol());
            System.out.println("Host: "+ home.getHost());
            System.out.println("File: "+ home.getFile());
            System.out.println("Ref: "+ home.getRef());
        ///////////////////////////////////////////////////////////////////////////////
            home=new URL("http://naver.com");
            BufferedReader br=new BufferedReader(new InputStreamReader(home.openStream(),"utf-8"));
           
            String line;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
            br.close();
           
        } catch (Exception e) {
            e.printStackTrace();
        }   
    }
}

애플리게이션은 애플리게이션의 코드를 통해 독립적인 실행 경로를 갖는 스레드를 통해 실행된다. 만일 여러개의 스레드가 실행되면 그레드 별로 다른 경로를 가지게 되는데 예를 들어 한 애플리케이션에 여러개의 스레드가 실행될 경우 코드에 switch문이 있을 때 스레드 별로 분리되어 서로 다른 case절이 실행 될 수 있다.

스레드는 애플리케이션의 성능을 높이기 위해 사용한다. 애플리게이션의 목적에 따라 일부 애플리게이션은 주어진 작업을 수행하기 위해 오직 기본 main 스레드만을 사용할 수 있으며, 다른 일부 애플리케이션은 시간이 많이 소요되는 작업을 백그라운드에서 처리하기 위해 추가적인 스레드를 사용하기도 한다.대기 시간이 길어지는 작업을 백그라운드로 스레드로 처리하며 백그라운드 작업의 종료 여부와 상관없이 지속적으로 사용자의 요구에 대응을 할 수 있다.

JVM은 스레드간의 간섭을 방지하기 위해 스레드별로 메소드 호출 스택을 갖고 만든다. 이 분리된 스택들은 스레드의 명령을 수행할 경로를 유지시켜 주며 더불어 이 스택은 메소드 파라미터, 로컬 변수 그리고 반환값의 복사본과 스레드를 제공한다.

자바는 Threading API를 통해 스레드를 지원하는데 이 API는 java.lang.package에 위치하며 하나의 인터페이스(Runnable) 그리고 네개의 클래스 (Thread, ThreadGroup, ThreadLocal, InheritableThreadLocal)로 구성되어 있다.

자바 5에서는 낮은 수준의 Threading API에 대한 대안이 되는 높은 수준의 java.util.concurrent 패키지를 소래한다. 비록 java.util.concurrent가 개발자가 선호하는 API 형태로 스레드와 작업을 제공하지만 간단한 스레딩을 작성할 경우 낮은 수준의 Threading API가 도움이 된다.

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

Runnable과 Thread

자바에서는 인터페이스의 void run() 메소드(인자와 반환값이 없음)를 통해 스레드를 실행시키는 코드를 포함하고 있는 객체를 식별하기 위한 Runnable 인터페이스를 제공한다. 클래스에서는 스레드 코드를 제공하기 위해서 Runnable을 구현하며 이런 클래스 중 하나가 Thread클래스이다.

Thread 클래스는 애플리케이션이 실행되는 운영체제의 스레딩 아키텍처와 일치하는 인터페이스를 제공한다(일반적으로 운영체제에서 스레드의 생성과 관리에 대한 책임을 진다). Thread클래스는 코드와 스레드를 연결하고, 스레드들에 대한 시작과 관리를 하며 각각의 Thread 인스턴스는 각각의 스레드와 연결이 된다.

Thread 클래스에는 Thread 객체를 초기화하는 몆가지 생성자가 선언되어 있는데 일부 생성자는 Runnable을 인자로 받으며 Thread의 확장없이 실행 될 수 있는 코드를 제공 할 수 있다. Runnable로 초기화하지 않고, 대신 Thread의 서브 클래스에서 Thread()를 호출하는 생성자를 제공하여야 하며 서브 클래스에서 Thread의 run() 메소드를 오버라이드 해야 한다.

인자에 명시된 이름이 없기 때문에 각 생성자는 Thread객체에 Thread-로 시작되며 중복이 안되는 기본 이름을 할당한다. 이렇게 동적으로 생성되고 중복이 안되는 이름을 사용해 서로 다른 스레드를 만드를 것이 가능하다. 동적으로 중복이 안되는 기본 이름이 제공되는 위의 두 생성자와는 달리 Thread(String threadName) 생성자에서는 스레드의 이름을 임의로 저장할 수 있다.

Thread 클래스에서는 스레드를 시작하고 관리할 수 있는 메소드를 포함하고 있다

스레드 메소드들

static Thread currentThread()

이 메소드를 호출한 스레드와 연관되어 있는 Thread 객체를 반환한다.

String getName()

현재 Thread 객체의 이름을 반환한다.

Thread.State getState()

현재 Thread 객체와 연관되어 있는 스레드의 상태를 반환한다. 상태는 Thread.State enum형으로 식별이 되며 상태에는 BLOCKED(lock 대기), NEW(생성하지만 시작은 안함), RUNNABLE(실행중), TERMINATED(스레드 종료), TIMED_WAITING(지정한 시간만큼 대기), WAITING(무기한 대기) 등이 있다.

void interrupt()

현재 Thread객체에 인터럽트 상태 플래그를 설정한다. 만일 스레드가 블록 또는 대기 상태가 되면 이 플래그가 클리어되고 InterruptedException 클래스의 인스턴스가 던져져 스레드가 꺠어나게 된다.

static boolean interrupted()

스레드에 보류된 인터럽트 요청이 있을 경우 true를 반환한 후 인터럽트 상태 플러그를 클리어 한다.

boolean isAlive()

현재 Thread 객체와 연관된 스레드가 활동 상태에 있을 때 true를 반환한다. 데몬 스레드는 사용자 스레드를 도와주며 애플리케이션의 마지막 비데몬 스레드가 종료되어 애플리게이션이 종료될 때 자동적으로 종료된다. 현재 Thread객체와 관련되어 있는 스레드가 데몬 스레드 일 때 true를 반환한다. 데몬 스레드는 사용자 스레드에 대한 헬퍼 스레드 역할을 하며 애플리게이션의 마지막 일반 스레드(데몬 스레드가 아닌 스레드) 가 종료될 떄 자동적으로 종료된다.

boolean isInterrupted()

현재 Thread 객체와 연관되어있는 스레드에 보류되어 있는 인터럽트 요청이 있을 때 true를 반환한다.

void join()

현재 Thread 객체에서 이 메소드를 호출한 스레드를 객체와 연관된 스레드가 종료할 때까지 기다린다. 이 메소드는 대기중에 현재 Thread 객체의 interrupt() 메소드가 호출되면 InterruptedException이 던져진다.

void join(long mills)

호출한 메소드 스레드가 종료될 때까지 또는 지정한 시간동안 대기한다. 이 메소드는 대기중에 현재 Thread 객체의 interrupt() 메소드가 호출되면 InterrptedException이 던져진다.

void setDaemon(boolean isDaemon)

인자 isDaemon을 true로 지정하면 현재 Thread 객체와 연관된 스레드를 데몬 스레드로 설정한다. 스레드는 생성 또는 시작하기 전에 호출되면 java.lang.illegalThreadStateException이 던져진다.

void setName(String threadName)

인자 threadName의 값을 현재 Thread 객체 이름으로 지정한다.

static void sleep (long time)

지정한 시간(밀리 초) 만큼 현재 Thread 객체와 연관된 스레드를 일시 정지 시킨다. 스레드가 일지 정지되어 있는 동안 스레드 객체의 interrupt() 메소드가 호출되면 InterruptedException이 던져진다.

void start()

현재 Thread 객체와 연관되어있는 스레드를 생성하고 시작한다. 스레드가 이미 시작되어 실행중이거나 종료되어 있는 상태이면 IllegalThreadStateException을 던진다.

--------

package Thread;

public class CountingThreads {
    public static void main(String[] args){
        Runnable r=new Runnable() {
           
            @Override
            public void run() {
                String name=Thread.currentThread().getName();
                int count=0;
                while(true){
                    System.out.println(name+": "+count++);
                }
            }
        };

        Thread thdA =new Thread(r);
        Thread thdB=new Thread(r);
        thdA.start();
        thdB.start();
    }
}

기본 메인 스레드가 실행되는 main()에서는 우선 Runnable을 구현한 익명 클래스를 인스턴스화한다. 다음에 객체를 runnable로 초기화되는 두 개의 Thread객체를 생성한 후 스레드를 생성하고 시작하기 위해 Thread클래스의 start() 메소드를 호출한다. 이 작업들을 완료한 후 main() 메소드의 메인 스레드는 종료한다.

메인 스레드에서 시작된 두 스레드는 각각 runnable의 run() 메소드를 실행하는데 run()메소드에서는 Thread인스턴스를 획득하기 위해 Thread의 currentThread() 메소드를 호출한 후 getName()메소드를 호출하여 이름을 반환 받는다. 다음에 count를 0으로 초기화 시키고 name과 count의 값을 출력한 후 count 의 값을 증가기키면서 무한 반복한다.

java.lang.System 클래스는 표준 입력, 표준 출력, 그리고 표준 에러를 포함한 시스템 지향적인 리소스에 접근할 수 있는 방법을 제공한다.

System 클래스에는 표준 입력, 표준 출력 그리고 표준 에러를 지원하는 각각의 in, out, 그리고 err클래스 필드가 선언되어 있다. in 클래스 필드는 java.io.InputStream 타입이며, out과 err클래스 필드는 java.io.PrintStream 타입으로 선언되어 있다. 이 클래스 필드들 이외에도 System 클래스에는 아래에서 소개하는 메소드를 포함하는 여러가지 static 메소드가 선언되어 있다.

void arraycopy (Object src, int srcPos, Object dest, int destPos, int length)

인자 src배열의 srcPos위치를 시작으로 인자 length에 지정한 개수의 요소를 인자 dest 배열의 destPos의 위치에 복사한다. 이 메소드는 인자 src 또는 dest가 null일 경우 NullPointerException을, 복사중에 배열의 범위를 벗어나게 되면 ArrayIndexOutBoundException을, 인자 src 배여로가 인자 dest배열의 타입이 일치하지 않아 저장을 못할 경우에는 java.lang.ArrayStoreException을 던진다.

long currentTimeMills()

January 1, 1970 00:00:00 UTC(universal time coordinated)에서부터 현재 시스템 시간까지의 시간을 밀리 초 단위로 반환한다.(UTC- 협정 세계시 :)

void gc()

JVM에게 가비지 콜렉터를 실행할 것을 통보한다. 하지만 통보를 했다고 해서 반드시 가비지 콜렉터가 실행되지는 않는다.

String getProperty(String prop)

인자 prop에 의해 지정된 시스템 프로퍼티(system property - 버전 번호 같은 플랫폼의 속성)의 값을 반환한다. 만일 지정한 프로퍼티가 존재하지 않으면 null을 반환한다.

void runFinalization()

JVM에 모든 불완전한 객체에 대해 파이널라이즈를 실행할 것을 통보한다. 단 이 메소드를 호출한다고 해도 반드시 객체들의 파이널라이즈가 수행되지는 않는다.

void setErr(PrintStream err)

표준 에러 스트림을 인자 err로 설정한다. 이 메소드 호출은 윈도우 xp에서 java Application2 > errlog로 지정하는 것과 같은 작업을 한다.

void setIn (InputStream in)

표준 입력 스트림을 인자 in으로 설정한다. 이 메소드 호출은 윈도우 xp에서 java Application < input 과 같이 지정하는 것과 같은 작업을 한다.

void setOut (PrintStream out)

표준 출력 스트림을 인자 out 으로 설정한다. 이 메소드 호출은 윈도우XP에서 java Application > output과 같이 지정하는 것과 같은 작업을 한다.

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

package System;

public class system {
    public static void main(String[] args){
        int[] grades={86,92,78,65,52,43,72,98,81};
        int[] gradesBackup=new int[grades.length];
        System.arraycopy(grades, 0, gradesBackup, 0, grades.length);
       
        for(int i=0; i<gradesBackup.length;i++)
            System.out.println(gradesBackup[i]);
       
            System.out.println("Current time : "+System.currentTimeMillis());
            String[] propNames={
                    "java.vender.url",
                    "java.class.path",
                    "user.home",
                    "java.class.version",
                    "os.version",
                    "java.vender",
                    "user.dir",
                    "user.timezone",
                    "path.separator",
                    "os.name",
                    "os.arch",
                    "line.separator",
                    "file.separator",
                    "user.name",
                    "java.version",
                    "java.home"
            };

            for (int i=0; i<propNames.length; i++){
                System.out.println(propNames[i]+": "+ System.getProperty(propNames[i]));
            }           
        }
    }

arraycopy(), currentTimeMills()그리고 getProperty()메소드를 사용하는 방법을 보여준다.

main() 메소드에서는 arraycopy()의 사용 방법을 제일 먼저 보여주는데 이 메소드는 grades 배열의 내용을 gradesBackup 배열에 복사를 한다.

arraycopy() 메소드는 배열을 다른 배열로 복사하는 가장 빠른 방법이다. 또한 참조를 내부 배열에 반환하는 메소드의 클래스를 작성할 때 배열의 복사본을 생성하고 복사본의 참조를 반환하기 위해 arraycopy() 메소드를 사용해야 한다. 이런 방법을 사용하면 고객이 직접 내부 배열을 조작하는 것을 방지 할 수 있다.

복사를 한 다음 밀리 초 값으로 표현되는 현재 시간을 반환하기 위해 currentTimeMills()메소드를 호출한다. currentTimeMills() 메소드에서 반환된 값이 밀리 초 형식으로써 일반적인 날짜는 아니기 때문에 날짜를 읽기 쉽게 하기 위새서는 일반적인 날짜 형식을 제공하는 java.util.Date클래스를 사용하는 것이 좋다. java.util.Date클래스의 Date()생성자는 내부적으로 currentTimeMills()를 호출한 후 toString()메소드에서 밀리 초의 값을 일반 형식의 날짜와 시간으로 변환한 후 반환한다.

마지막으로 main()메소드에서는 for 반복문 안에서 getProperty() 메소드를 사용하는데 반복을 하면서 프로퍼티의 이름과 값을 출력한다.

line.separator 프로퍼티에는 \r\n과 같은 줄바꿈을 표현하는 문자가 아닌 실제 줄 바꿈 문자 또는 문자들이 저장되어 있기 때문에 위의 출력 결과를 보면 line.separator 다음에 실제 빈 줄이 생긴다.

package IO;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Scanner;

public class copyFile {
    public static void main(String[] args){
        try {
            Scanner s=new Scanner(System.in);
            //System.out.println(s.nextLine());
            //int i=s.nextInt()*100;
            //System.out.println(i);
            System.out.println("원본파일");
            String sourceFile= s.nextLine();
            System.out.println();
            System.out.println("복사파일");
            String copyFile=s.nextLine();
            System.out.println(sourceFile+":"+copyFile);
                   
            File sFile=new File(sourceFile);
            File cFile=new File(copyFile);
           
            FileReader fr=new FileReader(sFile);
            FileWriter fw=new FileWriter(cFile);
           
            int c;
            while ((c=fr.read())!=-1) {
                fw.write(c);
            }
            fw.close();
            fr.close();
            System.out.println("Copy End !!");
        } catch (Exception e) {
                e.printStackTrace();
        }
    }
}

package IO;

import java.io.File;

public class fileIO {
    public static void main(String[] args){
        File f=new File("/org.txt");
        if(f.exists()){
            System.out.println("파일이름 : "+ f.getName());
            System.out.println("상대경로 : "+ f.getPath());
            System.out.println("절대경로 : "+ f.getAbsolutePath());
            System.out.println("쓰기가능 :"+ f.canWrite());
            System.out.println("읽기가능 : "+ f.canRead());
            System.out.println("파일길이 : "+f.length());
        }
    }
}

실제 String 객체는 불변으로 String 객체의 문자열은 변경되지 않는다. String 객체의 경우 객체의 문자열이 변경되는 것처럼 보이지만 실제로는 변경된 문자열을 가진 새로운 String 객체가 반환되는 것이다. 그러므로 String 객체의 문자열을 자주 변경하게 되면 지속적으로 새로운 String 객체를 생성하기 때문에 리소스를 생각보다 많이 낭비하게 된다. 그래서 자바에서는 비효율적인 String 객체를 대신 할 수 있는 java.lang.StringBuffer와 java.lang.StringBuilder를 제공한다. StringBuilder클래스는 속도가 StringBuffer 보다는 빠르지만 명시적인 동기화(explicit syncronization)없이는 다중 스레드 컨택스트에서는 사용할 수 없다.

StringBuffer 객체를 초기화하고 문자열 버퍼를 다루는 StringBuffer에 포함되어 있는 자주 사용되는 생성자와 메소드를 소개한다.StringBuilder의 생성자와 메소드는 StringBuffer와 동일하다.

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

StringBuffer()   

기본적으로 16개의 문자를 저장할 수 있는 빈 배열로 StringBuffer 객체를 초기화 한다.

StringBuffer( int capacity)

인자 capacity에 지정한 크기의 문자를 저장할 수 있는 빈 배열로 StringBuffer객체를 초기화 한다. capacity의 값이 음수이면 java.lang.NegativeArraySizeException이 던져진다

StringBuffer( String s ) 

인자 s의 문자들을 갖는 배열로 StringBuffer 객체를 초기화한다. 객체의 기본 저장 크기인 16에 s의 길이가 더해진 배열이 만들어지는데 s가 null 이면 생성자에서 NullPointException을 던진다.

StringBuffer append( boolean b )

인자 b가 true이면 StringBuffer 객체의 배열에 문자열 "true"가 추가되고, 인자 b가 false이면 문자열 "false"를 추가한 후 추가된 StringBuffer객체를 반환한다.

StringBuffer append( char ch )

StringBuffer 객체의 배열에 인자 ch의 문자를 추가하고 추가된 StringBuffer 객체를 반환한다.

StringBuffer append( char[] chars )

StringBuffer 객체의 배열에 인자 chars 배열에 있는 문자들을 추가하고 추가된 StringBuffer 객체를 반환한다. 인자 char이 null이면 NullPointerException을 던진다.

StringBuffer append( double d )

StringBuffer 객체에 d의 배정밀도 부동 소수점 값을 문자열로 변경한 후 추가된 StringBuffer객체를 반환한다.

StringBuffer append( float f )

StringBuffer 객체의 배열에 인자 f의 부동 소수점 값을 문자열로 변경하여 추가한 후 추가된 StringBuffer객체를 반환한다.

StringBuffer append( int i )

StringBuffer 객체의 배열에 인자 i의 정수값을 문자열로 변경하여 추가한 후 추가된 StringBuffer 객체를 반환한다.

StringBuffer append( long l )

StringBuffer 객체의 배열에 인자 l의 배정수 값을 문자열로 변경하여 추가한 후 추가된 StringBuffer 객체를 반환한다.

StringBuffer append( Object obj )

StringBuffer 객체의 배열에 인자 obj의 toString() 메소드를 호출하여 반환된 문자열의 문자들을 추가한다. 만약 obj에서 null이 반환되면 "null" 이 StringBuffer 객체의 배열에 추가가 된다. 추가된 StringBuffer 객체를 반환한다.

StringBuffer append( String s )

StringBuffer 객체의 배열에 인자 s의 문자열을 추가한다. 만일 인자 s의 값이 null이면 "null"이 배열에 추가되고 추가된 StringBuffer 객체가 반환된다.

int capacity()

StringBuffer 객체의 배열에 저장 할 수 있는 문자의 수를 반환한다.

char charAt( int index )

StringBuffer 객체의 배열에서 인자 index가 가리키는 위치에 있는 문자를 반환한다. 만일 index의 값이 음수이거나 또는 StringBuffer 객체의 length 보다 크거나 같으면 StringIndexOutofBoundsException이 던져진다.

void ensureCapacity( int min )

StringBuffer 객체의 저장 용량을 인자 min에 의해 지정된 값보다 반드시 크게 설정한다. 만일 현재 저장 용량이 min보다 작으면 저장 용량을 크게 하기 위해 새로운 내부 배열이 생성되는데 새로운 저장 용량은 min보다 크게 설정된다. 추가되는 크기는 보통 현재 저장 용량에 2를 곱한 후 2를 더한 크기가 되며 만일 인자min값이 0 또는 음수일 때는 아무런 일도 일어나지 않는다.

int length()

StringBuffer 객체의 배열에 저장되어 있는 문자들의 수를 반환한다.

StringBuffer reverse()

StringBuffer 객체의 배열에 있는 내용의 순서를 반대로 바꾼 후 바뀐 StringBuffer 객체를 반환한다.

void setCharAt( int index, char ch )

인자 index로 지정한 위치에 있는 문자를 인자 ch의 값으로 변경한다. index의 값이 음수 또는 StringBuffer 객체의 length 길이보다 크거나 같으면 StringIndexOutofException이 던져진다.

void setLength( int length )

StringBuffer 객체의 배열 length를 지정한 length로 설정한다. 만일 인자로 지정된 length가 현재 length보다 작으면 배열의 내용이 짤리게 되며 인자로 지정된 length가 현재 length보다 크거나 같으면 배열이 추가되고 추가된 배열에는 null문자('\u0000')가 채워진다. length가 음수로 지정되면 StringIndexOutOfBoundsException을 던진다.

String substring( int start )

StringBuffer 객체의 배열에서 인자 start에 지정한 위치부터 배열의 마지막까지 있는 모든 문자를 포함하는 새로운 String 객체를 반환한다. 인자start가 0보다 적거나 StringBuffer 객체의 배열 length보다 크거나 같으면 StringIndexOutOfBoundsException이 던져진다.

String toString()

StringBuffer 객체의 배열에 있는 내용을 문자열로 갖는 새로운 String 객체를 반환한다.

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

StringBuffer 와 StringBuilder 객체의 내부 배열의 크기는 저장 용량과 길이로 구별된다. 저장 용량은 배열에 저장될 수 있는 문자의 최대 개수를 의미하며 길이는 배열에 현재 저장된 문자의 개수를 의미한다.

toAlignBinaryString() 메소드는 다음 드에서 볼 수 있듯 비효율적인 반복문으로 구현되어 있다

int numLeadingZeros=numBits-result.length();

String zeroPrefix="";

for (int j=0; j<numLeadingZeros; j++)

zerosPrefix+="0";

위의 코드에 있는 반복문은 반복될 때마다 StringBuilder 객체와 String 객체를 생성하기 떄문에 비효율적이다. 실제 컴파일러에서는 위의 코드를 다음과 같이 해석한다.

int numLeadingZeros=3;

String zerosPrefix="";

for(int j=0; j<numLeadingZeros; j++)

zerosPrefix = new Stringbuilder().append(zerosPrefix).append("0").toString();

반복문이 반복될 때마다 객체를 생성하는 위의 예를 좀더 효율적인 코드로 만들기 위해서는 StringBuffer/StringBuilder 객체를 반복문 전에 생성한 후 반복될 때마다 append() 메소드를 호출하고 반복이 끝난 후 toString() 메소드를 호출해야 한다. 다음 코드는 좀 더 효율적으로 작성한 것이다.

int numLeadingZeros=3;

StringBuilder sb=new StringBuilder();

for(int j=0; j<numLeadingZeros; j++)

sb.append("0");

String zerosPrefix= sb.toString();

**문자열 결함 연산자는 반복이 많이 되는 반복문에서 불필요하게 많은 StringBuilder와 String 객체를 생성하기 때문에 가급적 사용하지 않는 것이 좋다. **

package IO;

import java.io.File;

public class getDirectory{
    public static void main(String[] args){
        String dir="/";
        File fdir=new File(dir);
        if(fdir.isDirectory()){
            System.out.printf("검색 디렉토리 %s\n",dir);
            System.out.println("=======================");
            String list[]=fdir.list();
           
            for (int i = 0; i < list.length; i++) {
                File f=new File(dir+File.separator+list[i]);
                if (f.isDirectory()) {
                    System.out.println("["+list[i]+"]");
                }else
                    System.out.println(list[i]);
            }
        }else
            System.out.printf("지정한 %s는 디렉토리가 아닙니다",dir);  
    }
}

package IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class byteCopy {
    public static void main(String[] args)throws IOException{
       
        InputStream in =new FileInputStream("/org.txt");
        OutputStream out =new FileOutputStream("/cpy.txt");
       
        int copyByte=0;
        int bData;
       
        while (true) {
            bData=in.read();
            if(bData==-1)break;
           
            out.write(bData);
            copyByte++;
        }
       
        in.close();
        out.close();
        System.out.println("복사된 바이트 크기 : "+copyByte);
       
    }
   
   
}

package MultiThread;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;

public class ChatServer {
   
    Vector<ClientThread> vc;
   
   
    public ChatServer(){
        vc=new Vector<ClientThread>();
        ServerSocket server=null;
        try {
            server=new ServerSocket(8008);
        } catch (Exception e) {
                System.err.println("Error in ChatServer");
                e.printStackTrace();
                System.exit(1);    // 1은 비정상적인 종료
        }
        System.out.println("++++++++++++++++++++++");
        System.out.println("클라이언트의 접속을 기다리고 있습니다");
        System.out.println("++++++++++++++++++++++");
        try {
            while (true) {
                Socket sock=server.accept();
                ClientThread ct =new ClientThread(sock);
                ct.start();
                vc.add(ct);
            }
        } catch (Exception e) {
                System.err.println("Error in Socket");
                e.printStackTrace();
                System.exit(1);
        }
    }
   

//접속된 모든 Client에게 메세지 전송
public void sendAllClients(String msg){
    for(int i=0;i<vc.size();i++){
        ClientThread ct=vc.get(i);
        ct.sendMessage(msg);
    }
}


//Vector에서 ClientThread를 제거
public void removeClient(ClientThread ct){
    vc.remove(ct);
}




class ClientThread extends Thread{
    Socket sock;
    String user;
    BufferedReader in; //Client가 보내는 메세지를 읽는다
    PrintWriter out; //Client로 메세지를 보낸다.
   
    public ClientThread(Socket sock){
        this.sock=sock;
        try {
            in=new BufferedReader(new InputStreamReader(sock.getInputStream()));
            out=new PrintWriter(sock.getOutputStream(),true); //auto flush
            System.out.println(sock+"접속됨 ...");
        } catch (Exception e) {
                e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            //Client가 제일 처음 받는 메세지
            out.println("사용하실 아이디를 입력하세요");
            user=in.readLine();
            sendAllClients("["+user+"] 님께서 입장 하셨습니다");
            String data=null;
            while ((data=in.readLine())!=null) {
                sendAllClients("["+user+"]"+data);
            }
            in.close();
            out.close();
        } catch (Exception e) {
                removeClient(this);
                e.printStackTrace();
                System.err.println(sock+"끊어짐....");
        }
    }
   
    public void sendMessage(String msg){
        out.println(msg);
    }
}


    public static void main(String[] args){
        new ChatServer();
    }
}


===================

package MultiThread;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class ChatClient extends JFrame implements ActionListener, Runnable {

    JButton connect, send;
    JTextField hostTxt, chatTxt;
    JTextArea ta;
    JScrollPane scroll;
    JScrollBar sb;
    BufferedReader in;
    PrintWriter out;
    int port = 8008;
    String user;

    public ChatClient() {
        setSize(350, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("MyChat1.0");
        JPanel p1 = new JPanel();
        p1.add(hostTxt = new JTextField("127.0.0.1", 20));
        p1.add(connect = new JButton("Connect"));
        add(p1, BorderLayout.NORTH);
        ta = new JTextArea(10, 30);
        ta.setBackground(Color.ORANGE);
        ta.setForeground(Color.BLUE);
        scroll = new JScrollPane(ta, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
                JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
        sb = scroll.getVerticalScrollBar();
        add(scroll);
        JPanel p2 = new JPanel();
        p2.add(chatTxt = new JTextField(20));
        p2.add(send = new JButton("보내기"));
        add(p2, BorderLayout.SOUTH);
        connect.addActionListener(this);
        chatTxt.addActionListener(this);
        send.addActionListener(this);
        setResizable(false);
        setVisible(true);
    }

    // 서버로 부터 들어오는 메시지를 TextArea로 append한다.
    @Override
    public void run() {
        try {
            while (true) {
                ta.append(in.readLine() + "\n");
                ta.transferFocus();
                // 화면에 보여진후 실행
                sb.setValue(sb.getMaximum());
            }
        } catch (Exception e) {
            System.err.println("Error in run");
            e.printStackTrace();
            System.exit(1);
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == connect) {
            connect(hostTxt.getText(), port);
            connect.setEnabled(false);
            hostTxt.setEditable(false);
        } else if (e.getSource() == chatTxt || e.getSource() == send) {
            if (user == null) {
                // 최초 아이디 입력할때
                user = chatTxt.getText();
                setTitle(getTitle() + " [" + user + "]");
                ta.setText("");
            }
            // chatTxt 입력된 값을 서버로 보낸다.
            out.println(chatTxt.getText());
            chatTxt.setText("");
            chatTxt.requestFocus();
        }
    }

    public void connect(String host, int port) {
        try {
            Socket sock = new Socket(host, port);
            in = new BufferedReader(
                    new InputStreamReader(sock.getInputStream()));
            out = new PrintWriter(sock.getOutputStream(), true/* auto flush */);
        } catch (Exception e) {
            System.err.println("Error in connect");
            e.printStackTrace();
            System.exit(1);
        }
        new Thread(this).start();
    }

    public static void main(String[] args) {
        new ChatClient();
    }
}