java io流02 字节流

 

1. 字节流介绍

　　字节流不仅可以操作字符还可以操作其他媒体文件。

　　InputStream类和OutputStream是字节流输入流，输出流的抽象类，是所有字节输入流，输出流的父类。

 

2. FileInputStream

　　FileInputStream是文件输入流，继承于InputStream，可以从文件中获取输入字节

　　FileInputStream的函数接口

public FileInputStream(File file)     //构造方法，创建一个“File对象”的文件输入流

public FileInputStream(FileDescriptor fdObj)    //构造方法，创建一个“文件描述符”对象的文件输入流

public FileInputStream(String name)    //构造方法，创建指定文件名的文件输入流

public void close()    //关闭文件输入流

public int read()    //读取一个字节的数据

public int read(byte b[])    //读取指定字节长度的数据

public long skip(long n)    //跳过n长度字节数据

　　

　　FileInputStream示例

public class FileInputStreamTest01{
    public static void main(String[] args){
        FileInputStream fis = null;
        try{
            //fis = new FileInputStream("D:\\JavaPractice\\Temp.txt");    //使用单斜杠表示转义，使用双斜杠取消转义
            fis = new FileInputStream("D:/JavaPractice/Temp.txt");    //也可以使用反斜杠
            //int readData = fis.read();    //一次读一个字节数据
            //System.out.println(readData);    //直接数据返回字符对应ASCII码
            int readData = 0;
            while((readData = fis.read()) != -1){     //循环读数据，当返回值是-1时，表示已经读取完了
                System.out.println(readData);
            }
                
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fis != null){
                try{
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

　　

　　使用int read(byte[] bytes)读取bytes数组长度的字节，返回读取的字节数量

public static void main(String[] args){
        FileInputStream fis = null;
        try{
            //fis = new FileInputStream("chapter/src/javase/io/Temp");   //也可以使用相对路径，项目路径作为根路径，文件路径以项目路径开始
            fis = new FileInputStream("D:\\JavaPractice\\Temp.txt");
            byte[] bytes = new byte[4];
            //int readData = fis.read(bytes);
            //System.out.println(new String(bytes));    //可以使用字符串构造方法把bytes数组转换为字符串  
            
            int readData = 0;
            while((readData = fis.read(bytes)) != -1){
                System.out.println(new String(bytes,0,readData));    //转换指定readData长度的字符串
            }
                
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fis != null){
                try{
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

 

　　available()和skip()

public static void main(String[] args){
        FileInputStream fis = null;
        try{
            fis = new FileInputStream("D:\\JavaPractice\\Temp.txt");
            System.out.println("总的字节数量" + fis.available());
            //byte[] bytes = new byte[fis.available()];
            //int readData = fis.read(bytes);
            //System.out.println(new String(bytes,0,readData));
            
            fis.skip(3);    //跳过3个字节
            System.out.println(fis.read());    //100 从第4个开始读
                
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fis != null){
                try{
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

 

3. FileOutputStream

　　FileOutputStream是文件输出流，继承于OutputStream，可以把数据写入文件。

　　FileOutputStream的函数接口

public FileOutputStream(String name)    //创建指定文件名的文件输出流

public FileOutputStream(String name, boolean append)    //创建指定文件名的文件输出流，指定追加模式

public FileOutputStream(File file)    //创建指定文件对象的文件输出流

public FileOutputStream(File file, boolean append)    //创建指定文件对象的文件输出流，指定追加模式

FileOutputStream(FileDescriptor fdObj)    //创建指定文件描述符的文件输出流

public void close()    //关闭文件输出流

public void write(byte b[], int off, int len)    //写入len长度的数据

 

　　FileOutputStream实例

public static void main(String[] args){
        FileOutputStream fos= null;
        try{
        //    fos = new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp.txt");  //如果文件不存在则创建文件写入，如果文件存在则清空文件重新写入
            fos = new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp.txt",true);   //指定追加模式，如果文件不存在则创建文件写入，如果文件存在给源文件追加内容
            String str = "FileOutputStream文件输出流";
            byte[] bytes = str.getBytes();
            fos.write(bytes);
            fos.flush();
                
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fos != null){
                try{
                    fos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

 

　　使用FileInputStream和FileOutputStream进行文件拷贝，可以拷贝任意流媒体文件

public static void main(String[] args){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try{
            fis = new FileInputStream("D:\\BaiduNetdiskDownload\\008-JDBC\\mysql-connector-java-8.0.15.zip");
            fos = new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\mysql-connector-java-8.0.15.zip");
            byte[] bytes = new byte[1024*1024];    //每次读取1M
            int readData = 0;
            while((readData = fis.read(bytes)) != -1){
                fos.write(bytes,0,readData);
            }
            fos.flush();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fos != null){
                try{
                    fos.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try{
                    fis.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }

 

4. 数据专属流DataOutputStream

　　会以特有的方式写入数据，除非知道写入顺序，否则不能打开，通常和DataInputStream一起使用。

　　DataOutputStream函数接口

public DataOutputStream(OutputStream out)    //构造方法，参数传入输出字节流

public final void writeByte(int v)    //将byte类型数值写入

public final void writeShort(int v)    //将short类型数值写入

public final void writeInt(int v)    //将Int类型数值写入

public final void writeLong(long v)    //将long类型数值写入

public final void writeFloat(float v)    //将float类型数值写入

public final void writeDouble(double v)    //将double类型数值写入

public final void writeBoolean(boolean v)    //将boolean类写入

public final void writeChar(int v)    //将Char类型写入

 

　　DataOutputSteam实例

public class DataOutputStreamTest01{
    public static void main(String[] args) throws Exception{
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp06.txt"));
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 500L;
        float f = 3.14f;
        double d = 5.23;
        boolean bl = true;
        char c = 'a';
        dos.writeByte(b);
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(bl);
        dos.writeChar(c);
        dos.flush();
        dos.close();
        
    }
}

 

5. 数据专属流DataInputStream

　　DataInputStream可以读取DataOutputStream写入的文件，需要知道写入的顺序。应用程序可以使用数据输出流写入后由数据输入流读取数据。

　　DataInputStream函数接口

public DataInputStream(InputStream in)    //构造方法，参数传入字节流

public final byte readByte()    //读取byte类型

public final short readShort()    //读取short类型

public final int readInt()    //读取Int类型

public final long readLong()    //读取long类型

public final float readFloat()    //读取Float类型

public final double readDouble()    //读取double类型

public final boolean readBoolean()    //读取Boolean类型

public final char readChar()    //读取Char类型

 

　　DataInputStream实例

public class DataInputStreamTest01{
    public static void main(String[] args) throws Exception{
        DataInputStream dis = new DataInputStream(new FileInputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp06.txt"));
        
        System.out.println(dis.readByte());
        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());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readChar());
        
    }
}

 

6. 标准输出流PrintStream

　　能为其他输出流添加功能，使它们能方便的打印各种数据值的表现形式

　　PrintStream函数接口

public PrintStream(OutputStream out)    //构造方法，参数传入字节流

 

　　PrintStream实例

public class PrintStreamTest01{
    public static void main(String[] args) throws Exception{
        System.out.println("hello world");
        PrintStream ps = new PrintStream(new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp07.txt"));
        System.setOut(ps);    //可以指定输出到流中
        System.out.println("hello python");
        System.out.println("hello java");
    }
}

 

　　PrintStream可以用于打印日志中

public class Logger{
    public static void main(String[] args){
        new Log().log("第一次调用");
        new Log().log("第二次调用");
        new Log().log("第三次调用");
        new Log().log("第四次调用");
    }
}

class Log{
    public void log(String str){
        try{
            PrintStream ps = new PrintStream(new FileOutputStream("C:\\Users\\THINK\\Desktop\\JavaTest\\Temp08.txt",true));
            System.setOut(ps);
            Date newDate = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss SSS");
            String dateStr = sdf.format(newDate);
            System.out.println(dateStr + ":" + str);
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        
    }
}