黑马程序员——IO流字节流

最新推荐文章于 2020-08-15 08:50:23 发布
最新推荐文章于 2020-08-15 08:50:23 发布
阅读量466 收藏
点赞数
分类专栏： 黑马程序员Java基础 文章标签： 黑马程序员 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W49408322/article/details/38701359
版权
------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


 

字节流读取流

字节流基类

InputStream

OutputStream

/*

写入文件

*/

import java.io.OutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Test{

    public static void main(String...args)throws IOException{

        OutputStream os = newFileOutputStream("1111.Java");

        os.write("戒风".getBytes());

        os.close();

        System.out.println("ok!!!!");

    }

}

/*

第一种读取文件的方法。

对于操作文本文件不支持使用此做法。

*/

import java.io.InputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        InputStream is =new FileInputStream("1111.java");

        for(int by = 0;(by=is.read())!=-1;){

            System.out.print(by);

        }

        is.close();

        System.out.println("ok!!!!");

    }

}

/*

第二种读取文件的方法。对于操作文本文件支持使用此做法。

*/

import java.io.InputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        InputStream is = newFileInputStream("C:\\1.Java");

        byte [] buf = new byte[1024];

        for(int len = 0;(len=is.read(buf))!=-1;){

            System.out.print(new String(buf,0,len));

        }

        is.close();

        System.out.println("ok!!!!");

    }

}

InputStream

int

available()
返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。

/*

第三种方式，如果内存太大会报错。

*/

import java.io.InputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        InputStream is =new FileInputStream("C:\\1.Java");

        byte[] buf =new byte[is.available()];

        is.read(buf);

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

        is.close();

    }

}

IO流(拷贝图片)

/*

思路：
1、用字节读取流对象和图片关联
2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据
3、通过循环读写，完成数据的存储
4、关闭资源

*/

import java.io.InputStream;

import java.io.FileInputStream;

import java.io.OutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Test{

    public static void main(String...args){

        InputStream is =null;

        OutputStream os =null;

        try{

            is =new FileInputStream("C:\\1.jpg");

            os =new FileOutputStream("D:\\1.jpg");

            byte []buf =new byte[1024];

            for(int len=0;(len=is.read(buf))!=-1;){

                os.write(buf,0,len);

            }

        }

        catch(IOException e){

            System.out.println("读写错误");

        }

        finally{

            try{

                if(is!=null)

                is.close();

            }

            catch(IOException e){

                System.out.println("读取流关闭失败");

            }

            finally{

                try{

                    if(os!=null)

                    os.close();

                }

                catch(IOException e){

                    System.out.println("写入流关闭失败");

                }

            }

            System.out.println("ok!!!");

       }

    }

}

字节流缓冲区

BufferedInputStream

BufferedOutputStream

import java.io.IOException;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

public class Test{

    public static void main(String...args)throws IOException{

        BufferedInputStream is = newBufferedInputStream

        (new FileInputStream("C:\\1.mp3"));

        BufferedOutputStream os = newBufferedOutputStream

        (new FileOutputStream("D:\\1.mp3"));

        for(int by = 0;(by=is.read())!=-1;){

            os.write(by);

        }

        is.close();

        os.close();

        System.out.println("ok!!!");

    }

}

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

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

class MyBufferedInputStream{

    private InputStream in;

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

    private int pos;

    private int count;

    MyBufferedInputStream(InputStream in){

        this.in=in;

    }

    public int myRead()throws IOException{

        if(count==0){

            count=in.read(buf);

            if(count<0)

            return -1;

            pos=0;

            byte b = buf[pos];

            pos++;

            count--;

            return b&255;

        }

        else if(count>0){

            byte b = buf[pos];

            pos++;

            count--;

            return b&0xff;

        }

        return -1;

    }

    public void myClose()throws IOException{

        in.close();

    }

}

public class Test{

    public static void main(String...args) throws IOException{

        long start = System.currentTimeMillis();

        copy();

        long end = System.currentTimeMillis();

        System.out.println(end-start);

    }

    public static void copy()throws IOException{

        MyBufferedInputStream bufis = newMyBufferedInputStream

        (new FileInputStream("C:\\1.avi"));

        BufferedOutputStream bufos = newBufferedOutputStream

        (new FileOutputStream("C:\\2.avi"));

        for(int len=0;(len=bufis.myRead())!=-1;){

            bufos.write(len);

        }

        bufis.myClose();

        bufos.close();

    }

}

字节流键盘读取

IO流(读取键盘录入)

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

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

/*
需求，通过键盘录入数据。
当录入一行数据后，就将改行数据进行打印，如果录入数据是over，那么停止录入
*/

import java.io.IOException;

import java.io.InputStream;

public class Test{

    public static void main(String...agrs)throws IOException{

        InputStream in =System.in;

        StringBuilder sb = newStringBuilder();

        while(true){

            int ch =in.read();

            if(ch=='\r')

            continue;

            if(ch=='\n'){

                String s=sb.toString();

                if("over".equals(s))

                break;

                System.out.println(s);

                sb.delete(0,sb.length());

            }

            else{

                sb.append((char)ch);

            }

        }

    }

}

IO流(读取转换流)

通过键盘录入一行数据，并打印其大写，发现其实就是读一行数据的原理，也就是readLine方法来完成键盘录入的一行数据的读取呢？

/*

需求，通过键盘录入数据。

当录入一行数据后，就将该行数据进行打印，如果录入数据是over，那么停止录入

*/

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.BufferedReader;

import java.io.IOException;

public class Test{

    public static void main(String...args)throws IOException{

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

        for(String line =null;(line=bufr.readLine())!=null;) {

            if("over".equals(line))

            break;

            System.out.println(line);

        }

        bufr.close();

    }

}

IO流(写入转换流)

/*

需求，通过键盘录入数据。

当录入一行数据后，就将该行数据进行打印，如果录入数据是over，那么停止录入

*/

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args)throws IOException{

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

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

        for(String line = null;(line=bufr.readLine())!=null;){

            if("over".equals(line))

            break;

            bufw.write(line);

            bufw.newLine();

            bufw.flush();

        }

        bufr.close();

        bufw.close();

    }

}

IO流(流操作规律)

1、 源：键盘

目的：控制台

/*
需求，通过键盘录入数据。
如果录入数据是over，那么停止录入,否则就打印*/

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.IOException;

public class Test{

    public static void main(String...args)throws IOException{

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

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

        for(String line = null;(line=bufr.readLine())!=null;){

            if("over".equals(line))

            break;

            bufw.write(line.toUpperCase());

            bufw.newLine();

            bufw.flush();

        }

        bufr.close();

        bufw.close();

    }

}

2、 源：键盘

目的：文件

/*

需求：将键盘录入的数据输出到一个文本文件中，

如果录入数据是over，那么停止录入,否则就输入到文件中

*/

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.IOException;

import java.io.FileOutputStream;

public class Test{

    public static void main(String...args)throws IOException{

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

        BufferedWriter bufw =new BufferedWriter(new OutputStreamWriter(new FileOutputStream("C:\\1.Java")));

        for(String line = null;(line=bufr.readLine())!=null;){

            if("over".equals(line))

            break;

            bufw.write(line);

            bufw.newLine();

            bufw.flush();

        }

        bufr.close();

        bufw.close();

    }

}

3、 源：文件

目的：控制台

/*

需求：想要讲一个文件的数据打印在控制而台上

*/

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.FileInputStream;

public class Test{

    public static void main(String...args)throws IOException{

        BufferedReader bufr =new BufferedReader(new InputStreamReader

        (new FileInputStream("C:\\1.Java")));

        BufferedWriter bufw =new BufferedWriter

        (new OutputStreamWriter(System.out));

        for(String line =null;(line=bufr.readLine())!=null;){

            bufw.write(line);

            bufw.newLine();

            bufw.flush();

        }

        bufr.close();

        bufw.close();

    }

}

面向对象IO简单总结下

流操作的基本规律：最痛苦的就是流对象有很多，不知道该用那一个。

通过明确来完成。

(1)、明确源和目的

源：输入流 InputStream ，Reader

目的：输出流OutputStream ，Writer

(2)、操作的数据是否是纯文本

是：字符流 Reader，Writer

不是：字节流 InputStream ， OutputStream

(3)、当体系明确后，再明确要使用那个具体的对象

通过设备来进行区分：

源设备：内存 硬盘 键盘

目的设备：内存 硬盘 控制台

/*

需求：将一个文本文件中数据存储到另一个文件中。复制文件

*/

源：因为是源，所以使用读取流。InputStreamReader

是否是纯文本文件：是，所以使用 Reader。

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

明确设备，硬盘，一个文件。

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

是否需要提高效率？

BufferedReader

目的：因为是目的，所以使用写入流。OutputStream Writer

是否是纯文本文件：是，所以使用 Writer。

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

明确目的，硬盘，一个文件。

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

是否需要提高效率？需要。BufferedWriter

/*

需求：将键盘录入的数据保存到一个文件中

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

*/

源：因为是源，所以使用读取流。InputStreamReader

是否是纯文本文件：是，所以使用 Reader。

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

明确设备，键盘。对应的对象是System.in。

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

为了操作键盘的文字数据方便，字节流可以转换成字符流，按照字符串操作最方便。

既然明确了Reader 就将 System.in 转换成Reader

用到了Reader 体系中的转换流，InputSteamReader

需要提高效率吗？需要，BufferedReader

目的：因为是目的，所以使用写入流。OutputStreamWriter

是否是纯文本文件：是，所以使用 Writer。

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

明确目的，硬盘，一个文件。

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

是否需要提高效率？需要。BufferedWriter

扩展

想要把录入的数据按照指定的编码表（UTF-8），将数据存到文件中，使用转换流，里面可以指定编码。

目的：OutputStream Writer

是否是纯文本？是，Writer

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

明确目的，硬盘，一个文件。

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

但是存储时，需要加入指定的编码表，而指定的编码表，只有转换流可以指定。

所以要使用的对象是OutputStreamWriter.

而该转换流对象要接收一个字节输出流。

而且还可以操作文件的字节输出流，FileOutputStream

是否需要提高效率？需要。BufferedWriter

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

IO流(改变标准输入输出设备)

System

static void

setIn(InputStream in)
重新分配“标准”输入流。

static void

setOut(PrintStream out)
重新分配“标准”输出流。

IO流(异常的日志信息)

import java.util.Date;

import java.text.SimpleDateFormat;

import java.io.PrintStream;

import java.io.IOException;

public class Test{

    public static void main(String...args) {

        try{

            int arr[] = new int[2];

            System.out.println(arr[3]);

        }catch(Exception e){

            try{

                Date d = new Date();

                SimpleDateFormat sdf = newSimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");

                String date = sdf.format(d);

                PrintStream ps = new PrintStream("c:\\execption.txt");

                ps.println(date);

                System.setOut(ps);

            }

            catch(IOException ex){

                throw new RuntimeException("日志文件创建失败");

            }

            e.printStackTrace(System.out);

        }

    }

}

IO流(系统信息)

import java.util.Properties;

import java.io.PrintStream;

import java.io.IOException;

public class Test{

    public static void main(String...args) throws IOException{

        Properties popr = System.getProperties();

        popr.list(new PrintStream("C:\\1.properties"));

    }

}

戒风
关注
专栏目录
Java学习 11.23
WGY0227的博客
11-23 567
Java学习 数组 1.1 junit的单元测试 我们现在代码测试的时候都是创建一个类 添加一个main函数、但是一个类只能有一个main函数。假如我们需要测试很多内容，就会出现一个问题 需要创建很多的类。很麻烦。 所以我们可以使用单元测试，相当于一个类可以写n个函数并且能调用执行。 ​ A 创建一个类 注意一定不能叫Test（因为我们要用的第三方的类也叫Test） B 在类中写一个公共无参数的函数 C 在函数上面添加一个@Test注解 D 通过智能纠正导入需要的依赖 package com..
黑马程序员——IO流—整理笔记
nanfp的博客
07-05 776
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 今天刚学完IO流，下面整理一下我的学习笔记。         ①根据处理数据的数据类型的不同可以分为：字节流（抽象基类为InPutStream和OutPutStream）和字符流（抽象基类为Reader和Writer）。          注意：由这四个类派生出来的子类名称都是以其父类名作
java入门基础(四)
qq_45798550的博客
08-15 2317
（一）对象和类 类:类是对象的抽象(不存在) 对象:对象是类的实现(具体存在) 现实生活中先有对象再有类 Java中先有类再有对象 面向对象:是一种思想,在开发过程中关注于对象进行开发 类中相同的行为和特征在Java中如何表示 特征:变量 行为:方法 类的定义: 1.public class 类名{} 2.定义成员变量 格式:public 数据类型 变量名 3.定义成员方法 格式:public 返回值数据类型 方法名称(参数){} 类的使用(对象): 1.通过类创建对象 格式:类名 对象名=
java socket类实现网络通信
我的blog
01-10 2364
java socket 类分为：ServerSocket、Socket，即服务器端和客户端。这两个类都属于，java.net包中。 ServerSocket的用法： 1、首先创建ServerSocket对象，并绑定一个端口号（端口号取值范围0-65535，0-1023是系统保留端口，建议设置1023之后的，大点更好，注意不能使用已经占用的端口）。 2、通过ServerSocket的accep
socket发送接收消息(String message)
lvwenwen
07-23 1632
package com.qingshan.net.socket; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /** * * 客户端:发送信息/接收服务器反馈信息 ...
黑马程序员——IO流
codeting的博客
12-16 402
最近学习了Java的IO流部分，下面作一些简单的总结：    首先，Java中IO流的作用是处理设备之间的数据传输。按照操作数据可以分为字符流和字节流，按照流向可以分为输入流和输出流。Java用来操作流的对象都封装在io包中，下面我引用了一张别人的框架图，清晰地罗列出了IO流的体系结构。 下面，对一些常用的流举例示范： 字符流 //对FileReader和FileWriter的
黑马程序员——io字节流
binbinsex的专栏
04-15 389
字节流是最基本的流，文件的操作、网络数据的传输等等都依赖于字节流。而字符流常常用于读取文本类型的数据或字符串流的操作等等。 关于字节流的API，没什么好说的，看看就知道了。这里挑几个关键点：
黑马程序员——IO流（字节流）
cmj的博客
09-17 380
IO（Input Output）流 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 IO流常用基类 字节流的抽象基类    InputStream    OutputStream 字符流的抽象基类  Reader   Writer 注：有
黑马程序员——IO流体系
guojiadui的博客
05-16 432
黑马程序员——IO流体系——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- java作为一种面向对象语言，程序的一切都动作行为都是通过对象完成。所谓IO流，就是把数据的传输行为封装成了对象，对于数据的传输过程，也就变成了对IO流对象的操作过程：IO流的分类1.按数据的传输方向分类（也就根据数据的传输方向分，数据的源头与数据目的地）： 输入流：硬盘、网络、或输入
黑马程序员——IO流：字节流，字符流及键盘录入
Jiaming84的博客
06-03 661
------- android培训、java培训、期待与您交流！ ---------- IO流 概述：1，IO流用来处理设备间的数据传输。       2，Java对数据的操作是通过流的方式。       3，Java用于操作流的对象都在IO包中。       4，流按操作数据分为两种：字节流和字符流。       5，流按流向分为：输入流和输出流。 注意：流只能操作数据，而不能操作
黑马程序员——Java中IO流（字节流 字符流 其他流 ）
InsistOwn的博客
06-30 556
IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在io包中   IO体系：   流按操作数据        |---字节流（InputStream   OutputStream）        |---字符流（Reader   Writer）   流按流向        |---输入流        |---输出流 字节流两个基
黑马程序员————Java基础日常笔记---IO流一
shuizhi312的博客
07-20 976
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 黑马程序员————Java基础日常笔记---IO流一 1.1 IO的由来： 先什么是IO流呢？ java对数据的操作；  IO流用来处理设备之间的数据传输， 并且操作流的对象都在IO包中，  而对数据的操作： 读和写； IO流按照操作的数据分为：字节流与字符流（InputS
黑马程序员java学习笔记——IO流
魏天翔的博客
06-08 536
IO流     概述     流的特点     IO流用于处理设备之间的数据传输；     java对数据的操作是通过流的方式；     java用于操作留的对象都放在IO包中；     流按操作数据分为两种：字节流和字符流；     按流向分为：输入流和输出流；     字符流对相融合了编码表。     流常用基类     字节流的抽象基类：输入流InputS
黑马程序员——集合工具类
W49408322的专栏
08-20 819
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Collections:集合框架的工具类。里面定义的都是静态方法。（相信Java的新手们都知道，如果一个类全都是静态方法的话，那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的） Collections和Coll
黑马程序员——泛型(Generic)
W49408322的专栏
08-20 724
入门泛型的基本应用 代码示例： package com.itheima.day02; import java.util.ArrayList; public class GenericTest1 {     public staticvoidmain(String[] args) {         ArrayList collection1 = new ArrayLis
黑马程序员——Java基础__多线程（下）
W49408322的专栏
08-20 669
面向对象——多线程（下） 线程间的通信 线程间通信——等待唤醒机制 wait(), notify(), notifyAll(), 都使用在同步中，因为要对持有监视器（锁）的线程操作。 思考：为什么操作线程的方法wait notify notifyAll定义在了Object类中？ 因为这些方法是监视器的方法。监视器其实就是锁。锁可以是任意的对象，任意的对象调用的方式一定定义在Obj
黑马程序员——反射
W49408322的专栏
08-20 644
 Java 面向对象——反射 理解反射的概念 反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的
黑马程序员——Java基础__多线程（上）
W49408322的专栏
08-20 625
面向对象——多线程（上） 简单概念：任务管理器——进程里面执行的程序里面就有很多的线程，不是同时执行的，只是CPU在做着快速的切换。 什么是API？就是Java用面向对象的思想给程序员封装好的核心类库，方便了我们的使用。 多线程 概述 1、进程： 是一个正在执行中的程序。 每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元（线程）。 2、线程：就是进
黑马程序员——Java集合Collection
W49408322的专栏
08-20 581
面向对象——集合Collection 集合类的由来： 对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。 集合的特点： 长度可以发生改变。 只能存储对象。 集合中不可以存储基本数据类型值。 可以存储多种类型对象(一般存储的还是同一种，因为1.5JDK的新特性 泛型)。 集合和
黑马程序员io流笔记
最新发布
07-29
在Java中，有字节流和字符流两种类型的IO流。字节流是以字节为单位进行操作的，而字符流是以字符为单位进行操作的。字节流更加方便且在处理图片、音频等二进制对象时更常用，而字符流在处理中文时更为方便。\[1\]\[2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值