IO Stream - in put - out put - 18일차

i/0 인풋 아웃풋

인풋은 들어오는것을 처리 아웃풋은 내보는것을 처리(채팅을 생각하면쉽다. 들어오는 것을 읽고 내보내는 것을 처리)

Byte Stream 음악 파일이라던ㅈㅣ. 동영상 파일이라던지 진행하는데 쓰인다. 1바이트

Character Stream 2바트

//둘중에 하나라도 잘쓰면된다.

Object의 직렬화 방법을 배운다.(파일에 있는것을 쓰는것을 객체 직렬화라고한다.)

Stream?(영어사진 의미 틀다. 수돗꼭지 생각하면 바로 의미 파악된다. 틀면나오고 잠그면 안나오고 단반향)
(Stream)Data를 목적지로 Input/Output하기 위한 방법이다.
Stream에 Data를 쓸 수 있고, Stream에서 Data를 읽을 수 있다.
Stream에 Data를 쓸 경우, 이러한 Stream을 output stream이라고 한다.
Stream에서 Data를 읽을 경우, 이러한 Stream을 input stream이라고 한다.

 

Stream의 특징
Stream은 FIFO 구조이다. ? FIFO구조란 먼저 들어간 것이 먼저 나오는 형태로서 Data의 순서가 바뀌지 않는다는 특징이 있다.(실제로 동영상을 다운받을때 이방식. 먼저 다운 받은게 먼저 안나우고 나중에 다운 받은게 먼저 나오면 엉망진창일꺼다.)퍼스트 이프, 퍼스트 아웃
Stream은 단방향이다. ? Java에서 Stream은 읽기, 쓰기가 동시에 되지 않는다. 따라서 읽기, 쓰기가 필요하다면 읽는 Stream과 쓰는 Stream을 하나씩 열어 사용해야 한다.(읽는 스트림 따로 쓰는 스트림을 따로 만들어야한다.)
Stream은 지연될 수 있다.(다운로드 했을때 멈추거나 했을때 다른 다운로드창이 안떠서  진행되지 않음을 뜻함) ? Stream은 넣어진 Data가 처리되기 전까지는 Stream에 사용되는 Thread는 지연상태에 빠진다. 따라서 Network 내에서는 Data가 모두 전송되기 전까지 Network Thread는 지연상태가 된다.

File class
System에 있는 file이나 directory를 추상화한 class이다.
File class를 이용하면 file의 크기, 생성, 삭제, 변경 및 마직막 수정날짜 등 다양한 정보를 알 수 있는 method를 제공하고 있다.
canRead( ) 읽기 가능한지
canWrite( ) 쓰기 가능한지. 요런뜻

-------------------------------------
-------------------------------------
[FileEx.java]
import java.io.*;
public class FileEx{
 public static void main(String[] args)
  throws IOException{ //메인메소드에 IO익셉션을 붙여줬다. 메소드를  API에서 찾아보면서 어떤 예외가 발생할수 있는지도 알아봐라
  String filePath = "c:\\"; //스트링 패스에 파일 패스라는 개체선언 따옴표 안에 들어간건 문자열인데 역슬러쉬 하나는 취급이 안된다. 두개 넣어야된다.
  File f1 = new File(filePath);  //F1에는 현재쓰는 컴퓨터의 c드라이브라는 루트가 전부 담겨있다.
  String list[] = f1.list(); //파일 정보를 배열로 리턴
  for(int i=0;i<list.length;i++){ //배열의 갯수만큼 반복
   File f2 = new File(filePath,list[i]); //파일 패스는 C드라이브 리스트에는 파일명이나 디렉토리가 나옴 여기까지 경로를 잡은 다음에 개체를 생성 f2
   if(f2.isDirectory()){
    System.out.printf("%s : 디렉토리 %n",list[i]);
   }else{
    System.out.printf("%s : 파일(%,dbyte)%n",
      list[i],f2.length());
   }//파일이름과 파일디렉토리를 출력.
  }  
  File f3 = new File("c:\\test.txt"); //파일 개체를 생성한다. c드라비브에 TEST.TXT
  System.out.println(f3.createNewFile()); // 새로운 파일을 만드는 메소드 크레이트 뉴파일 createNewFile()
  System.out.println(f3.getAbsolutePath()); // getAbsolutePath()
  System.out.println(f3.getCanonicalPath()); // getCanonicalPath(
  System.out.println(f3.getPath()); // getPath()
  System.out.println(f3.getName()); //getName())파일의 이름을 뽑아냄
  System.out.println(f3.getParent()); //파일이 퐘되어있는 폴더나 디렉토리를 뽑아냄
  File f4 = new File("c:\\test.txt"); //똑같은 파일을 하나더만듬
  File f5 = new File("c:\\test1.txt"); //TEST1을 더마듬
  System.out.println(f4.renameTo(f5)); //f4에 있는 renameTo()이름을 f5에 이름으로 바꿔치기 하겠다. 들어가면 텍스트 원으로 바뀐것을 확인할수 있다.
 }
} // 들어가서보면 파일이 만들어져 있다.
//미니홈피를 만든다.해서 만들기 하면 만들어지는데 그냥 만들어지는게 아니라 이와 처럼 카피 읽어서 만들수 있게끔 해준다.
-------------------------------------
-------------------------------------
//예제가 워낙 빨리 넘겨서 하다 말았는데 위에것과 이것 그리고 몇개를 더하면 C드라이브를 트리구조로 보여주는것을 만들수 있다. 17일차에 있으니 확인 바란다.
//이번 쉬는동안 분석해보자.

//디렉토리에대한 정보를 다루는
[Directory.java]
public class Directory{
 private String directoryName;
 public Directory(String folderName){
  this.directoryName = folderName;
 }
 public String getDirectoryName() {
  return directoryName;
 }
 public void setDirectoryName(String directoryName) {
  this.directoryName = directoryName;
 }
 public String toString(){
  return directoryName;
 } 
}

//드라이버 정보를 다루는
[Driver.java]
public class Driver{
 private String driverName;
 public Driver(String driverName){
  this.driverName = driverName;
 }
 public void setDriverName(String driverName){
  this.driverName = driverName;
 }
 public String getDriverName(){
  return driverName;
 }
 public String toString(){
  return driverName;
 }
}

// 요예제도 트리 만드는데 포함되는지 모르겠다. 일단 이건거 같아서 집어넣음
[JTreeDelegate.java]
import java.awt.*;
import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
import java.io.*;
import javax.swing.filechooser.*;
public class JTreeDelegate extends JTree{
 private JTreeModel jtm;
 private DefaultTreeModel m_model; 
 private Icon driver_img,folder_img,foleropen_img;
 public JTreeDelegate(){
  super(new JTreeModel());
  File f = new File("c:"+System.getProperty("file.separator"));
  FileSystemView fsv = FileSystemView.getFileSystemView() ;
  driver_img = fsv.getSystemIcon(f);
  folder_img = new ImageIcon("image/folder_close.gif");
  foleropen_img = new ImageIcon("image/folder_open.gif");
  setCellRenderer(new MyRenderer());
  addTreeSelectionListener(new MySelectionListener());
 }
 private class MySelectionListener implements
  TreeSelectionListener{
  public void valueChanged(TreeSelectionEvent e){
   TreePath path = e.getPath();
   Object[] nodes = path.getPath();
   String filepath = "";
   for(int k=0;k<nodes.length;k++){
    DefaultMutableTreeNode node =
     (DefaultMutableTreeNode)nodes[k];
                System.out.println(nodes[k]);
    if(node.getUserObject()instanceof Directory) {
     filepath +=  node.toString()+
                        System.getProperty("file.separator");
    }else if(node.getUserObject()instanceof Driver) {
     filepath +=
      node.toString();
    }
   } 
   DefaultMutableTreeNode node =
    (DefaultMutableTreeNode)nodes[nodes.length-1];
   File f1 = new File(filepath); 
   File f2=null;
   String list[] = f1.list(); 
   if(list != null){
    for(int i=0;i<list.length;i++){    
     f2 = new File(filepath+list[i]); 
     if(f2.isDirectory()){  
      DefaultMutableTreeNode dmt1 =
      new DefaultMutableTreeNode(
      new Directory(list[i]));
      node.add(dmt1);        
     }       
    }      
   }
  }
 }
 private class MyRenderer extends DefaultTreeCellRenderer {
        public Component getTreeCellRendererComponent(JTree tree,
   Object value,boolean sel,boolean expanded,
   boolean leaf, int row, boolean hasFocus) {
            super.getTreeCellRendererComponent(tree, value, sel,
    expanded, leaf, row,hasFocus);
   if (getObejct(value) instanceof Driver) {
    setIcon(driver_img);
            }else if(getObejct(value) instanceof Directory){
    if(expanded)
     setIcon(foleropen_img);
    else
     setIcon(folder_img);
   }
            return this;
        }
  private Object getObejct(Object value) {
            DefaultMutableTreeNode node =
    (DefaultMutableTreeNode)value;
   return   node.getUserObject();
        }
 }
}

 

// 요예제도 트리 만드는데 포함되는지 모르겠다. 일단 이건거 같아서 집어넣음 예제는 4개를 합친거라고했는데..;;
[JTreeModel.java]
import javax.swing.tree.*;
import java.io.*;
public class JTreeModel extends DefaultMutableTreeNode{
 private String filePath = "c:"+System.getProperty("file.separator");;
 private File f1,f2;
 private String[] list;
 public JTreeModel(){
  super(new Driver("c:"+System.getProperty("file.separator")));
  DefaultMutableTreeNode dmt1=null;  
  f1 = new File(filePath);   
  list = f1.list();   
  for(String _temp : list){    
   f2 = new File(filePath,_temp);   
   if(f2.isDirectory()){ 
    dmt1 = new DefaultMutableTreeNode(
     new Directory(_temp));
    add(dmt1);    
   }   
  }
 }
}

 

[WindowSearchEx.java]
import java.awt.*;
import javax.swing.*;
public class WindowSearchEx extends JFrame{
 private JScrollPane sp_jtree;
 public WindowSearchEx(){
  Container contentPane = getContentPane();
  sp_jtree = new JScrollPane(new JTreeDelegate(),
   ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
   ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
  sp_jtree.setPreferredSize(new Dimension(300, 550));
  contentPane.add(sp_jtree);
  setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  setSize(310,555);
  setVisible(true);
 }
 public static void main(String[] args){
  JFrame.setDefaultLookAndFeelDecorated(true);
  new WindowSearchEx();
 }
}
//예제가 워낙 빨리 넘겨서 하다 말았는데 위에것과 이것 그리고 몇개를 더하면 C드라이브를 트리구조로 보여주는것을 만들수 있다. 17일차에 있으니 확인 바란다.
//이번 쉬는동안 분석해보자. 간단한 스윙만들고 맨끝에 윈도우에 관련된 트리를 만들어주는 클래스를 꺼내서 만들면된다. 나머지는 붙이기로 해결해라.

-------------------------------------
-------------------------------------
Byte Stream(1바이트를 읽고 쓸수 있는)
 Byte Stream은 1byte를 Input/Output 할 수 있는 Stream이다.
 일반적으로 Byte로 구성된 file, 즉 동영상 file, Image file, 음악 file을 처리하기에 적합한 Stream이다.

Byte Stream의 종류
 InputStream과 OutputStream으로 구성되어 있다. 인풋스트림 아웃풋스트림

fileinput 파일인풋스트림 파일의 내용을 읽어드릴때 쓰는

오브젝트 인풋스트림 객체를 읽어드릴때 쓰는

버퍼도 인풋스 트림 데이터를 내타입에 맞게끔 읽고 쓰는 스트림

시스템점 in 쓰는거 시스템점 아웃 쓰는거 시스템점 에러 에러다. (system.out.println 요딴식)

Byte Input Stream(InputStream)(읽어드릴때 필요한 모든것을 담고 있는것이 기본 인풋스트림이다.)
 InputStream은 Byte Input을 수행하는 데 필요한 method를 정의하는 추상 class이다.
 Java Program은 Object를 생성하고 생성된 Object와 Byte Stream과 연결함으로써 file을 연다.
 Java는 다른 장치들과도 Byte Stream을 연결할 되어 있는고 Program이 시작되면 장치들과 연결된 세 개의 Object(System.in, System.out, System.err)를 생성한다.
 System.in Object는 Keyboard로 Byte를 Input할 수 있는 InputStream Object이다.

InputStream의 주요 method
 read( ) 기본메소듣. 스트림 데이터 1바이트를 읽어온다. 반환값은 0~255의 아스키코드 값이기 때문에 문자로 나타내려면 char로 캐스팅해야 한다.더 이상 읽을 수 없을 때는 -1을 반환한다.

 read(byte b[ ]) 바이트형으로 저장 위에껄 제외하고 나머지 메소드는 이런식으로 알면된다.

 close( ) 입력 스트림을 닫는다.아래한글로 작업을 하고 있는데 그걸 탐색기에서 삭제 하려고 하면 안되는형식. 클로우즈를 써야지만 작업이 가능하다.

 

 

FileInputStream
 FileInputStream은 System에 있는 모든 file을 읽을 수 있는 기능을 제공한다.
 file을 읽을 때는 file의 경로와 file Object를 Constructor의 parameter로 설정할 수 있다.
 만약, file이 존재하지 않으면 FileNotFoundException을 발생하게 된다.

 

DataInputStream (어쩌다 한번 활용할수 있는 메소드)
 DataInput Interface는 Input Stream으로부터 기본형 Data를 읽기 위한 method를 정의한다.(적절하게 타입에 맞는 것을 읽어드린다.)
 DataInput Interface는 Primitive Data Type을 읽을 수 있는 각종 method와 Character를 읽을 수 있는 method를 정의 하고 있다.
 DataInputStream class의 Constructor는 한 개로 구성되어 있으며, 어떠한 예외 처리도 되어 있지 않다.

 

BufferedInputStream (속도차이는 별로 안나지만 많이 쓰인다.)
 Bufferring은 Input/Output 수행을 향상 시킨 기술이다.
 Bufferring이란 논리적 Data 덩어리들이 하나의 큰 물리적 Input 연산으로서 file로부터 읽혀서 Buffer로 Input 하는 것을 말한다.(다른 말로 표현하면 메모리 활용 파일을 메모리에다 올려놓고, 쓰기 떄문에 읽고 쓰는 속도가 향상 된다.)
 Bufferring을 이용하면 Data를 읽어서 Buffer를 꽉 채우고, 연속된 read() method 호출의 경우는 단지 memory Buffer로부터 Data를 읽어 내는 것일뿐으므로 훨씬 효율적이다. (메모리를 채우고 작업하기 떄문에 하드디스크에서 읽는것보다는 향상이 될수 있다. 메모리에서 읽는)
 또한 mark 기능과 reset 기능을 구현 추가로 구현하였다.

 

인풋쓰트림은 파일에 써져 있는 내용을 읽는데 쓰인다.
아웃풋스트림은 쓰는데 쓰인다.(파일에다 데이터를 쓰는)

Byte Output Stream(OutputStream)
 OutputStream은 Byte Output을 수행하는 필요한 method를 정의한 abstract class이다.
 Program이 시작 되면 장치와 연결된 두 개의 Output Stream은 System.out(데이터출력), System.err(에러메세지출력)를 생성한다.
 System.out Object는 화면에 Data를 Output 한다.
 System.err Object는 화면에 error Message를 Output하게 된다.

flush( ) 플러쉬 메소드 출력 스트림을 통하여 쓰기를 할 때 일반적으로 버퍼에 가득차게 되면한꺼번에 보내게 되는데, 이 메서드를 사용하게 되면 버퍼에 가득 차있지 않더라도 버퍼의 내용를 바로 보내게 된다.

FileOutputStream (시스템에 모든파일에 쓰는것을 제공)
 FileOutputStream은 System에 있는 모든 file에 쓸 수 있는 기능을 제공한다.
 만약 Object를 생성할 때 , file이 존재하지 않으면 FileNotFoundException을 발생하게 된다.
 Object가 생성되면 file이 있는 경우에는 file을 생성하지 않으면 file이 없는 경우에는 file을 생성하게 된다.
 FileNotFoundException의 의미는 경로가 일치하지 않을 때 발생하는 예외이다. 즉 경로는 일치하고 file이 없는 경우에는 예외가 발생하지 않고 file 생성하게 된다.

 

DataOutputStream
 DataOutput Interface는 Output Stream으로부터 기본형 Data를 쓰기 위한 method를 정의한다.
 DataOutput Interface는 Primitive Data Type을 쓸 수 있는 각종 method와 Character를 쓸 수 있는 method를 정의 하고 있다.
 DataOutputStream class의 Constructor는 한 개로 구성되어 있으며, 어떠한 예외 처리도 되어 있지 않다.

 

BufferedOutputStream
 이 class를 사용하면 Buffer가 채워질 때마다 한번에 대량으로 Output장치로의 실제 전송이 수행된다.(한번에 읽어드릴ㄸㅐ)
 OutputStream은 Output 속도의 향상을 위해서 flush() method를 정의하고 있다. 하지만 실제로는 구현되지 않았다.
 flush란 Buffer가 다 차지 않더라도 Buffer를 비워주는 기능.
 flush 기능을 구현한 class가 바로 BufferedOutput-Stream class가 된다.

 

PrintStream
 PrintStream은 모든 Data Type을 Output할 수 있는 print(), println() method가 Overloading 되어 있다.
 Program이 시작되면 장치와 연결된 OutputStream인 System.out, System.err Object가 PrintStream Object다.
 Java 5.0에서는 PrintStream의 format() method와 printf() method가 추가되어 있기 때문에 이전의 System.out.printf() 나 System.out.format()을 이용해서 Output문을 작성할 수 있었다.

 

 

 

-------------------------------------
-------------------------------------
[InputStreamEx.java]
import java.io.IOException;
public class InputStreamEx{
 public static void main(String args[])throws IOException{ // throws쓰로스 예외전가.  와일드문은 캐치라던가 써줘야 하는데 IOException로 쓰로스가 떙겨와서 예외를 전가 시켰기 떄문에 IOException보고 처리하라고한것임
  System.out.println("입력하세요..");
  int _byte;
  while((_byte=System.in.read())!=-1){ // System.in.read()) in 입력하고 엔터를 치면 리드메소드가 읽어드린다. 그내용이 -1이 아니라면 // -1 원래 문자는 -1이라는 음수 문자를 가질수 없다. -1은 공백 즉 아무것도 입력하지 않으면 아무것도 발동되지 않고. 입력하면 아래와 같이 발동하라라는 뜻
   if(_byte == 10 || _byte == 13) continue; //10이나 13이면 계속진행
   if(_byte == 113 || _byte==81) break; //113이나 81이면 빠져나가고 //113q 아스키코드 문자인데  그문자를 치면 빠져나간다는 사람들과 약속임
   char c = (char) _byte;  //읽어드린 것을 캐리터 변수에 저장한다음에
   System.out.printf("%s(%d)",c,_byte); //출력을한다.
  }  
 }
}

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

//정확한 경로를 넣어주어야만 오픈해서 나온다. 그렇지 않으면 안나온다. \\ 이거 두개
//아래한글 읽어드릴떄 마지막 저장한거 띄운다던지 이전작업한게 나오는것이 프로그램이 저장되면 인풋을 계속 쓰는거고, 출력되면서 아웃풋을 계속 쓰는거다.

[FileInputStreamEx.java]
import java.io.*;
public class FileInputStreamEx{
 public static void main(String arg[]){
  
  FileInputStream fis = null; //클래스 객체 선언 파일인풋스트림
  byte _read[] = new byte[100]; //바이터 타입의 배열을 100자저장해라(100자로 지정되어 있기 때문에 자바 내용의 100자만 저장 가능. 이걸 길게 하려면 1000자로 바꿔 주면된다.)
  byte console[] = new byte[100]; //바이터 타입의 콘솔 배열을 100자저장해라 (100자로 지정되어 있기 때문에 자바 내용의 100자만 저장 가능. 이걸 길게 하려면 1000자로 바꿔 주면된다.)
  try{
   System.out.print("파일명 : ");
   System.in.read(console); //파일명 읽어드려서 콘솔이라는 배열에 저장 리드에 매개변수가 들어가면 그 매개변수에 저장
   String file = new String(console).trim(); //배열에 한자 한자 저장. 트림은...? 없앤다?
   fis = new FileInputStream(file); //파일을 객체서 생성
   fis.read(_read,0,_read.length); // fis을 리드 메소드로 읽는다.
   System.out.println(
     new String(_read).trim());
  }catch(FileNotFoundException fnfe){
   fnfe.printStackTrace();
  }catch(IOException ie){
   ie.printStackTrace();
  }finally{
   try{
    if(fis != null) fis.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
 }
}

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

[BufferedInputStreamEx.java]
import java.io.*;
public class BufferedInputStreamEx {
 public static void main(String[] args){
  FileInputStream fis = null; //객체선언
  BufferedInputStream bis = null;
  try{
   fis =
    new FileInputStream("c:\\bufferIn.txt");// c:\\bufferIn.txt 여기서 읽어드리겠다.
   bis =
    new BufferedInputStream(fis);  //파일 인풋에 fis읽어드린 내용을 메모리에 올리겠다. fis여기서 읽어드린 내용 바로위의것 fis
   int readbyte=0;
   while((readbyte = bis.read()) != -1) { // 리드메소드로 읽고 -1이 아니면 계속 반복
    System.out.print((char)readbyte);
         }
  }catch(IOException ioe){
   ioe.printStackTrace();
  }finally{
   try{
    if(fis != null) fis.close(); // fis 가 널이 아니면 클로우즈
    if(bis != null) bis.close(); // bis 가 널이 아니면 클로우즈
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
         
 }
}

//여기까지 예제가 읽어드리는 연습 인풋
-------------------------------------
-------------------------------------
//아래와 같이 쓰진 않는다. 그런데 아웃풋을 가지고 억지로 쓰는것을 보여주는 예제

[OutputStreamEx.java]
import java.io.*;
public class OutputStreamEx{
 public static void main(String args[]){
  PrintStream ps = null; // PrintStream 객체선언
  OutputStream out = null; //OutputStream  객체선언
  try{
   ps  = System.out;
   out = (OutputStream)ps; // (OutputStream)를 out으로 캐스팅시킴
   int first='A';
   int second='B';
   out.write(first);
   out.write(second);
   out.flush();
  }catch(IOException ioe){
   ioe.printStackTrace();
  }finally{
   try{
    if(ps != null) ps.close();
    if(out != null) out.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }  
    }
}

-------------------------------------
-------------------------------------
//없던 파일이 생기고 파일에 방금 작업했던게 써질것이다.

[FileOutputStreamEx.java]
import java.io.*;
public class FileOutputStreamEx{
 public static void main(String arg[])
 throws FileNotFoundException,IOException{
  FileOutputStream fos = null; //FileOutputStream객체썬언 
  try{
   fos = new FileOutputStream("c:\\fileout.txt"); //"c:\\fileout.txt 만들어서 작업
      //fos = new FileOutputStream("c:\\fileout.txt",true); //위에꺼에다가 주석달고 이거에다가 주석 풀고 생성할때 출력물이 다른것을 알수 있는데 트루를 주면 파일 기존것에 이어서 작성을 하는거고 펄스는 기존것을 아예 지우고 작성하는거다.(텍스트 파일을 보면확인이가능하다.)
   String message = "Hello FileOutputStream!!"; // 스트링 타입의 문자열선언
   fos.write(message.getBytes()); // getBytes()문자열의 배열을 쪼개서 바이트로 나타내는
   fos.close();  
  }catch(FileNotFoundException fnfe){
   fnfe.printStackTrace();
  }catch(IOException ie){
   ie.printStackTrace();
  }finally{
   try{
    if(fos != null) fos.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
  }
 }

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

//바이트 단위로 저장했기 때문에 뭔지모르는 출력물이 뜬다.
[DataOutputStreamEx.java]
import java.io.*;
public class DataOutputStreamEx {
 public static void main(String args[]) throws IOException {
  FileInputStream fis = null;
  DataInputStream dis = null;
  FileOutputStream fos = null;
  DataOutputStream dos = null;
  try {
   fos = new FileOutputStream("c:\\dataOut.txt"); // c:\\dataOut.txt를 만들면서 FileOutputStream객체생성
   dos = new DataOutputStream(fos);
   dos.writeBoolean(false);
   dos.writeInt(20000); //정수
   dos.writeChar('T'); //문자
   dos.writeDouble(290.45); //실수
   fis = new FileInputStream("c:\\dataOut.txt"); //데이터 아웃풋점을 읽게끔 new FileInputStream를 만들어주고
   dis = new DataInputStream(fis);
   System.out.println(dis.readBoolean());
   System.out.println(dis.readInt()); // 바이트를 읽었기 때문에 깨져서나온다.
   System.out.println(dis.readChar());
   System.out.println(dis.readDouble());
   
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fis != null) fis.close();
    if (dis != null) dis.close();
    if (fos != null) fos.close();
    if (dos != null) dos.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }

 }
}
-------------------------------------
-------------------------------------
[BufferedOutputStreamEx.java]
import java.io.*;
public class BufferedOutputStreamEx {
 public static void main(String[] args){
  FileOutputStream fos = null;
  BufferedOutputStream bos = null;
  try {
   fos = new FileOutputStream("c:\\bufferOut.txt");
   bos = new BufferedOutputStream(fos);
   String str = "BufferedOutputStream Test 입니다."; //문자열을 만들어놓고
   bos.write(str.getBytes()); //문자열을쓰겠다. 버퍼는 8키로바이트의 용량이 채워지기 전에는 쓰지 않는다. 이대로 실행하면 아무것도 안뜬다.
   //bos.flush(); //그러나 이주석을 풀면 써진다. 플러쉬는 꽉차지 않더라도 써주는 메소드ㅏ.

  } catch (IOException ie) {
   ie.printStackTrace();
  } finally {
   try {
    if (fos != null) fos.close();
    if (bos != null) bos.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}
-------------------------------------
-------------------------------------

[PrintStreamEx.java]
import java.io.*;
public class PrintStreamEx {
 public static void main(String[] args)  {
  FileOutputStream fos = null;
  BufferedOutputStream bos = null;
  PrintStream ps = null; // 선언
  try{
   fos = new FileOutputStream("c:\\printStream.txt"); //FileOutputStream("c:\\printStream.txt"를 만들어서
   bos = new BufferedOutputStream(fos);  // 그걸 불러들여 여기서 작업하고
   ps = new PrintStream(bos,true); // 여기서 그걸 또 가져와 출력한다. //여기다 트루를 쓰면 바로 바로 쓰인다. 여기다 펄스로 주면 안써진다.(텍스트로 확인가능)
   ps.println("성영한");
   ps.println(1234);
   ps.println(true);
   ps.println('a');
  }catch(IOException ie){
   ie.printStackTrace();
  }finally{
   try{
    if(fos != null) fos.close();
    if(bos != null) bos.close();
    if(ps != null) ps.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
 }
}

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

-------------------------------------
-------------------------------------
Character Stream의 특징(2바이트를 읽고 쓸수 있다(영어는 물론 세계 모든 랭귀지들을 인아웃풋 하기에 적합하다. 똑같은데 바이트차이다.). 위에 바이트 스트림은 1바이트(영문자로 구성된 파일, 음악파일, 영화파일등)
 Byte Stream에 추가하여 Reader와 Writer class를 제공하는데, 이것은 2Byte를 Input/Output 할 수 있는 Character 기반 Stream이다.
 Byte Stream은 1Byte를 Input/Output하기 때문에 일반적으로 영문자로 구성된 file,  동영상 file, 음악 file의 Input/Output 등에 적합한 Stream이다.
 Character Stream은 2Byte를 Input/Output하기 때문에 세계 모든 언어로 구성된 file을 Input/Output 하기에 적합하다.

 Character Stream의 구조
 Character Stream은 Reader와 Writer로 나눈다.

 Character Input Stream ? Reader (인풋스트림)
 Character Output Stream - Writer (아웃풋 스트림)

Reader(리더 읽기 클래스)-차이점은 2바이트를 읽을 수 있다.
 Reader class는 Character Input Stream의 최상위 abstract class이다.
 InputStream class와 거의 같은 method를 제공하고 있으며, 차이점은 Reader class는 2Byte를 읽을 수 있는 method로 구성되었다는 점이다.

//앞의 바이트 스트림이 정리가 되야 이것도 똑같이 정리가 될것이다.
FileReader(파일리더)
 FileReaderclass는 System에 있는 file을 읽을 수 있는 기능을 제공한다.
 file을 읽을 때는 file의 경로,  File Object를 Constructor의 parameter로 지정할 수 있다.
 file이 존재 하지 않으면 FileNotFoundException 예외를 발생한다.
 FileReader class는 Character Stream으로 한Character를 읽기 때문에 화면에 Output하더라도 한글 깨지는 현상이 일어나지 않는다.

 

Writer
 Writer class는 Character Output Stream의 최상위 abstract class이며, OutputStream과 거의 같은 method를 제공한다.
 Writer class는 2Byte를 Output할 수 있는 method로 구성되어 있다.

 

PrintWriter(프린트 라이터)-아무거나 가지고 객체를 생성한후 출력할수 가 있다.
 PrintWriter class는 다른 Stream과 다르게 Byte Output Stream과 Character Output Stream을 가지고 Object를 생성할 수 있는 class이다.
 자동 flush 기능을 가지고 있다.
 PrintWriter class의 Constructor에는 FileNotFoundException 예외를 발생하기 때문에 반드시 예외처리를 해야 한다.

 

 

 

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

[FileReaderEx.java]
import java.io.*;
public class FileReaderEx {
 public static void main(String[] args) {
  FileReader fr = null;
  try {
   fr = new FileReader("c:\\fileReader.txt");
   int readChar;
   while ((readChar = fr.read()) != -1) { //((readChar = fr.read()) 이건 바로 읽엉서 바로 출력이 가능. 위의예제는 읽은내용을 배열에 저장한다음에 다시 뽑아냈는데
    System.out.print((char) readChar);
   }
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fr != null)
     fr.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

//이 밑에껀 똑같은 결과값이나 다른방법
/*
 //read(char[] cbuf) 메서드 사용
 char[] cbuf = new char[100];
 int totalReadCount = fr.read(cbuf);
 System.out.println(new String(cbuf));
 System.out.println("totalReaderCount : "+ totalReadCount);
 */
/*
 //read(char[] cbuf, int start, int length)
 char[] b = new char[100];
 int totalReadCount = fr.read(b,10,23); //10부터 23자만 저장
 System.out.println(new String(b));
 System.out.println("totalReaderCount : "+ totalReadCount);
 */

[BufferedReaderEx.java]
import java.io.*;
public class BufferedReaderEx {
 public static void main(String[] args){
  FileReader fr = null;
  BufferedReader br = null;
  try {
   fr = new FileReader("c:\\bufferReader.txt");
   br = new BufferedReader(fr);
   String msg;
   while ((msg = br.readLine()) != null) {
    System.out.println(msg);
   }
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fr != null) fr.close();
    if (br != null) br.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

-------------------------------------
-------------------------------------
[BufferedReaderEx.java]
import java.io.*;
public class BufferedReaderEx {
 public static void main(String[] args){
  FileReader fr = null;
  BufferedReader br = null;
  try {
   fr = new FileReader("c:\\bufferReader.txt");
   br = new BufferedReader(fr); //파일 리더 객체를 이용해서 버퍼리더 객체를 생성
   String msg; //
   while ((msg = br.readLine()) != null) { //br.readLine())줄단위로 msg를 출력해라.
    System.out.println(msg);
   }
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fr != null) fr.close();
    if (br != null) br.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}
//여기까지 예제가 읽는거
-------------------------------------
-------------------------------------
//여기서부터 쓰는 예제
[FileWriterEx.java]
import java.io.*;
public class FileWriterEx {
 public static void main(String arg[]) {
  FileWriter fw = null;
  try {
   fw = new FileWriter("c:\\fileWriter.txt");
   // fw = new FileWriter("c:\\fileWriter.txt",true);
   String message = "안녕하세요 FileWriter 테스트";
   fw.write(message); //라이터로 쓴다.
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fw != null) fw.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

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

[BufferedWriterEx.java]
import java.io.*;
public class BufferedWriterEx {
 public static void main(String[] args) {
  FileWriter fw = null;
  BufferedWriter bw = null;
  try {
   fw = new FileWriter("c:\\bufferWriter.txt");
   bw = new BufferedWriter(fw);
   bw.write("BufferedWriter 테스트입니다.");
   bw.newLine(); //뉴라인 줄바꿈
   bw.write("안녕하세요" +
     System.getProperty("line.separator")); // getProperty("line.separator") 라인을 구분하는 구분자 각 시스템에 맞는 라인에 맞는 구분자가 들어간다.(운영체제에 맞게
   bw.flush();
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fw != null) fw.close();
    if (bw != null) bw.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }  
 }
}
-------------------------------------
-------------------------------------

[PrintWriterFirstEx.java]
import java.io.*;
public class PrintWriterFirstEx {
 public static void main(String arg[]) {
  FileWriter fw = null;
  BufferedWriter bw = null;
  PrintWriter pw = null;
  try {
   fw = new FileWriter("c:\\printWriterFirst.txt"); // 파일라이더 객체 생성하고
   bw = new BufferedWriter(fw); //버퍼라이터 객체 생성하고
   pw = new PrintWriter(bw,true); //프린트라이터 객체 생성하고 // bw 이부분이 라이터가 아니고 아웃풋스트림이라도 관계가 없다.
   pw.println("안녕하세여");
   pw.println("반갑습니다.");
   pw.println(100);
   pw.println(new Integer("1000"));
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fw != null) fw.close();
    if (bw != null) bw.close();
    if (pw != null) pw.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}
-------------------------------------
-------------------------------------

[PrintWriterSecondEx.java]
import java.io.*;

public class PrintWriterSecondEx {
 public static void main(String arg[]) {
  PrintWriter pw = null;
  FileOutputStream fos = null;
  BufferedOutputStream bos = null;
  try {
   fos = new FileOutputStream("c:\\printWriterSecond.txt");
   bos = new BufferedOutputStream(fos);
   pw = new PrintWriter(bos, true); // 앞에랑 똑같은데 PrintWriter이것만틀리다.
   pw.println("안녕하세여!!");
   pw.println("또 만났네요.");
   pw.println(100.0);
   pw.println(new Boolean(true));
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fos != null) fos.close();
    if (bos != null) bos.close();
    if (pw != null) pw.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

-------------------------------------
-------------------------------------
//바이트 스트림과 캐리터스트림을 연결할떄 씀. (1바이터로 처리 되어있는것을 2바이터로 처리하고 싶을때)-InputStreamReader
//읽어올 파일의 경로를 써주고 엔터치면 정확히 읽어줘서 출력하고 있다.
import java.io.*;
class  FileRead{
 public static void main(String[] args)throws Exception {
  int i = 0;
  String file;
  BufferedReader read =
   new BufferedReader(new InputStreamReader(System.in)); // InputStreamReader(System.in)
  System.out.print("읽어올 파일을 입력하세요==");
  file = read.readLine(); // 파일이름 입력하면 저장
  System.out.println(file+" 문서의 내용==========");
  FileInputStream fr = new FileInputStream(file); //파일이름을 읽어준다음에 출력하면 끝?
  while((i = fr.read()) != -1){
   System.out.print((char)i);
  }
  fr.close();
 }
}

-------------------------------------
-------------------------------------
//파일이름을 입력하면 그 파일이름에 저장되는 예제
//파일이름 입력하라고 뜨면 입력하고 문자열을 입력하라고 하면 입력하면 만들어짐

import java.io.*;
import java.util.*;
class  FileWrite{
 public static void main(String[] args)throws Exception {
  String file, str;
  Date date = new Date();
  str = "파일 생성시간\n"+date+"\n";
  BufferedReader read =
   new BufferedReader(new InputStreamReader(System.in));
  System.out.print("파일 이름을 입력하세요==");
  file = read.readLine();
  System.out.println("저장할 문자열을 입력하세요=====");
  str +=read.readLine();
  char [] ch_str = new char[str.length()];
  str.getChars(0,str.length(), ch_str , 0);
  FileWriter fw = new FileWriter(file);
  fw.write(ch_str);
  fw.close();
  System.out.println(file+" 파일을 성공적으로 저장했습니다.");
 }
}

-------------------------------------
-------------------------------------
 java.io.*;
import java.util.*;
class  DataOutputStreamEx{
 public static void main(String[] args) throws Exception{
  File tf = new File("d://soldesk.txt");
  FileOutputStream fos = new FileOutputStream(tf); //
  DataOutputStream dos = new DataOutputStream(fos); //데이터 아웃스트림 생성
  dos.writeBoolean(true);
  dos.writeChar(65);
  dos.writeShort(100);
  dos.writeInt(100);
  dos.writeLong(1000);
  dos.writeFloat(6.7f);
  dos.writeDouble(10.15);
  dos.flush();
  System.out.println("testEx.txt에"+dos.size()+ " byte 저장");
  dos.close();
 }
}

//오늘만하고 안쓸 확률100%다. 차이점만 보면된다.
-------------------------------------
-------------------------------------
//오늘만하고 안쓸 확률100%다. 차이점만 보면된다.
import java.io.*;
import java.util.*;
class  DataIntputStreamEx{
 public static void main(String[] args) throws Exception{
  File tf = new File("d://soldesk.txt");
  FileInputStream fis = new FileInputStream(tf);
  DataInputStream dis = new DataInputStream(fis);
  System.out.println(dis.readBoolean());
  System.out.println(dis.readChar());
  System.out.println(dis.readShort());
  System.out.println(dis.readInt());
  System.out.println(dis.readLong());
  System.out.println(dis.readFloat()); 
  System.out.println(dis.readDouble());
  dis.close();
 }
}

-------------------------------------
-------------------------------------
파일클래스,  바이트 스트림, 캐리터 스트림, 바이터 스트림 캐리터스트림으로 바꾸는 방법 까지 공부하면되겠다.

다음주 스캐너 클래스

1바이트

file outputstream
file Inputstream
Buffered outputStream
Buffered inputStream
Data outputStream
Data InputStream

print outputStream

//요거 꼰 예제 말고 생성하는 법을 보자. 이와 같은 것이 중요하다.(안꼰예제들도 있다.)

 

-------------------------------------
-------------------------------------
//여기서 부터 아래 예제들은 형이 직접 뽑아준 예제
//IO는 읽고 쓰려고 쓰는거다. 네트웍에서도 쓰인다.

[BufferedInputStreamEx.java]********
import java.io.*;
public class BufferedInputStreamEx {
 public static void main(String[] args){
  FileInputStream fis = null; // 널값은 편의상 넣어주는거다.  File f = new File("aaa.txt"); // FileInputStream fis = new FileInputStream(f); //  fis = new FileInputStream(f); 이거랑 다 같은거다. 그냥 편의 변수 놓은것을 한번에 보기 위해서 개인의 취향에 따라 설정하는 것일뿐 다똑같다.
  BufferedInputStream bis = null;
  
  try{ // 트라이 캐치 파이널리 기본구문 조오기까지
   fis =
    new FileInputStream("c:\\bufferIn.txt"); // FileInputStream는 ("c:\\bufferIn.txt") 있는것을 불러드리겠다.
   bis =
    new BufferedInputStream(fis); //BufferedInputStream 메모리에 상주시키겠다. 이걸 굳이 안써줘도 되나 손이 더 갈수 있다. 
   int readbyte=0;
   while((readbyte = bis.read()) != -1) { // 이반복문 해석 :  read()) 최종적으로 마지막으로 있는 것을 읽어드린다. 지금과 같은 경우는 버퍼에 상주해 놓는 것을 읽는다.
    System.out.print((char)readbyte); // print 이대로 출력하면 바이트 값을 인트로 담은거기 떄문에 인트로 나온다. 고로 캐리터 형변환해서  readbyte를 출력해준다. 문자로 보기위해서
         }
  }catch(IOException ioe){ //인풋스트림에서 자동적으로 아이오 익셉션이 생긴다.  안잡아주면 (readbyte = bis.read()) 저 리드부분에서 오류(익셉션)가 뜬다. 예외전가를 시켜주던가. 트라이로 잡아주어야한다.
   ioe.printStackTrace(); //  printStackTrace() 용도 알아볼것
  }finally{
   try{
    if(fis != null) fis.close();
    if(bis != null) bis.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
         
 }
}

 

[FileOutputStreamEx.java]***********
import java.io.*;
public class JAVA2{
 public static void main(String arg[])
 throws FileNotFoundException,IOException{ // FileNotFoundException,IOException 여기는 쓰로우를 통해서 잡아줬으니 트라이문을 뻄
  FileOutputStream fos = null;  
  
   fos = new FileOutputStream("c:\\fileout.txt"); // 해당 경로에 가보면 해당 파일에 출력이 되어있을것이다.  OutputStream 출력 File파일
      //fos = new FileOutputStream("c:\\fileout.txt",true);
   String message = "Hello FileOutputStream!!";
   fos.write(message.getBytes());//write() 쓰게 해주는 message.getBytes())메세지를 쪼개서 겟바이트 넣어준다.
   fos.close();  
  
   
  }
  }

 

[DataOutputStreamEx.java]**************
import java.io.*;
public class DataOutputStreamEx {
 public static void main(String args[]) throws IOException { //  IOException 쓰로우를 통해 잡아줬으나 이쌍허게 트라이문을 써줬다.
  FileInputStream fis = null;
  DataInputStream dis = null;
  FileOutputStream fos = null;
  DataOutputStream dos = null;
  try {
   fos = new FileOutputStream("c:\\dataOut.txt"); // FileOutputStream 에서 바로 땡겨쓰면 라이트 문 밖에 쓸수 없다. 고로 DataOutputStream를 통해서 땡겨와서 다시 빼스면 쓸수 있는 메소드 종류가 늘어나 사용이 가능하다.
   dos = new DataOutputStream(fos); // 1.이게 fos와 한몸이고
   dos.writeBoolean(false); //writeBoolean(false) 아 그냥 이값을 출력해보라라는 간단한 거
   dos.writeInt(20000); // 아 그냥 이값을 출력해보라라는 간단한 거
   dos.writeChar('T'); // 아 그냥 이값을 출력해보라라는 간단한 거
   dos.writeDouble(290.45); //아 그냥 이값을 출력해보라라는 간단한 거

   fis = new FileInputStream("c:\\dataOut.txt");
   dis = new DataInputStream(fis); // 2.이게 fis와 한몸이라

   System.out.println(dis.readBoolean()); //위에 아웃풋을 출력한것을 이값으로 읽어드려라.
   System.out.println(dis.readInt()); //위에 아웃풋을 출력한것을 이값으로 읽어드려라.
   System.out.println(dis.readChar()); //위에 아웃풋을 출력한것을 이값으로 읽어드려라.
   System.out.println(dis.readDouble()); //위에 아웃풋을 출력한것을 이값으로 읽어드려라.
   
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fis != null) fis.close(); 3. 저위 두가지만 클로우즈 잡아주면 되는데 다 잡아줬다. 이상하다잉. 두게만 잡아줘도 된다.
    if (dis != null) dis.close(); //dis != null 널값이 아니면 그냥 닫아주라는 소리
    if (fos != null) fos.close();
    if (dos != null) dos.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }

 }
}

 

[BufferedOutputStreamEx.java]*****************

import java.io.*;
public class BufferedOutputStreamEx {
 public static void main(String[] args){
  FileOutputStream fos = null;
  BufferedOutputStream bos = null;
  try {
   fos = new FileOutputStream("c:\\bufferOut.txt");// ("c:\\bufferOut.txt") 출력할 대상 , FileOutputStream 출력할 내용을 담을 파일을 생성
   bos = new BufferedOutputStream(fos); // 메모리 담는다.
   String str = "BufferedOutputStream Test 입니다."; // 이게 파일에 담길 내용 문구. 그러나 스트링은 4바이트 출력 스트림은 1바이트 고로 아래 겟바이트에 배열로 쪼개줘서 넣어줌으로서 출력을 가능하게끔 만들었따.
   bos.write(str.getBytes());
   //bos.flush(); // 이게 없으면 위의 파일에 문구가 담기지 않는다.

  } catch (IOException ie) {
   ie.printStackTrace();
  } finally {
   try {
    if (fos != null) fos.close();
    if (bos != null) bos.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

 

//메소드가 여러개일경우 상관관계를 보기 때문에 메인메소드를 읽고 올라가면되는데 이런건 그냥 쭉 읽음 된다.
[PrintStreamEx.java]***********************
import java.io.*;
public class PrintStreamEx {
 public static void main(String[] args)  {
  FileOutputStream fos = null; //new 하고 생성하는거랑 같은경우라고 보면 된다.
  BufferedOutputStream bos = null; //1.여기서 선언해주고
  PrintStream ps = null;
  try{
   fos = new FileOutputStream("c:\\printStream.txt"); //2.밑에서 뉴 그것처럼 생성 FileOutputStream fos = new FileOutputStream("c:\\printStream.txt")
   bos = new BufferedOutputStream(fos);
   ps = new PrintStream(bos,true); // 여기다 true 를 써주면 아까전 플러쉬가 자동으로 따라온다. flush();
   ps.println("성영한");
   ps.println(1234);
   ps.println(true);
   ps.println('a');
  }catch(IOException ie){
   ie.printStackTrace();
  }finally{
   try{
    if(fos != null) fos.close();
    if(bos != null) bos.close();
    if(ps != null) ps.close();
   }catch(IOException ioe){
    ioe.printStackTrace();
   }
  }
 }
}

 

 

//여기서부터 2바이트
//"c:\\bufferReader.txt"요파일만 읽는다.
[BufferedReaderEx.java]*****************
import java.io.*;
public class BufferedReaderEx {
 public static void main(String[] args){
  FileReader fr = null; // 읽는 2바이트
  BufferedReader br = null; //BufferedReader 읽는 버퍼메모리 2바이트
  try {
   fr = new FileReader("c:\\bufferReader.txt"); // FileReader 읽는 기능 위에 인풋하고 동일
   br = new BufferedReader(fr);
   String msg;
   while ((msg = br.readLine()) != null) { // 2바이트 이거는 스트링 값으로 바로 받기 때문에 위에서 인트값으로 받는것과달리. 버퍼리드 안에 있는 리드 라인을 써서 한줄씩 담는다.
    System.out.println(msg);
   }
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fr != null) fr.close();
    if (br != null) br.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

 

 

[BufferedWriterEx.java](************************
import java.io.*;
public class BufferedWriterEx {
 public static void main(String[] args) {
  FileWriter fw = null;
  BufferedWriter bw = null;
  try {
   fw = new FileWriter("c:\\bufferWriter.txt");
   bw = new BufferedWriter(fw);
   bw.write("BufferedWriter 테스트입니다.");
   bw.newLine(); //뉴라인 줄바꿈
   bw.write("안녕하세요" +
     System.getProperty("line.separator")); // getProperty("line.separator") 라인을 구분하는 구분자 각 시스템에 맞는 라인에 맞는 구분자가 들어간다.(운영체제에 맞게
   bw.flush();
   bw.close(); // 아래 예제 처럼  파이널리 부분을 굳이 넣어서 일일이 안넣어줘도 되고 이렇게 콕 찝어서 닫아줘도 된다.
  } catch (IOException ioe) {
   ioe.printStackTrace();
  }
  }  
 }

 

 

 

[PrintWriterFirstEx.java]*********************
import java.io.*;
public class PrintWriterFirstEx {
 public static void main(String arg[]) {
  FileWriter fw = null;
  BufferedWriter bw = null;
  PrintWriter pw = null;
  try {
   fw = new FileWriter("c:\\printWriterFirst.txt");
   bw = new BufferedWriter(fw);
   pw = new PrintWriter(bw,true); // PrintWriter 는 프린터 프린터라인하고 포맷하고 다들어있다. 고로 아래처럼 써주면된다.
   pw.println("안녕하세여");
   pw.println("반갑습니다.");
   pw.println(100);
   String s = "1000";
   pw.println(new Integer(s));
  } catch (IOException ioe) {
   ioe.printStackTrace();
  } finally {
   try {
    if (fw != null) fw.close();
    if (bw != null) bw.close();
    if (pw != null) pw.close();
   } catch (IOException ioe) {
    ioe.printStackTrace();
   }
  }
 }
}

--------------------------------------------
--------------------------------------------
Integer a = new Integer("1000");

int a = 1000;

위의 경우와 똑같은거다.
String s = "1000";
pw.println(new Integer(s));

 

 

 

 

 

 

 

 

 

 

[FileEx.java]
import java.io.*;
public class FileEx{
 public static void main(String[] args)
  throws IOException{ //메인메소드에 IO익셉션을 붙여줬다. 메소드를  API에서 찾아보면서 어떤 예외가 발생할수 있는지도 알아봐라
  String filePath = "c:\\"; //스트링 패스에 파일 패스라는 개체선언 따옴표 안에 들어간건 문자열인데 역슬러쉬 하나는 취급이 안된다. 두개 넣어야된다.
  File f1 = new File(filePath);  //F1에는 현재쓰는 컴퓨터의 c드라이브라는 루트가 전부 담겨있다.
  String list[] = f1.list(); //파일 정보를 배열로 리턴
  for(int i=0;i<list.length;i++){ //배열의 갯수만큼 반복
   File f2 = new File(filePath,list[i]); //파일 패스는 C드라이브 리스트에는 파일명이나 디렉토리가 나옴 여기까지 경로를 잡은 다음에 개체를 생성 f2
   if(f2.isDirectory()){
    System.out.printf("%s : 디렉토리 %n",list[i]);
   }else{
    System.out.printf("%s : 파일(%,dbyte)%n",
      list[i],f2.length());
   }//파일이름과 파일디렉토리를 출력.
  }  
  File f3 = new File("c:\\test.txt"); //파일 개체를 생성한다. c드라비브에 TEST.TXT
  System.out.println(f3.createNewFile()); // 새로운 파일을 만드는 메소드 크레이트 뉴파일 createNewFile()
  System.out.println(f3.getAbsolutePath()); // getAbsolutePath()
  System.out.println(f3.getCanonicalPath()); // getCanonicalPath(
  System.out.println(f3.getPath()); // getPath()
  System.out.println(f3.getName()); //getName())파일의 이름을 뽑아냄
  System.out.println(f3.getParent()); //파일이 퐘되어있는 폴더나 디렉토리를 뽑아냄
  File f4 = new File("c:\\test.txt"); //똑같은 파일을 하나더만듬
  File f5 = new File("c:\\test1.txt"); //TEST1을 더마듬
  System.out.println(f4.renameTo(f5)); //f4에 있는 renameTo()이름을 f5에 이름으로 바꿔치기 하겠다. 들어가면 텍스트 원으로 바뀐것을 확인할수 있다.
 }
} // 들어가서보면 파일이 만들어져 있다.
//미니홈피를 만든다.해서 만들기 하면 만들어지는데 그냥 만들어지는게 아니라 이와 처럼 카피 읽어서 만들수 있게끔 해준다.