java基础--IO流(3)

io流分为    字节流与字符流

 字节流读写的是字节二进制  使用于 图片、视频

字节输入流 inputstream    实现类  FileInputstream 

字节输出流 outputstream  实现类 Fileoutputstream

inputstream 子类fileinputstream 子类datainputstream与dataoutputstream

字节流转换为字符流

InputStreamReader和OutputStreamWriter  两个类

字符流读写的是字符文本 实用于文本的读写  

字符输入流  reader  实现类 FileReader  

字符输出流  writer   实现类 FileWriter

带缓存区的字符流适合大文本读取，按一行一行的读取 bufferadreader 和bufferadwriter 

package oop.io.file;

import java.io.File;
import java.io.IOException;

public class FileDemo {
    /**
     * 创建文件夹
     */
    public static void createFile(File file) {

        /**
         * 判断是否有文件
         */
        if (file.exists()) {
            if (file.isFile()) {
                System.out.println("是文件");
            } else if (file.isDirectory()) {
                System.out.println("是文件夹");
            }
        } else
        /**
         * 没有文件夹
         */
        {

            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 查看文件家
     * 
     */
    public static void getFileInfo(File file) {
        System.out.println("文件名" + file.getName());
        System.out.println("文件大小" + file.length());
        System.out.println("文件相对路径" + file.getPath());
        System.out.println("文件绝对路径" + file.getAbsolutePath());

    }
    
    /**
     * 删除文件
     * 
     */
    public static void deleteFile(File file){
        if(file.exists()){
             if (file.isFile()) {
                file.delete();
                System.out.println("文件已删除");
            }
            
        }else{
            
            System.out.println("文件不存在");
        }
        
        
    }
}

package oop.io.file;

import java.io.File;

public class Test {
  public static void main(String[] args) {
    File file=new File("D://holly.txt");
    FileDemo.createFile(file);      
    FileDemo.getFileInfo(file);      
    //FileDemo.deleteFile(file); 
      
}
}

package oop.io.inoutstram;

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

import oop.io.file.FileDemo;

public class InOutStream {
    public static void main(String[] args) throws IOException {
        File file=new File("D://bizhi.jpg");
        /*readerFile(file); 
        writeFile(file);*/
        File file2=new File("D://ouchanglu.jpg");
        FileDemo.createFile(file2);
        copyPater(file2, file);
    }
    
    /**
     * 文件复制粘贴
     */
    /**
     * 字节输入流，写的
     * @throws IOException 
     * 
     */
   public static void copyPater(File file2,File file) throws IOException{
       
       InputStream inputStream=new FileInputStream(file);
       byte[] bsw=new byte[(int) file.length()];
       inputStream.read(bsw);
       
       OutputStream outputstream=new FileOutputStream(file2);
       outputstream.write(bsw);
       
       inputStream.close();
       outputstream.close();
       
       
   }
    
    
    
    
   public static void writeFile(File file) throws IOException{
      //创建输入流
       OutputStream outputStream=new FileOutputStream(file);
          
          String str="abcdefghijklmnopqrst";
          byte[] bsw=str.getBytes();
          outputStream.write(bsw);
          outputStream.close();
   }
    
   /**
    * 
    * 
    * 读取文件流
    */
    
   public static void readerFile(File file) throws IOException{
      
       InputStream inputStream=new FileInputStream(file);
        
       byte[] bws=new byte[(int) file.length()];
          inputStream.read(bws);       
       for (byte b : bws) {
        System.out.print(b);
    }   
       inputStream.close();
   }
   
   
   
   
}

package com.readwritebuffered;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import javax.print.DocFlavor.READER;

/**
 * 带有缓冲区是字符流读写操作
 * @author pc
 *
 */
public class ReadWriteBufferedTest {
    public static void main(String[] args) throws IOException {
        //1.指定路径
        File file=new File("D://holly.txt");
        //2.字符流写入
        writeFile(file);
        //3.字符流读取
        readFile(file);
        //4.复制文件
        copyFile("D://holly.txt","C://holly.txt");

    }
    /**
     * 复制文件
     * @param string
     * @param string2
     * @throws IOException 
     */
   private static void copyFile(String sourcePath, String targetPath) throws IOException {
     //1.创建字符输入流对象，并指定读取路径
        Reader fr=new FileReader(sourcePath);
        BufferedReader br=new BufferedReader(fr);
        
        //2.定义字符输出流对象
        Writer fw=new FileWriter(targetPath);
        BufferedWriter bw=new BufferedWriter(fw);
        
        //3.循环按行读取，按行写入
        String str=br.readLine();
        while(str!=null){
            //按行写入
            bw.write(str);
            bw.newLine();
            bw.flush();
            //改变循环条件
            str=br.readLine();
        }
        //4.关闭流
        fr.close();
        fw.close();
        System.out.println("copy file成功");
       
   }
/**
    * 字符流写入
    * @param file
 * @throws IOException 
    */
    private static void writeFile(File file) throws IOException {
        //1.定义字符输出流对象
        Writer fw=new FileWriter(file);
        BufferedWriter bw=new BufferedWriter(fw);
        
        //2.按行写入
        bw.write("我爱我家");
        bw.newLine();
        bw.write("我爱TB47");
        bw.flush();
        
        //3.关闭流
        fw.close();
        System.out.println("写入成功");
        
    }
    /**
     * 字符流读取操作
     * @param file
     * @throws IOException 
     */
    private static void readFile(File file) throws IOException {
        //1.创建字符输入流对象，并指定读取路径
        Reader fr=new FileReader(file);
        BufferedReader br=new BufferedReader(fr);
        
        //2.按行读取
        String str=br.readLine();
        while(str!=null){
            System.out.println(str);
            str=br.readLine();
        }
        
        //3.关闭流
        fr.close();
        
        
    }

}

package com.readwrite;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import javax.print.DocFlavor.READER;

/**
 * 字符流读写操作
 * @author pc
 *
 */
public class ReadWriteTest {
    public static void main(String[] args) throws IOException {
        //1.指定路径
        File file=new File("D://holly.txt");
        //2.字符流写入
        writeFile(file);
        //3.字符流读取
        readFile(file);
        //4.复制文件
        copyFile("D://holly.txt","C://holly.txt");

    }
    /**
     * 复制文件
     * @param string
     * @param string2
     * @throws IOException 
     */
   private static void copyFile(String sourcePath, String targetPath) throws IOException {
       //1.创建字符输入流对象 
       Reader fr=new FileReader(sourcePath);
       //2.创建char数组
        char[] ch=new char[10];
        //3.读取到数组
        fr.read(ch);
        //4.创建字符输出流对象
        Writer fw=new FileWriter(targetPath);
        //5.将数组内容写入到文件
        fw.write(ch);
        //6.刷新流
        fw.flush();
        //7.关闭流
        fw.close();
        fr.close();
        System.out.println("copy file success");
          
    }
/**
    * 字符流写入
    * @param file
 * @throws IOException 
    */
    private static void writeFile(File file) throws IOException {
        //1.定义字符输出流对象
        Writer fw=new FileWriter(file);
        
        //2.定义写入内容
        String str="我爱我家";
        
        //3.使用字符输出流对象写入到指定路径
        fw.write(str);
        
        //4.关闭流
        fw.close();
        System.out.println("写入成功");
        
    }
    /**
     * 字符流读取操作
     * @param file
     * @throws IOException 
     */
    private static void readFile(File file) throws IOException {
        //1.创建字符输入流对象，并指定读取路径
        Reader fr=new FileReader(file);
        
        //2.定义字符数组
        char[] ch=new char[10];
        
        //3.使用字符输入流对象，将内容读取到数组
        fr.read(ch);
        
        //4.循环查看读取内容
        for (char c : ch) {
            System.out.println(c);
        }
        
        //5.关闭流
        fr.close();
        
        
    }

}

package com.data;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 二进制文件读写
 * @author pc
 *
 */
public class DataTest {
    public static void main(String[] args) throws IOException {
        //1.指定读取路径
        File file=new File("D://Koala.jpg");
        //2.创建字节输入流对象
        FileInputStream fis=new FileInputStream(file);
        //3.创建二进制字节输入流对象
        DataInputStream dis=new DataInputStream(fis);
        //4.创建字节数组
        byte[] bt=new byte[(int) file.length()];
        //5.将源文件内容读取到字节数组
        dis.read(bt);
        //6.创建字节输出流对象
        FileOutputStream fos=new FileOutputStream("C://Koala.jpg");
        //7.创建操作二进制文件的字节输出流对象
        DataOutputStream dos=new DataOutputStream(fos);
        //8.写入到目标文件
        dos.write(bt);
        //9.关闭流（先开后关）
        dos.close();
        fos.close();
        dis.close();
        fis.close();
        System.out.println("copy success");
        
    }

}

--序列化与反序列化

package com.test;

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private int sid;
    private String sname;
    private transient String password;

    public Student() {
    }

    public Student(int sid, String sname, String password) {
        this.sid = sid;
        this.sname = sname;
        this.password = password;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String toString() {
        return "Student [password=" + password + ", sid=" + sid + ", sname="
                + sname + "]";
    }
}

package com.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

/**
 * 对象序列化
 * 作用：将对象写入到本地（对象输出流）
 * @author pc
 *
 */
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.指定操作路径
        File file=new File("D://student.txt");
        //序列化
        objWrite(file);
        //反序列化
        objRead(file);
        
    }
    /**
     * 对象反序列化
     * @param file
     * @throws IOException 
     * @throws ClassNotFoundException 
     */
    private static void objRead(File file) throws IOException, ClassNotFoundException {
        //2.创建字节输入流对象，并指定file路径
        InputStream fis=new FileInputStream(file);
        //3.创建反序列对象，（对象的输入流）
        ObjectInput ois=new ObjectInputStream(fis);
        //4.使用反序列进行读取本地对象
        Student stu=(Student) ois.readObject();
        System.out.println(stu);
    }
    /**
     * 对象序列化
     * 作用：将对象写入到本地（对象输出流）
     * @param file
     * @throws IOException
     */
    public static void objWrite(File file) throws IOException{
        //2.创建字节输出流对象并指定路径
        OutputStream fos=new FileOutputStream(file);
        
        //3.创建序列化对象（对象输出流）
        ObjectOutput oos=new ObjectOutputStream(fos);
        
        //4.创建写入对象
        Student stu=new Student(1, "holly","123");
        
        //5.使用序列化将对象写入本地
        oos.writeObject(stu);
        System.out.println("序列化完成");
    }

}