字节流File读写操作

字符流:

FileReader  FileWriter

BufferedReader  BufferedWrtier

字节流:

FileInputStream  FileOutputStream

BufferedInputStream  BufferedOutputStream

需求:想要操作图片数据,这时就要用到字节流。

import java.io.*;

class FileStream
{
    pubilc static void main(String[] args)
    {

    }

     public static void readFile_3()throws IOException     {        FileInputStream fis = new FileInputStream("fos.txt");

        //int num = fis.available();

        byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区,不用再循环了。此方法要慎用。可能会发生内存溢出。

        fis.read(buf);        //System.out.println("num"+num);

        System.out.println(new String(buf));

        fis.close();     }

     public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[1024];//建议定义1024的整数倍。

        int len = 0;

        while((ch=len.read(buf))!=-1)
        {
            System.out println(new String(buf,0,len));
        }
        fis.close();
    }

    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        int ch =  0;

        while((ch=fis.read())!=-1)
        {
            System.out println((char)ch);
        }
        fis.close();
    }

    pubilc static void writerFile()throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");

        fos.writer("abcde".getBytes());

        fos.close();//不需刷新,但必须关闭资源。
    }
}

拷贝图片

复制一个图片

思路:

1,用字节读取流对象和图片关联。

2,用字节写入流对象创建一个图片文件,用于存储获取到的图片数据。

3,通过循环读写,完成数据的存储。

4,关闭资源。

import java.io.*;

class CopyPic
{
    pubilc static void mian(String[] args)
    {
        FileOutputStream fos = null;
        FileInputStream fps = null;
        try
        {            //写
            fos = new FileOutputStream("c:\\2.bmp");            //读
            fps = new FileInputStream("c:\\1.bmp");

            byte[] buf = new byte[1024];

            int len = 0;

            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch(IOException e)
        {
            throws new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
             catch(IOException e)
            {
                throws new RuntimeException("读取关闭失败");
            }
             try
            {
                if(fos!=null)
                    fis.close();
            }
             catch(IOException e)
            {
                throws new RuntimeException("写入关闭失败");
            }
        }
    }
}

字节流的缓冲区

演示MP3的复制,通过缓冲区。

import java.io.*;

class CopyMp3
{
    public static void mian(String[] args)throws IOException
    {
        long start = System.currentTimeMillis();
        Copy_1();
        long end = System.currentTimeMillis();

        System.out.println((end-start)+"毫秒");
    }

    //通过字节流的缓冲区完成复制。
    public static void Copy_1()throws IOException
    {
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));

        BufferedOnputStream bufos = new BufferedOnputStream(new FileOnputStream("c:\\1.mp3"));

        int by = 0;

        while((by=bufis.read())!=-1)
        {
            bufos.write(by);
        }

        bufos.close();
        bufis.close();
    }
}

  

自定义字节流的缓冲区-read和write的特点

import java.io.*;

class MyBufferedInputStream;
{
    private InputStream in;

    private byte[] buf = new byte[1024*4];

    private int pos = 0,count = 0; 

    MyBufferedInputStream(InputStream in)
    {
        this.in = in;
    }

    //一次读一个字节,从缓冲区(字节数组)获取。
    public int myRead()throw IOException
    {
        //通过int对象读取硬盘上数据,并存储buf中。
        if(count==0)
        {
            count = in.read(buf);

            if(count<0);
                return -1;

            byte b = buf[pos];

            count--;

            pos++;

            return b&255;
        }
        else if(count>0)
        {
            byte b = buf[pos];

             count--;

             pos++;

            return b&Oxff;
        }

        return -1;
    }

    public void myClose()throw IOException
    {
        in.close();
    }
}

注意:

read方法返回的是int类型,但还是-1。是-1的原因是因为在8个1面前补的是1所导致的。那么我只要在前面补0,既可以保留原字节数据不变,又可以避免-1的出现。

怎么补0呢?在返回数据时&上255/Oxff(255的十六进制表现形式)。

read的方法将数据进行提升(是为了避免-1的发生),write方法将数据强制转换再返回(只写最低8位,有效数据)。

读取键盘录入

System.out:对应的是标准输出设备,控制台。

System.in:对应的是标准的输入设备:键盘。

import java.io.*;

class ReadIn
{
    public static void main(String[] args)throws IOException
    {
        InputStream in = System.in;

        int ch = in.read();//此方法是一个阻塞式方法。

        System.out.println(ch);//被提升后,打印出来的是数字。

        int ch = in.read();

        System.out.println(ch);//回车符在编码边里面'\r'=13,'\n'=10
    }
}

需求:通过键盘录入数据。当录入一行数据后,就将该行数据进行打印,如果录入的数据是over,那么停止录入。

import java.io.*;

class ReadIn
{
    public static void main(String[] args)throws IOException
    {
        InputStream in = Ststem.in;

        StringBuilder sb = new StringBuilder();

        while(true)
        {
            int ch = in.read();

            if(ch=='\r')
                cuntinue;
            if(ch=='\n')
            {
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());//打印一次就要清空缓冲区一次。
            }
            else
            {
                sb.append((char)ch);
            }
        }
    }
}

读取转换流

通过刚才的键盘录入一行数据并打印其大写,发现其实就是都一行数据的原理,也就是readLine方法。能不能直接使用readLine方法开完成键盘录入的一行数据读取呢?

readLine方法是字符流BufferedReader类中的方法。而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢?

import java.io.*;

class TransStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //获取键盘录入对象。
        InputStream in = System.in;

        //将字节流对象转换成字符流对象,使用转换流,InputStreamReader
        InputStreamReader isr = new InputStreamReader(in);

        //为了提高效率,将字符串进行缓冲区技术高效操作,使用BuferedReader.
        BufferedReader bufr = new BufferedReader(isr);

        String line = null;

        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            System.out.println(line.toUpperCase());
        }

        bufr.close();//可以省略不写。最终都是System.in在操作。
    }
}

写入转换流

System.out返回的是PrintStream,是OutputStream的子类。

import java.io.*;

class TransStreamDemo
{
    public static void main(String[] args)throws IOException
    {

        InputStream in = System.in;

        InputStreamReader isr = new InputStreamReader(in);

        BufferedReader bufr = new BufferedReader(isr);

        OutputStream os = System.out;

        OutputStreamWriter osw = new OutputStreamWriter(os);

        BufferedWriter bufw = new BufferedWriter(osw);

        String line = null;

        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;

            bufw.writer(line.toUpperCase());
            bufw.newline();
            bufw.flush();

            //此方法不跨平台:osw.write(line.toUpperCase()+"'\r\n");
            //osw.flush();

            //System.out.println(line.toUpperCase());
        }

        bufr.close();//可以省略不写。最终都是System.in在操作。
    }
}

代码进行优化后:

import java.io.*;

class TransStreamDemo
{
    public static void main(String[] args)throws IOException
    {   //键盘录入的最常见写法。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

        String line = null;

        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;

            bufw.writer(line.toUpperCase());
            bufw.newline();
            bufw.flush();
        }
    }
}

流操作规律-1

1,

源:键盘录入。

目的:控制台。

2,需求:想把键盘录入的数据存储到一个文件中。

源:键盘。

目的:文件。

3,需求:想要将一个文件的数据打印在控制台上。

源:文件。

目的:控制台。

源:

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

目的:

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

流操作的基本规律:最痛苦的是流对象有很多,不知道用哪一个。

通过三个明确来完成。

1,明确源和目的。

  源:输入流。InputStream  Reader

  目的:输出流。OutputStream  Writer

2,操作的数据是否是纯文本。

  是:字符流。

  不是:字节流。

3,当体系明确后,再明确要使用哪个具体的对象。

  通过设备来进行区分:

  源设备:内存,硬盘,键盘。

  目的设备:内存,硬盘,控制台。

需求:

1,将一个文本文件中数据存储到另一个文件中,复制文件。

  源:因为是源,所以使用读取流。InputStream  Reader

  是不是操作文本文件?是。这是就可以选择Reader,这样体系就明确了。

  接下来明确要使用该体系中的哪个对象。

  明确设备:硬盘,上的一个文件。

  Reader体系中可以操作文件对象的是FileReader。

  是否需要提高效率:是!加入Reader体系中缓冲区BufferedReader。

  FileReader fr = new FielReader("a.txt");

  BufferedReader bufr = new BufferedReader(fr);

  目的:OutputStream  Writer

  是否是纯文本呢? 是。用Writer.

  设备:硬盘。一个文件。

  Writer体系中可以操作文件的对象是FileWriter。

  是否需要提高效率:是!加入Writer体系中缓冲区BufferedWriter。

  FileWriter fw = new FileWriter("b,txt");

  BufferedWriter bufw = new BufferedWriter(fw);

练习:将一个图片文件中数据存储到另一个文件中,复制文件。要按照以上格式自己完成三个明确。

流操作规律-2

2,需求:将键盘录入的数据保存到一个文件中。

  这个需求中有源和目的都存在。那么分别分析。

  源:InputStream  Reader

  是不是纯文本?是。Reader

  设备:键盘。对应的对象是System.in。

  不是选择Reader吗?System.in对应的不是字节流吗?

  为了操作键盘的文本数据方便,转成字符流按照字符串操作是最方便的。

  所以既然明确了Reader,那么就将System.in转换成Reader。

  用了Reader体系中转换流,InputStreamReader

  InputStreamReader isr = new InputStreamReader(System.in);

  需要提高效率吗?需要。BufferedReader

  BufferedReader bufr = new BufferedReader(isr);

  目的:OutputStream  Writer

  是否是纯文本?是!Writer

  设备:硬盘。一个文件。使用FileWriter.

  FileWriter fw = new FileWriter("c.txt");

  需要提高效率吗?需要。

  BufferedWriter bufw = new BufferedWriter(fw);


  扩展一下,想要把录入的数据按照指定的编码表(utf-8),将数据存到文件中。

  

  目的:OutputStream  Writer

  是否是纯文本?是!Writer

  设备:硬盘。一个文件。使用FileWriter.(使用的是默认的编码表GBK)

  但是存储时需要加入指定编码表UTF-8,而指定的编码表只有转换流可以指定。所以要使用的对象是OutputStreamWriter。

  而该转换流对象要接收一个字节输出流,而且还可以操作文件的字节输出流。FileOutputStream。

  OutputStreamWriter osw = new OutputStreamWriter(new FIleOutputStream("d.txt"),"UTF-8");

  需要高效吗?需要。

  BufferedWriter bufw = new BufferedWriter(osw);

  所以,记住:转换流什么时候使用。字符和字节之间的桥梁,通常,涉及到字符编码转换时,需要用到转换流。

练习:将一个文本数据打印在控制台上,要按照以上格式自己完成三个明确。

  

改变标准输入输出设备

System里提供两个静态方法来改变标准的的输入输出设备。

1,static void setIn(InputStream in):重新分配“标准”输入流。//System.in(new FileInputStream("PersonDemo.java");

2,static void setOut(PrintStream out):重新分配“标准”输出流。//System.out(new PrintStream("zz.txt");

异常的日志信息

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

class ExceptionInfo
{
    public static void main(String[] args)
    {
        try
        {
            int[] arr = new int[2];
            System.out.println(arr[3]);
        }
        catch(Exceptiom e)
        {
            try
            {
                Date d = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
                String s = sdf.format(d);

                PrintStream ps = new PrintStream("exception.log");
                //ps.write(d.toString().getBytes());
                ps.println(d.toString());
                System.setOut(ps);
            }
            catch(IOException ex)
            {
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);//将日志信息存到指定文件
        }
    }
}

LOG4G:网络工具包,专门用于建立Java的日志文件信息。

系统信息

Properties类中的方法:

1,void list(PrintStream out):将属性列表输出到指定的输出流。

2,void list(PrintWriter out):将属性列表输出到指定的输出流。

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

class SystemInfo
{
    public static void main(String[] args)
    {
        Properties prop = System.getProperties();

        //System.out.println(prop);
        prop.list(new PrintStream("sysinfo.txt");
    }
}

,,,,。。。。。。。。。。。。。。。。。。。。。。。。。

黑马程序员_JavaIO流(三)的更多相关文章

  1. 黑马程序员_JavaIO流(四)

    File概述 File类 用来将文件或者文件夹封装成对象. 方便对文件与文件夹的属性信息进行操作. File对象可以作为参数传递给流的构造函数. 了解File类中的常用方法. 字段:static St ...

  2. 黑马程序员_JavaIO流(二)

    字符流的缓冲区 缓冲区的出现提高了对数据的读写效率. 对应类: BufferedWriter BufferedReader 缓冲区要结合流才可以使用. 在流的基础上对流的功能进行了增强. Buffer ...

  3. 黑马程序员_JavaIO流(一)

    IO(Input Output)流 概述: IO流(数据流)用来处理设备之间的数据传输. Java对数据的操作是通过流的方式. Java用于操作流的对象都在IO包中. 流按操作数据分为两种:字节流与字 ...

  4. 黑马程序员——OC基础 三种特性之封装

    Java培训.Android培训.iOS培训..Net培训.期待与您交流! (以下内容是对黑马苹果入学视频的个人知识点总结) 三种特性之一封装 (一)set方法和get方法 1)  set方法 1&g ...

  5. 黑马程序员——【Java高新技术】——代理

    ---------- android培训.java培训.期待与您交流! ---------- 一.“代理概述”及“AOP概念” (一)代理概述 1.问题:要为已存在的多个具有相同接口的目标类的各个方法 ...

  6. 黑马程序员:Java基础总结----网络编程

    黑马程序员:Java基础总结 网络编程   ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! 网络编程 网络通讯要素 . IP地址 . 网络中设备的标识 . 不易记忆,可用 ...

  7. 黑马程序员:3分钟带你读懂C/C++学习路线

    随着互联网及互联网+深入蓬勃的发展,经过40余年的时间洗礼,C/C++俨然已成为一门贵族语言,出色的性能使之成为高级语言中的性能王者.而在今天,它又扮演着什么样重要的角色呢?请往下看: 后端服务器,移 ...

  8. 【黑马18期Java毕业生】黑马程序员Java全套资料+视频+工具

        Java学习路线图引言:        黑马程序员:深知广大爱好Java的人学习是多么困难,没视频没资源,上网花钱还老被骗. 为此我们历时一个月整理这套Java学习路线图,不管你是不懂电脑的小 ...

  9. 黑马程序员+SQL基础(上)

    黑马程序员+SQL基础 ---------------<a href="http://edu.csdn.net"target="blank">ASP ...

随机推荐

  1. 9、委托、事件、Lambda

    开始 关于委托,肯定是要有问题的. 第一个问题,委托用来干什么? 看.net中的表述:在.net平台下,委托类型用来定义和相应应用程序中的回调.(回调?处理内存中两个实体双向通信的一种技术.)   第 ...

  2. Android 学习笔记之一 “Unable to establish loopback connection”

    今天碰到一个错误:Unable to establish loopback connection,在网上找各种方法都解决不了,后来看一个帖子说是要关闭系统防火墙,尝试了下还是不行.最后是进任务管理器杀 ...

  3. Odoo Email Template Problem

    Odoo 8.0 的邮件模板是运行自jiajin2沙盒中的阉割版mako,像自定义及 <%%>等功能都无法正常使用. 且for-loop %for %endfor不能嵌套在table中使用 ...

  4. 如果你修改了ashx.cs的命名空间

    如果你修改了ashx.cs的命名空间,记得要同时修改ashx的WebHandler的Class. 在解决方案资源管理器中右键,查看标记

  5. 【XLL 文档翻译】【第3部分】必要的和有用的 C API XLM 函数

    本节中将介绍几个对于 DLL 和 XLL 开发人员来说十分重要的回调函数,xlfRegister 函数是可用于注册函数,使得 Excel 可以直接访问 DLL 和 XLl 中的函数. xlfUnreg ...

  6. Bootstrap页面布局17 - BS选项卡

    代码结构: <div class='container-fluid'> <h2 class='page-header'>Bootstrap 选项卡</h2> < ...

  7. [笔记]PHP文件系统处理

    PHP文件系统处理 ***所有的文件处理都是使用系统函数完成的. ***php文件处理 是 基于linux/unix系统为模型的, 在linux下完全没问题 在windows下有一些 有差别. ### ...

  8. 如何修改tomcat的端口

    <Connector port="8485" protocol="HTTP/1.1" connectionTimeout="20000" ...

  9. 冲突--ListView与ScrollView冲突的4种解决方案

    众所周知ListView与ScrollView都具有滚动能力,对于这样的View控件,当ScrollView与ListView相互嵌套会成为一种问题: 问题一:ScrollView与ListView嵌 ...

  10. JavaWeb之Servlet:请求 与 响应

    1 引入 浏览器和服务器的种类都有很多,要在它们之间通讯,必定要遵循一定的准则,而http协议就是这样的一个"准则". Http协议:规定了 浏览器 和 服务器 数据传输的一种格式 ...