lonelycat's cellar

★ BufferedOutputStream / BufferedInputStream 클래스

이 두개의 클래스는 FilterOutputStream, FilterInputStream 클래스로부터 상속된 클래스이다

① BufferedOutputStream 클래스
버퍼를 사용하여 스트림을 출력
생성자
  BufferedOutputStream(OutputStream outputStream)
  BufferedOutputStream(OutputStream outputStream, int bufSize)

② BufferedInputStream 클래스
버퍼를 사용하여 스트림을 입력
생성자
  BufferedInputStream(InputStream inputStream)
  BufferedInputStream(InputStream inputStream, int bufSize)

통신의 효율을 높이기 위해 버퍼링(Buffering)을 사용

/******************************************************************************
*   파일      : BufferedStreamTest.java
*   용도      : BufferedStreamTest
*   작성자   : 성홍제
*   작성일   : 2006. 08. 02
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class  BufferedStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String [] args) throws Exception
    {
        if(args.length < 2)
        {
            System.out.println("원본 파일과 복사될 파일의 이름을 입력하십시요!");
            System.exit(-1);
        }
       
        // 화면 버퍼 테스트
        System.out.write(55);   // 화면에 바로 출력하는 게 아니라 화면 출력용 버퍼에 55,

                                        // 즉 "7"을 출력한다.
                                        // 근데 이것만으로는 화면 출력용 버퍼가 충분이 차지 않으므로

                                        // 화면에 내용이 출력되지 않는다.
        System.out.flush();      // 그래서 flush()를 이용해서 버퍼의 내용을 강제적으로 출력한다.
                                        // close()를 할 때로 출력하지만, 여기서는 아직 화면 출력을

                                        // 다 끝낸 것이 아니므로 flush()를 사용.
       
        FileInputStream fin = new FileInputStream(args[0]);
        FileOutputStream fout = new FileOutputStream(args[1]);
       
        BufferedInputStream in = new BufferedInputStream(fin);
        BufferedOutputStream out = new BufferedOutputStream(fout);
       
        //BufferedInputStream in = new BufferedInputStream(new FileInputStream(args[0]));
        //BufferedOutputStream out

        //      = new BufferedOutputStream(new FileOutputStream(args[1]));
       
        int s1=0;
        byte[] buf = new byte[1024];
       
        //while((s1 = in.read()) != -1)
        while((s1 = in.read(buf)) != -1)
        {
            //out.write(buf, 0, s1);    // 파일출력
            System.out.write(buf, 0, s1);   // 화면출력           
            //System.out.write(s1);   // 화면출력 - 하나씩 할 때
        }
       
        fin.close();
        fout.close();
       
        in.close();
        out.close();
       
        System.out.println("");
        System.out.println("Copied...Successfully!");
    }
}

★ DataOutputStream / DataInputStream 클래스

이 클래스들은 자바의 기본 자료형 데이터(Primitive Type)를 바이트 스트림으로 입출력하는 기능을 제공
① DataOutputStream
FilterOutputStream 클래스로부터 상속되었고, DataOutput 인터페이스를 사용한 클래스
기본 자료형 데이터를 바이트 스트림으로 출력
생성자
  DataOutputStream(OutputStream outputStream)
② DataInputStream
FilterInputStream 클래스로부터 상속되었고, DataInput 인터페이스를 사용한 클래스
바이트 스트림으로부터 자바의 기본 자료형 데이터를 입력
생성자
  DataInputStream(InputStream inputStream)

★ DataOutput 인터페이스에 선언된 메소드
void write(int i) throws IOException   i를 스트림으로 출력
void write(byte buffer[]) throws IOException     buffer를 스트림으로 출력
void write(byte buffer[], int index, int size)  buffer의 index위치부터 size 만큼의
          throws IOException                        바이트를 스트림으로 출력
void writeBoolean(boolean b)    b를 스트림으로 출력
          throws IOException
void writeByte(int i) throws IOException       i의 하위 8비트를 스트림으로 출력
void writeBytes(String s) throws IOException     문자열 s를 스트림으로 출력
void writeChar(int i) throws IOException        i의 하위 16비트를 스트림으로 출력
void writeChars(String s) throws IOException     문자열 s를 스트림으로 출력
void writeDouble(double d) throws IOException   d를 스트림으로 출력
void writeFloat(float f) throws IOException        f를 스트림으로 출력
void writeInt(int i) throws IOException           i를 스트림으로 출력
void writeLong(long l) throws IOException    l을 스트림으로 출력
void writeShort(short s) throws IOException  s를 스트림으로 출력
void writeUTF(String s) throws IOException    s를 스트림으로 출력. 유니코드를
                                                               UTF-8 엔코딩을 이용하여 변환
★ DataInput 인터페이스에 선언된 메소드
boolean readBoolean(boolean b)   스트림으로부터 읽은 boolean을 반환
         throws IOException 
byte readByte() throws IOException     스트림으로부터 읽은 byte를 반환
char readChar() throws IOException     스트림으로부터 읽은 char를 반환
double readDouble() throws IOExceptio   스트림으로부터 읽은 double을 반환
float readFloat() throws IOException     스트림으로부터 읽은 float를 반환
long readLong() throws IOException     스트림으로부터 읽은 long을 반환
short readShort() throws IOException    스트림으로부터 읽은 short를 반환
int readInt() throws IOException        스트림으로부터 읽은 int를 반환
void readFully(byte buffer[])    스트림으로부터 buffer 크기 만큼의 바이트를

      throws IOException                읽어 buffer 배열에 저장
void readfully(byte buffer[],int index, int size) 스트림으로부터 size 만큼의 바이트를 읽어

         throws IOException                             buffer의 index 위치에 저장
int readUnsignedByte() throws IOException  스트림으로부터 읽은unsigned byte를 반환
int readUnsignedShort() throws IOException 스트림으로부터 읽은unsigned short를 반환
int skipBytes(int n)    입력 스트림으로부터 n 바이트를 스킵

/******************************************************************************
*   파일      : DataIOApp.java
*   용도      : DataIOApp
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class DataIOApp
{
    public static void main(String args[]) throws IOException
    {
        File file = new File("d:\\test.txt");
        FileOutputStream outFile = new FileOutputStream(file);
        DataOutputStream outStream = new DataOutputStream(outFile);
       
        outStream.writeBoolean(true);   // 파일에 기본형을 출력
        outStream.writeInt(12345);
        outStream.writeChar('K');
        outStream.writeDouble(3.14);
       
        System.out.println(outStream.size()+" bytes were written");
           
        outStream.close();
        outFile.close();
       
        FileInputStream inFile = new FileInputStream(file);
        DataInputStream inStream = new DataInputStream(inFile);
       
        System.out.println(inStream.readBoolean()); // 위에서 만든 파일로부터 입력 받음
        System.out.println(inStream.readInt());
        System.out.println(inStream.readChar());
        System.out.println(inStream.readDouble());
       
        inStream.close();
        inFile.close();
       
        try
        {
            Thread.sleep(6000);
        }
        catch(Exception e)
        {}
       
        file.delete();
    }
}

★ OutputStream 클래스와 InputStream 클래스
① 바이트 스트림의 입출력에 필요로 되는 다양한 메소드를 제공하는 추상 클래스(개체생성못함)
② OutputStream 클래스 : 바이트 스트림을 출력하는 기능
③ OutputStream 클래스의 주요 메소드

   void close() throws IOException      출력 스트림을 닫는다
   void flush() throws IOException      버퍼에 남아 있는 출력 스트림을      모두 출력
   void write(int i) throws IOException  정수 i의 하위 8비트를 출력
   void write(byte buffer[]) throws IOException    buffer의 내용을 출력

★ InputStream 클래스 : 바이트 스트림으로부터 데이터를 읽어 들인다
InputStream 클래스의 주요 메소드

int available()      현재 읽기 가능한 바이트의 수를 반환
void close()        입력 스트림을 닫는다
int read()            입력 스트림으로부터 한 바이트를 읽어 int
                         값으로 반환한다. 더 이상 읽을 값이 없을 경우 –1을 반환
int read(byte buffer[])     입력 스트림으로부터 buffer[] 크기만큼을 읽어 buffer 배열에

                                    저장하고 읽은 바이트 수를 반환
int read(byte buffer[], int offset, int numBytes)     입력 스트림으로부터 numBytes 만큼을

                                                                     읽어buffer[]의  offset 위치에 저장하고

                                                                      읽은 바이트 수를 반환
int skip(long numBytes)       numBytes로 지정된 바이트를 스킵(skip)하고

                                        스킵된 바이트 수를 반환

/******************************************************************************
*   파일      : InputOutputStreamTest.java
*   용도      : InputOutputStreamTest를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class InputOutputStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String args[]) throws IOException
    {
        System.out.println("아무 글이나 입력하시고 Enter를 쳐주세요");
        System.out.println(" 's'를 입력하면 프로그램이 종료됩니다.");
       
        int ch;
       
        // InputStream은 추상 클래스여서 new로 instance 생성 불가
        InputStream in = System.in;          // 표준 입력 - 키보드
        OutputStream out = System.out;   // 표준 출력 - 모니터
       
        // read()는 '한 문자씩' 입력 받으나, 키보드 버퍼에 저장되어있는 것을

        // while문을 돌면서 차례로 입력받는다.
        while((ch = in.read()) != -1)
        {
            if(ch == 's' || ch == 'S')
                break;
           
            // write()는 일단 화면 버퍼에 출력하고, 화면 버퍼가 어느 정도 차거나

            // 화면에 출력해도 괜찮을 때 출력한다.
            // 따라서 'aaaaas'와 같이 입력해도 'aaaaa'는 화면 버퍼에 있는 상태에서

            // 's'를 만나서 프로그램이 종료되므로
            // 화면에는 아무것도 나오지 않는다.
            out.write(ch);
           
            // 한글은 깨진다. print() 메소드 자체가 한글을 처리하기 위해 가공하므로,
            // 한글 문자 정보의 일부분인 ch가 가공되어 제대로 출력되지 않는다.
            //System.out.print((char)ch);
           
            //System.out.println("Char: "+(char)ch+", Available: "+in.available());
        }
    }
}

/******************************************************************************
*   파일      : FileInputOutputStreamTest.java
*   용도      : FileInputOutputStream을 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileInputOutputStreamTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
        /*if(args.length < 2)
        {
            System.out.println("원본 파일과 복사될 파일의 이름을 입력하십시요!");
            System.exit(-1);
        }*/
       
        BufferedReader brIn = new BufferedReader(new InputStreamReader(System.in));
        String ori = null;
        String copy = null;
       
        System.out.print("원본 파일의 이름을 입력하세요 >> ");
       
        try
        {
            ori = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        System.out.print("복사될 파일의 이름을 입력하세요 >> ");
       
        try
        {
            copy = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        int i, len=0;
       
        InputStream in=null;
        OutputStream out=null;
       
        //System.out.println("원본파일 : "+args[0]);
        //System.out.println("목표파일 : "+args[1]);
        System.out.println("원본파일 : " + ori);
        System.out.println("목표파일 : " + copy);       
       
        try
        {
            //in = new FileInputStream(new File(args[0]));
            //out = new FileOutputStream(args[1], true);
            in = new FileInputStream(new File(ori));
           
            // 두번째 true 옵션은 같은 이름의 파일이 있으면 그 파일의 끝에 붙여넣는다.
            out = new FileOutputStream(copy, true);
        }
        catch(FileNotFoundException e)
        {
            System.out.println(e);
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
       
        byte buffer[] = new byte[256];
       
        try
        {
            //while((i=in.read()) != -1)    // 이건 1바이트씩 읽어들이는 것
            while((i=in.read(buffer)) != -1)    // 이건 256 바이트씩?
            {
                out.write(buffer,0,i);
                //System.out.write(buffer,0,i); // 화면에 출력한다.
                len += i;
            }
           
            in.close();
            out.close();
           
            System.out.println(len + " bytes are copied...Successfully!");
        }
        catch(IOException e1)
        {
            System.out.println(e1);
        }
    }
}

/******************************************************************************
*   파일      : FakeXCopy.java
*   용도      : FakeXCopy
*   작성자   : 성홍제
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FakeXCopy
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
//        BufferedReader brIn = new BufferedReader(new InputStreamReader(System.in));
        File f = null;
        String ori = null;
        String dest = null;
/*       
        System.out.print("원본 파일의 이름을 입력하세요 >> ");
       
        try
        {
            ori = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
       
        System.out.print("복사될 파일의 이름을 입력하세요 >> ");
       
        try
        {
            dest = brIn.readLine();
        }
        catch (IOException e2)
        {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }
*/       
        ori = "d:\\Test\\";
        dest = "d:\\Test_Test\\";
       
        System.out.println("원본파일 : " + ori);
        System.out.println("목표파일 : " + dest);
       
        f = new File(ori);
       
        if(!f.exists())
        {
            System.out.println("디렉토리가 존재하지 않습니다.");
            System.exit(0);
        }
   
        if(f.isDirectory())
        {
            // 현재 디렉토리의 디렉토리, 파일 리스트
            File[] fileList = f.listFiles();
           
            for(int j = 0; j < fileList.length; j++)
            {
                if(fileList[j].isDirectory())
                {
                    // 디렉토리 체크
                    checkDir(fileList[j], dest);
                }
                else
                {
                    // 파일 복사
                    copyFile(fileList[j], dest);
                }
            }
           
            //checkDir(f, dest);    // 기본 디렉토리까지 복사한다.
        }
    }
   
    public static void copyFile(File file, String str)
    {
        int i, len=0;
        InputStream in=null;
        OutputStream out=null;
       
        // 파일 복사
        try
        { 
            in = new FileInputStream(file);
           
            // 두번째 false 옵션은 같은 이름의 파일이 있으면 덮어쓴다.
            out = new FileOutputStream(str + file.getName(), false);
        }
        catch(FileNotFoundException e)
        {
            System.out.println(e);
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
       
        byte buffer[] = new byte[4096];
       
        try
        {
            //while((i=in.read()) != -1)    // 이건 1바이트씩 읽어들이는 것
            while((i=in.read(buffer)) != -1)    // 이건 4096 바이트씩
            {
                out.write(buffer,0,i);
                //System.out.write(buffer,0,i); // 화면에 출력한다.
                len += i;
            }
           
            System.out.println(len + " bytes are copied...Successfully!");
        }
        catch(IOException e1)
        {
            System.out.println(e1);
        }
        finally
        {
            try
            {
                in.close();
                out.close();
            }
            catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }           
        }
    }
   
    /*************************************************
    * Purpose       : 재귀호출로 디렉토리를 체크한다.
    * Return         : void
    * Parameter    : File file - 체크할 디렉토리, String str - 현재 경로
    *************************************************/
    public static void checkDir(File file, String str)
    {
        // 재귀호출로 현재 디렉토리가 계속 갱신된다. !!!!!
       
        // 목표 디렉토리로 변경
        file.renameTo(new File(str + file.getName() + "\\"));
       
        // 디렉토리 생성
        if(file.mkdirs())
        {
            //System.out.println("디렉토리 생성 성공");
        }
       
        // 디렉토리니까 다시 체크
        File[] fileList = file.listFiles();
       
        for(int j = 0; j < fileList.length; j++)
        {
            if(fileList[j].isDirectory())
            {
                // 디렉토리 체크
                checkDir(fileList[j], str);
            }
            else
            {
                // 파일 복사
                copyFile(fileList[j], str);
            }
        }
    }
}

/******************************************************************************
*   파일      : CopyDir.java
*   용도      : CopyDir - 강사님이 작성한 것
*   작성자   : 김종식
*   작성일   : 2006. 08. 01
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class CopyDir
{
    /// Fields
    /// Constructor
    /// Method
    public static void copyDirectory(File source , File target) throws IOException
    {
        //디렉토리인 경우
        if (source.isDirectory())
        {
            //복사될 Directory가 없으면 만듭니다.
            if (!target.exists())
            {
                target.mkdir();
            }
           
            String[] children = source.list();
           
            for (int i=0; i<children.length; i++)
            {
                copyDirectory(new File(source, children[i]),new File(target, children[i]));
            }
        }
        else
        {
         //파일인 경우
            InputStream in = new FileInputStream(source);
            OutputStream out = new FileOutputStream(target);
           
            // Copy the bits from instream to outstream
            byte[] buf = new byte[1024];
            int len;
           
            while ((len = in.read(buf)) > 0)
            {
                out.write(buf, 0, len);
            }
           
            in.close();
            out.close();
        }
    }
   
    /// Main Method       
    public static void main(String[] args) throws IOException
    {
        if ( args.length < 2)
        {
            System.out.println("복사할 원본과 대상을 지정하세요.");
            System.exit(-1);
        }
       
        File source = new File(args[0]);
        File target = new File(args[1]);
       
        copyDirectory(source , target);
    }   
}

★ 임시파일

임시파일들을 생성하는 기능
임시파일의 사용을 위한 File 클래스의 메소드
   static File createTempFile(String prefix, String suffix)
   static File createTempFile(String prefix, String suffix,File Directory)
   저장할 디렉토리를 지정하지 않으면 시스템의 것사용

사용법
try

{
  File tmp1 = File.createTempFile("~JavaIO",".tmp");
  File tmp2 = File.createTempFile("~javaIO1",".tmp",new File("c:\\tmp"));
  tmp1.deleteOnExit();
  tmp2.deleteOnExit();
}

catch(IOException e)

{}

/******************************************************************************
*   파일      : TempFile.java
*   용도      : TempFile를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class TempFile
{
    public static void main(String[] args)
    {
        try
        {
            // 디렉토리를 설정해주지 않았으므로 기본 디렉토리
            // C:\Documents and Settings\Class4--25(자기계정)\Local Settings\Temp

            // 에 생성된다.
            File f = File.createTempFile("tmp_", ".dat");
            System.out.println("60초 동안 멈춰있습니다.");
           
            f.deleteOnExit(); // JVM이 종료될 때 임시파일을 자동으로 삭제한다.
           
            try {
                Thread.sleep(60000);// 60초 동안 프로그램이 멈춰있는다.
            }
            catch (InterruptedException e1)
            {
                System.out.println(e1);
            }
        }
        catch (IOException e)
        {
            System.out.println(e);
        }
    } // main
}

★ 파일 클래스

   입출력을 위해 필요로 되는 파일과 디렉토리를 다루기 위한 File 클래스 제공

★ Constructor Summary

File (String pathname) - 절대 경로로 생성
File (String parent, String child)  -
File (File parent, String child)  -
File (URI uri)  -

★ File 클래스의 메소드

boolean canRead()   파일이 읽기 가능하면 true, 아니면 false를 반환
boolean canWrite()    파일이 쓰기 가능하면 true, 아니면 false를 반환
boolean delete()       파일을 삭제하고 true를 반환, 파일을 삭제할 수 없으면    false를 반환
boolean equals(Object obj)   현재의 객체와 obj로 지정된 객체가 같은 파일을 가지고
                                          있으면 true, 아니면 false를 반환
boolean exists()     파일이 존재하면 true, 아니면 false를 반환

                            제일 많이 쓰는 메소드 중 하나. 파일이 존재하지 않으면 생성하고 존재하면...
String getAbsolutePath()    파일에 대한 절대 경로를 반환
String getCanonicalPath()  파일에 대한 정규 경로를 반환
String getParent()   부모 디렉토리 이름을 반환
String getName()    파일의 이름을 반환
String getPath()      파일의 경로를 반환
boolean isAbsolute()   경로가 절대 경로이면 true, 아니면 false를 반환
boolean isDirectory()   현재의 객체가 디렉토리이면 true, 아니면 false를 반환

boolean isFile()    현재의 객체가 파일이면 true, 아니면 false를 반환
long lastModified()    1970년 1월 1일(GMT)부터 파일이 마지막으로 수정된
                               날자까지의 시간을 밀리 초로 반환
long length()   파일의 바이트 수를 반환.  자주 사용한다.
String[] list()  현재 디렉토리 내의 디렉토리 및 파일들의 이름을 반환.  자주 사용한다.
boolean mkdir()   디렉토리를 생성. 경로로 지정된 모든 부모 디렉토리가
                         존재하여야 한다. 지정한 디렉토리가 생성되면 true를
                         반환하고, 아니면 false를 반환
boolean mkdirs()  디렉토리를 생성. 경로로 지정된 디렉토리가 존재하지 않으면
                          경로를 생성한 다음 지정한 디렉토리를 생성. 디렉토리가 생성되면
                          true를 아니면 false를 반환
boolean renameTo(File newName) 파일이나 디렉토리의 이름을 newName으로
                                                 변경한 다음 true를 반환.

                                                 이름을 변경하지 못하면 false를 반환

/******************************************************************************
*   파일      : FileTest.java
*   용도      : File Class를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31

*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileTest
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args) throws Exception
    {

        File f1 = new File("./FileTest.java");  // 둘다 상대경로로 생성
        //File f1 = new File("FileTest.java");  // 둘다 상대경로로 생성
       
        System.out.println(" f1.getPath(): "+f1.getPath());
        // 파일의 절대 경로를 표시. 그렇다 하더라도 파일 객체 생성 시 "./FileTest.java"이렇게

        // 한 것은 ./FileTest.java 이런 식으로 나온다.
        System.out.println(" f1.getAbsolutePath(): "+f1.getAbsolutePath());
        // 파일의 경로를 표시. '.' 으로 되어있는 것도 풀어서 실제 위치를 표시한다.
        // 따라서 어떤 파일의 정확한 경로를 알고 싶으면 getCanonicalPath()를 사용하는

        // 편이 좋다.
        System.out.println(" f1.getCanonicalPath(): "+f1.getCanonicalPath());
        System.out.println(" f1.getName(): "+f1.getName());
        System.out.println(" f1.toString(): "+f1.toString());
       
        try
        {
            System.out.println(" f1.toURL(): "+f1.toURL());
        }
        catch(java.net.MalformedURLException e)
        {
            System.out.println(" f1.toURL(): "+e);
        }
       
        System.out.println(" f1.canRead(): "+f1.canRead());
        System.out.println(" f1.canWrite(): "+f1.canWrite());
        System.out.println(" f1.isAbsolute(): "+f1.isAbsolute());
        System.out.println(" f1.isDirectory(): "+f1.isDirectory());
        System.out.println(" f1.isFile(): "+f1.isFile());
        System.out.println(" f1.isHidden(): "+f1.isHidden());
        System.out.println(" f1.lastModified(): "+f1.lastModified());
       
        /*
        Date d = new Date(f1.lastModified());
        System.out.println(" f1.lastModified(): "+d.toString());
        */
       
        System.out.println(" f1.length(): "+f1.length());
        System.out.println(" f1.exists(): "+f1.exists());
    }
}

/******************************************************************************
*   파일      : FileList.java
*   용도      : FileList를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;
import java.text.*;
import java.util.*;

public class FileList
{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args) throws IOException
    {

        // Date 정보를 내가 원하는 방식으로 표현하기 위해 사용하는 클래스
        SimpleDateFormat sdf = null;  
        sdf = new SimpleDateFormat("yyyy-MM-dd  a KK:mm");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
        /*if(args.length != 1)
        {
            System.out.println("사용법 : java FileList 디렉토리이름");
            System.exit(0);
        } // if end*/  
   
        //File f = new File(args[0]);
        System.out.println("디렉토리 path를 입력해주세요");
        File f = new File(br.readLine());
   
        if(!f.exists())
        {
            System.out.println("디렉토리가 존재하지 않습니다.");
            System.exit(0);
        }
   
        if(f.isDirectory())
        {
            // 현재 디렉토리의 디렉토리, 파일 리스트
            File[] fileList = f.listFiles();
           
            for(int i = 0; i < fileList.length; i++)
            {
                System.out.print(sdf.format(new Date(fileList[i].lastModified())));
                System.out.print("\t");
               
                if(fileList[i].isDirectory())
                {
                    System.out.print("<DIR>");
                    System.out.print("\t");
                }
                else
                {
                    //System.out.print("파일");
                    System.out.print("\t");
                    System.out.print(fileList[i].length());
                }
               
                System.out.print("\t");
                System.out.print(fileList[i].getName());
                System.out.println("\t");
            }
        }
        else
        {
            System.out.println("디렉토리가 아닙니다.");
        }
    }
}

/******************************************************************************
*   파일      : FileDelete.java
*   용도      : FileDelete를 테스트하는 예제
*   작성자   : 성홍제
*   작성일   : 2006. 07. 31
*   Version : 1.0
******************************************************************************/

package FileIO;

import java.io.*;

public class FileDelete

{
    // Fields
    // Constructor
    // Method
    // Main Method
    public static void main(String[] args)
    {
        if(args.length != 1)
        {
            System.out.println("사용법 : java FileDelete 파일이름");
            System.exit(0);
        } // if end
   
        File f = new File(args[0]);
   
        if(f.exists())
        {
            boolean deleteflag = f.delete();
           
            if(deleteflag)
                System.out.println("파일 삭제를 성공하였습니다.");
            else
                System.out.println("파일 삭제를 실패하였습니다.");
        }
        else
        {
            System.out.println("파일이 존재하지 않습니다.");
        }

    }//main
}

★ 입출력 개요

① 자바의 입출력은 모든 하드웨어에 독립적으로 설계
② 자바는 입출력을 스트림(stream)으로 처리
   스트림 : 순서가 있고 길이가 정해져 있지 않은 일련의 데이터 흐름을 의미하는 추상적인 개념
③ 사용자는 스트림을 이용하여 입출력 수행
   스트림을 이용하여 실제 다양한 하드웨어와 입출력을 수행하는 일은 JVM에 의해 실행
④ 스트림의 개념을 이용하면 데이터의 근원지나 목적지에 상관없이 항상 일관된 방법으로 프로그램을 작성할 수 있다.
⑤ 자바는 입출력을 위한 클래스들을 java.io 패키지로 제공(API 참조)
⑥ 단방향으로 작동
   입력 스트림 : 데이터를 스트림으로 읽어 들임
   출력 스트림 : 출력 스트림으로 데이터를 보냄

★ 전달 데이터 형에 따른 분류
① 바이트 스트림
   바이트, 바이트 배열, Primitive형 데이터, 개체형 데이터 등의 흐름
   1byte씩 처리

   1byte씩 처리하므로, 영어권이 아닌 2bytes 문자인 한글, 한자, 일본어 등은 깨진다.
    ex) InputStream, OutputStream
② 문자 스트림
   문자, 문자 배열, 문자열의 흐름
   2byte씩 처리
    ex) Reader, Writer

★ 버퍼 - BufferedReader, BufferedWriter 등 Buffered가 붙은 녀석들.

데이터를 하나씩 받아서 하나씩 처리하는게 아니라, 데이터를 계속 받아서 모은 후에 한꺼번에 처리한다.

★ 데이터 처리 여부에 따른 분류
① Sink 스트림
   단순히 데이터를 근원지에서 읽어오거나 목적지에 기록
② Procession 스트림
   다른 입출력 클래스를 통해 얻어진 데이터를 중간에서 조작하거나,처리하는 프로세싱 스트림(필터 스트림)

java.lang.OutOfMemoryError

                     2005-05-31     송학렬    ㈜아이티플러스 기술지원부

이 문서는 기술지원 또는 개발 시 java.lang.OutOfMemoryError 를 만났을 때 원인 파악 및 해결방안 입니다.

java.lang.OutOfMemoryError 에는 크게 2가지 패턴이 있다고 볼 수 있습니다.(전적으로 개인적인 생각이지만..^^)

Java의 heap 메모리가 정말로 Full 되서 나는 종류가 있고 그렇지 않은데도 나는 종류가 있습니다.

그 둘 중에 어는 것 인지부터 가려내는 것이 가장 먼저 선행되어야 합니다.

Java 가상머신에는 메모리 구조가 여러단계로 나뉘어 져 있으므로 어느 영역에 의해 java.lang.OutOfMemoryError 가 나는지 알기 위해 JAVA OPTION으로 싸이트가 안정화 되기 전까진 –verbosegc 또는 -XX:+PrintGCDetails  옵션을 추가해 놓는 것이 java.lang.OutOfMemoryError 났을 때를 대비해 좋은 습관이라 할 수 있습니다.

-verbosegc 또는  -XX:+PrintGCDetails  옵션으로 로그에 남는 heap 메모리 정보를 본 후 java.lang.OutOfMemoryError 가 날 때 heap이 꽉 차서 나는 것인지 아닌지 부터 판단합니다.

1.     Heap Memory가 Full 차지 않았을 때

1)     Perm 영역이 full 되는 경우

Permanent generation is full...

increase MaxPermSize (current capacity is set to: 134217728 bytes)

[Full GC[Unloading class sun.reflect.GeneratedSerializationConstructorAccessor31282]

 810207K->802132K(1013632K), 8.3480617 secs]

<GC: 2 4  2465625.831280 10348 0 31 113802808 105534632 286326784 0 0 35782656 715849728 715848840 715849728 134217720 134023296 134217728 8.348677 8.348677 >

Passwd Check =============

<2005. 5. 19. 오전 9시 32분 23초 KST> <Error> <HTTP> <BEA-101017> <[ServletContext(id=2536415,name=/,context-path=)] Root cause of ServletException.

java.lang.OutOfMemoryError

위와 같은 case 인 경우네는 Java 가상머신중에 Perm 영역이 full 차는 경우 입니다. 

Perm 영역에는 class object 및 관련된 meta data가 로드되는 곳인데 싸이트가 매우 많은 수의 class를 사용하는 경우 늘려줘야 하는 case도 있습니다.

얼마가 적정한 사이즈란 정답이 없는 것 같고 max가 계속 늘어나지 않고 일정한 사이즈를 유지 하면 됩니다.

             위 에러가 났을때는 -XX:MaxPermSize=256m  옵션으로 사이즈를 적당하게 늘려주는게 방

             법이며 늘려주었는데도 불구하고 Full 차는 시간만 늘어날 뿐 계속 사이즈가 늘어난다면 이 영역은 일반 비즈니스 프로그램으로 핸들링 할 수 없는 영역이므로 WAS 제품의 버그 및 jdk 버그로 보는 것이 일반적입니다.

2)     MAXDSIZ 사이즈 관련

  - Exception in thread "CompileThread0" java.lang.OutOfMemoryError: requested 32756 bytes for ChunkPool::allocate

Possible causes:

         - not enough swap space left, or

         - kernel parameter MAXDSIZ is very small.

-          java.lang.OutOfMemoryError: unable to create new native thread

위 두 에러가 나는 이유는 Data 사이즈가 Full 차서 더 이상 메모리 할당을 할 수 없다는 java.lang.OutOfMemoryError 입니다.

Jdk도 내부적으로 c 라이브러리를 쓰고 jni를 통해서 c프로그램을 호출할 수 도 있는 환경에서 Data 영역이상으로 메모리 사용 시 위 에러를 만날 수 있습니다.

Heap 영역에는 java heap과 C heap이 있는데 C heap이 Data 메모리 영역에 영향을 미치는 것으로 보이며 보통 C의 전역 변수들이 잡히는 영역입니다.

위 현상을 만났을 때는 hp os의 MAXDSIZ가 너무 작게 잡혀있지 않은지 확인 후 적당한 크기로 늘려 줘야 합니다.

Glance 에서 shift+m 을 누른 후 jvm pid를 누르면 java가 사용하는 Data 사이즈를 모니터링 할 수 있습니다.

모니터링을 통해 적정한 사이즈로 MAXDSIZ를 늘려주어야 하며 만일 늘려 준게 에러 발생의 시간만 지연 시킬 뿐 계속 사용량이 늘어난다면 이는 사용하는 c라이브러리 쪽에 메모리 릭 버그가 있는 것이므로 c라이브러리를 체크 하셔야 합니다.

java.lang.OutOfMemoryError: unable to create new native thread

이 경우는 프로그램에서 Thread pool 프로그램 실수로 필요이상으로 쓰레드가 생성되는 경우도 과도하게 메모리를 사용할 수 있으므로 jvm 쓰레드 덤프를 통해 과도한 쓰레드가 생성되지 않았는지도 확인해 보셔야 합니다.

2.     Heap이 Full 찾을 때

이 경우는 java가 사용하는 heap 영역이 Full 되서 java.lang.OutOfMemoryError 가 나는 경우 인데 두 가지 패턴이 있습니다.

순간적으로 대량의 데이터를 메모리에 올리는 프로그램이 실행되어 문제를 야기 할수 있으며 다른 한 가지는 조금씩 메모리 릭이 발생하여 점차적으로 메모리가 쌓여 가는 경우 입니다.

두 가지 중에  어느 것인지 구별하는 것이 중요하며 이를 위해서도 마찬가지로 -verbosegc 또는  -XX:+PrintGCDetails  로그를 통해 순간적으로 메모리가 차는 것인지 조금씩 메모리가 차는 것인지를 확인하셔야 합니다.

1) 특정 프로그램의 특정시점의 과도한 메모리 사용에 의한 경우

                특정 프로그램이 과도하게 heap 메모리 이상 메모리를 사용하면서

java.lang.OutOfMemoryError가 발생하는 경우는 이 에러가 발생하는 시점의 쓰레드 덤프를 통해 어느 프로그램인지 쉽게 찾을 수 있습니다.

쓰레드 덤프에 메모리를 쓸만한 프로그램은 어느 정도의 자바프로그램 경험이 있으면 찾을 수 있습니다.

Ex)

"ExecuteThread: '36' for queue: 'default'" daemon prio=10 tid=0x0048e7b0 nid=48 lwp_id=4139729 runnable [0x23f32000..0x23f30500]

          at java.net.SocketInputStream.socketRead(Native Method)

          at java.net.SocketInputStream.read(Unknown Source)

          at oracle.net.ns.Packet.receive(Unknown Source)

          at oracle.net.ns.NetInputStream.getNextPacket(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.net.ns.NetInputStream.read(Unknown Source)

          at oracle.jdbc.ttc7.MAREngine.unmarshalUB1(MAREngine.java:718)

          at oracle.jdbc.ttc7.MAREngine.unmarshalSB1(MAREngine.java:690)

          at oracle.jdbc.ttc7.Oall7.receive(Oall7.java:373)

          at oracle.jdbc.ttc7.TTC7Protocol.doOall7(TTC7Protocol.java:1405)

          at oracle.jdbc.ttc7.TTC7Protocol.fetch(TTC7Protocol.java:889)

          - locked <0x35e8e3b0> (a oracle.jdbc.ttc7.TTC7Protocol)

          at oracle.jdbc.driver.OracleResultSetImpl.next(OracleResultSetImpl.java:242)

          - locked <0x36f66c98> (a oracle.jdbc.driver.OracleResultSetImpl)

          at weblogic.jdbc.pool.ResultSet.next(ResultSet.java:180)

          at Dcard.AAA.ejb.monitor.member.wbbb.WACBean.getInfoList(WACBean.java:5789)

java.lang.OutOfMemoryError 가 날 상황에 쓰레드 덤프를 두 세번 떠서 같은 쓰레드 번호로 위 같은 로직이 오래 결려있다면 이는 프로그램에서 while(rs.next()) 를 오랜 기간 돌면서 메모리에 DB로부터 읽어서 올리고 있다는 것을 의미 합니다… 대량 데이터 조회가 일어나는 경우인 것 입니다.

이런 식으로 특정 프로그램의 특정 시점에 과도한 메모리 사용으로 인한 java.lang.OutOfMemoryError 에러는 쓰레드 덤프를 통해 찾을 수 있습니다.

-- 물론 2번에서 설명 할 heap dump를 통해서도 찾을 수 있습니다.

2) 메모리 릭에 의해 조금씩 메모리가 쌓인 경우

JVM위 에서 실행중인 프로그램중에 어떤 것이 GC 대상에서 제외되는 영역에 data를 조금씩 쌓고 있다는 얘기입니다.

GC 대상에서 제외되는 영역은 다음과 같은 곳이 있습니다.

- Http Session에 넣는 데이터..(세션 타임아웃 또는 invilidate 씨 까지 제외됨)

- Static 변수

- 서블릿 또는 jsp의 멤버변수 ( WAS 기동 후 최초 호출 시 인스턴스 화 되어 WAS가 내려 갈 때 까지 사라지지 않음 )

- EJB의 멤버변수( pool안에서 객체가 존재하는 한 GC대상에서 제외)

          위 같은 영역에 프로그램에서 data를 add 하는 구조를 메모리 릭 이라고 할 수 있습니다.

           IBM 또는 SUN JDK 인 경우에는 heapdump를 통해서 분석하여 어느 데이터가 메모리를 많이 잡고 있는지를 알 수 있습니다.

           Heapdump 사용법 및 분석 법은 다음을 참조 하시면 됩니다.

 http://www.alphaworks.ibm.com/aw.nsf/FAQs/heaproots

http://www-1.ibm.com/support/docview.wss?uid=swg21190476

http://www-1.ibm.com/support/docview.wss?rs=180&context=SSEQTP&q1=heapdump+solaris&uid=swg21190608&loc=en_US&cs=utf-8&lang=en

http://www.skywayradio.com/tech/WAS51/IBMHeapDump/