字节流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. Java 中浮点数---------BigDecimal和double(初探)

    为什么要使用 bigdecimal? 借用<Effactive Java>这本书中的话,float和double类型的主要设计目标是为了科学计算和工程计算.他们执行二进制浮点运算,这是为了 ...

  2. css3颜色渐变

    从上到下的线性渐变: #grad {  background: -webkit-linear-gradient(red, blue); /* Safari 5.1 - 6.0 */  backgrou ...

  3. PHPDoc/PHPDocumentor生成API文档

    PHPDocumentor是一个用PHP写的强大的文档自动生成工具,对于有规范注释的php程序,能够快速生成具有结构清晰.相互参照.索引等功能的API文档.旧版本是PHPDoc,PHPDoc是PEAR ...

  4. 一句话解释jquery中offset、pageX, pageY、position、scrollTop, scrollLeft的区别

    offset   元素相对文档的偏移 pageX, pageY 事件(鼠标)相对文档的偏移 注意:文档是指document, 而不是当前窗口,是包含了滚动位置的,即滚动条的位置对这些值是不产生影响的 ...

  5. Microsoft云备份解决方案Azure Backup的常见配置问题

    这篇博客文章有助于解决 Microsoft云备份解决方案(即 Azure Backup)的常见配置问题.客户通常会在安装或注册 Azure Backup时遇到这些问题.以下是有关如何诊断和解决问题的建 ...

  6. ubuntu下PHP支持cURL

    公司项目需要,注册需要验证手机号码,其中需要LAMP支持cURL.由于事先安装平台的时候,并没有注意到这一点,所以编译PHP5的时候,并没有使用参数--with-curl.后来需要的时候,查一些参考方 ...

  7. SQL Server数据库的操作流程和连接的简单介绍

    学习ADO,免不了要跟数据库打交道,对于初学者来说,如果不整理一下整个流程,那么可能会出现很多的问题,下面简单的介绍数据库的操作流程. 1.     我们最终操作的对像是数据表,在操作数据表之前我们先 ...

  8. iOS开发RunTime之函数调用

    文章来自小笨狼的iOS博客,一直认为csdn的博客UI不太好看,看博客不太爽.所以自己搭建了一个博客. 欢迎各位去链接中看我的博客.也欢迎大家加QQ群讨论iOS技术问题 经过两个多月的面试,工作最终尘 ...

  9. MPP 一、Greenplum 集群安装

    Installating and Initializing a Greenplum Database System... 1 安装说明 1.1 环境说明 名称 版本 下载地址 虚拟机 Oracle V ...

  10. Flex中一些属性总结

    Flex中一些属性总结 1.buttonMode = "true"  鼠标变成手形 2.useHandCursor = "true" 鼠标变成手形