首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Java基础-20(02)总结,递归,IO流

Java基础-20(02)总结,递归,IO流

作者头像
Java帮帮
发布2018-03-16 15:37:41
6930
发布2018-03-16 15:37:41
举报
(4)FileInputStream读取数据

A:操作步骤

a:创建字节输入流对象

b:调用read()方法

c:释放资源

B:代码体现:

 FileInputStream fis = new FileInputStream("fos.txt");
 //方式1
 int by = 0;
 while((by=fis.read())!=-1) {
 System.out.print((char)by);
 }
 //方式2
 byte[] bys = new byte[1024];
 int len = 0;
 while((len=fis.read(bys))!=-1) {
 System.out.print(new String(bys,0,len));
 }
 fis.close();

(5)案例:2种实现

A:int read():一次读取一个字节

package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 字节输入流操作步骤:
 * A:创建字节输入流对象
 * B:调用read()方法读取数据,并把数据显示在控制台
 * C:释放资源
 * 
 * 读取数据的方式:
 * A:int read():一次读取一个字节
 * B:int read(byte[] b):一次读取一个字节数组
 */
public class FileInputStreamDemo {
 public static void main(String[] args) throws IOException {
 // FileInputStream(String name)
 // FileInputStream fis = new FileInputStream("fis.txt");
 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 // // 调用read()方法读取数据,并把数据显示在控制台
 // // 第一次读取
 // int by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 //
 // // 第二次读取
 // by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 //
 // // 第三次读取
 // by = fis.read();
 // System.out.println(by);
 // System.out.println((char) by);
 // // 我们发现代码的重复度很高,所以我们要用循环改进
 // // 而用循环,最麻烦的事情是如何控制循环判断条件呢?
 // // 第四次读取
 // by = fis.read();
 // System.out.println(by);
 // // 第五次读取
 // by = fis.read();
 // System.out.println(by);
 // //通过测试,我们知道如果你读取的数据是-1,就说明已经读取到文件的末尾了
 // 用循环改进
 // int by = fis.read();
 // while (by != -1) {
 // System.out.print((char) by);
 // by = fis.read();
 // }
 // 最终版代码
 int by = 0;
 // 读取,赋值,判断
 while ((by = fis.read()) != -1) {
 System.out.print((char) by);
 }
 // 释放资源
 fis.close();
 }
}
 B:int read(byte[] b):一次读取一个字节数组
package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 一次读取一个字节数组:int read(byte[] b)
 * 返回值其实是实际读取的字节个数。
 */
public class FileInputStreamDemo2 {
 public static void main(String[] args) throws IOException {
 // 创建字节输入流对象
 // FileInputStream fis = new FileInputStream("fis2.txt");
 FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");
 // 读取数据
 // 定义一个字节数组
 // 第一次读取
 // byte[] bys = new byte[5];
 // int len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第二次读取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第三次读取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys));
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 //
 // // 第四次读取
 // len = fis.read(bys);
 // // System.out.println(len);
 // // System.out.println(new String(bys, 0, len));
 // System.out.print(new String(bys, 0, len));
 // // 代码重复了,用循环改进
 // // 但是,我不知道结束条件
 // // len = fis.read(bys);
 // // System.out.println(len);
 // // len = fis.read(bys);
 // // System.out.println(len);
 // // 如果读取到的实际长度是-1,就说明没有数据了
 // byte[] bys = new byte[115]; // 0
 // int len = 0;
 // while ((len = fis.read(bys)) != -1) {
 // System.out.print(new String(bys, 0, len));
 // // System.out.print(new String(bys)); //千万要带上len的使用
 // }
 // 最终版代码
 // 数组的长度一般是1024或者1024的整数倍
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 System.out.print(new String(bys, 0, len));
 }
 // 释放资源
 fis.close();
 }
}

A:复制文本文件

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 复制文本文件。
 * 
 * 数据源:从哪里来
 * a.txt -- 读取数据 -- FileInputStream 
 * 
 * 目的地:到哪里去
 * b.txt -- 写数据 -- FileOutputStream
 * 
 * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
 * 
 * 这一次复制中文没有出现任何问题,为什么呢?
 * 上一次我们出现问题的原因在于我们每次获取到一个字节数据,就把该字节数据转换为了字符数据,然后输出到控制台。
 * 而这一次呢?确实通过IO流读取数据,写到文本文件,你读取一个字节,我就写入一个字节,你没有做任何的转换。
 * 它会自己做转换。
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("a.txt");
 // 封装目的地
 FileOutputStream fos = new FileOutputStream("b.txt");
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 释放资源(先关谁都行)
 fos.close();
 fis.close();
 }
}

B:把c盘下的a.txt的内容复制到d盘下的b.txt中

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把c盘下的a.txt的内容复制到d盘下的b.txt中
 * 
 * 数据源:
 *  c:\\a.txt -- 读取数据-- FileInputStream
 * 目的地:
 *  d:\\b.txt -- 写出数据 -- FileOutputStream
 */
public class CopyFileDemo2 {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("c:\\a.txt");
 // 封装目的地
 FileOutputStream fos = new FileOutputStream("d:\\b.txt");
 // 复制数据
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 释放资源
 fos.close();
 fis.close();
 }
}

c:复制图片

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
 * 
 * 数据源:
 *  e:\\林青霞.jpg --读取数据--FileInputStream
 * 目的地:
 *  mn.jpg--写出数据--FileOutputStream
 */
public class CopyImageDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
 // 封装目的地
 FileOutputStream fos = new FileOutputStream("mn.jpg");
 // 复制数据
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 释放资源
 fos.close();
 fis.close();
 }
}

d:复制视频

package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源:
 *  e:\\哥有老婆.mp4--读取数据--FileInputStream
 * 目的地:
 *  copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
 // 封装目的地
 FileOutputStream fos = new FileOutputStream("copy.mp4");
 // 复制数据
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 // 释放资源
 fos.close();
 fis.close();
 }
}

e:计算机是如何识别什么时候该把两个字节转换为一个中文呢?

package cn.itcast_03;
import java.util.Arrays;
/*
 * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
 * 在计算机中中文的存储分两个字节:
 *  第一个字节肯定是负数。
 *  第二个字节常见的是负数,可能有正数。但是没影响。
 */
public class StringDemo {
 public static void main(String[] args) {
 // String s = "abcde";
 // // [97, 98, 99, 100, 101]
 String s = "我爱你中国";
 // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
 byte[] bys = s.getBytes();
 System.out.println(Arrays.toString(bys));
 }
}

(6)字节缓冲区流

A:BufferedOutputStream

package cn.itcast_05;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多,所以,看来有一个缓冲区还是非常好的。
 * 既然是这样的话,那么,java开始在设计的时候,它也考虑到了这个问题,就专门提供了带缓冲区的字节类。
 * 这种类被称为:缓冲区类(高效类)
 * 写数据:BufferedOutputStream
 * 读数据:BufferedInputStream
 * 
 * 构造方法可以指定缓冲区的大小,但是我们一般用不上,因为默认缓冲区大小就足够了。
 * 
 * 为什么不传递一个具体的文件或者文件路径,而是传递一个OutputStream对象呢?
 * 原因很简单,字节缓冲区流仅仅提供缓冲区,为高效而设计的。但是呢,真正的读写操作还得靠基本的流对象实现。
 */
public class BufferedOutputStreamDemo {
 public static void main(String[] args) throws IOException {
 // BufferedOutputStream(OutputStream out)
 // FileOutputStream fos = new FileOutputStream("bos.txt");
 // BufferedOutputStream bos = new BufferedOutputStream(fos);
 // 简单写法
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream("bos.txt"));
 // 写数据
 bos.write("hello".getBytes());
 // 释放资源
 bos.close();
 }
}

B:BufferedInputStream

package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
 * 注意:虽然我们有两种方式可以读取,但是,请注意,这两种方式针对同一个对象在一个代码中只能使用一个。
 */
public class BufferedInputStreamDemo {
 public static void main(String[] args) throws IOException {
 // BufferedInputStream(InputStream in)
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 "bos.txt"));
 // 读取数据
 // int by = 0;
 // while ((by = bis.read()) != -1) {
 // System.out.print((char) by);
 // }
 // System.out.println("---------");
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 System.out.print(new String(bys, 0, len));
 }
 // 释放资源
 bis.close();
 }
}

(7)案例:4种实现

基本字节流一次读写一个字节: 共耗时:117235毫秒

基本字节流一次读写一个字节数组: 共耗时:156毫秒

高效字节流一次读写一个字节: 共耗时:1141毫秒

高效字节流一次读写一个字节数组: 共耗时:47毫秒

package cn.itcast_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件:
 * 基本字节流一次读写一个字节: 共耗时:117235毫秒
 * 基本字节流一次读写一个字节数组: 共耗时:156毫秒
 * 高效字节流一次读写一个字节: 共耗时:1141毫秒
 * 高效字节流一次读写一个字节数组: 共耗时:47毫秒 ***必须掌握****
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 //测试时间
 long start = System.currentTimeMillis();
 // method1("e:\\哥有老婆.mp4", "copy1.mp4");
 // method2("e:\\哥有老婆.mp4", "copy2.mp4");
 // method3("e:\\哥有老婆.mp4", "copy3.mp4");
 method4("e:\\哥有老婆.mp4", "copy4.mp4");
 long end = System.currentTimeMillis();
 System.out.println("共耗时:" + (end - start) + "毫秒");
 }
 // 高效字节流一次读写一个字节数组:
 public static void method4(String srcString, String destString)
 throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 srcString));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(destString));
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 bos.write(bys, 0, len);
 }
 bos.close();
 bis.close();
 }
 // 高效字节流一次读写一个字节:
 public static void method3(String srcString, String destString)
 throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 srcString));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(destString));
 int by = 0;
 while ((by = bis.read()) != -1) {
 bos.write(by);
 }
 bos.close();
 bis.close();
 }
 // 基本字节流一次读写一个字节数组
 public static void method2(String srcString, String destString)
 throws IOException {
 FileInputStream fis = new FileInputStream(srcString);
 FileOutputStream fos = new FileOutputStream(destString);
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 fos.close();
 fis.close();
 }
 // 基本字节流一次读写一个字节
 public static void method1(String srcString, String destString)
 throws IOException {
 FileInputStream fis = new FileInputStream(srcString);
 FileOutputStream fos = new FileOutputStream(destString);
 int by = 0;
 while ((by = fis.read()) != -1) {
 fos.write(by);
 }
 fos.close();
 fis.close();
 }
}

A:复制文本文件

package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把c:\\a.txt内容复制到d:\\b.txt中
 * 
 * 数据源:
 *  c:\\a.txt -- 读取数据 -- FileInputStream
 * 目的地:
 *  d:\\b.txt -- 写出数据 -- FileOutputStream
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("c:\\a.txt");
 FileOutputStream fos = new FileOutputStream("d:\\b.txt");
 // 复制数据
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 // 释放资源
 fos.close();
 fis.close();
 }
}

B:复制图片

C:复制视频

package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求:把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源:
 *  e:\\哥有老婆.mp4--读取数据--FileInputStream
 * 目的地:
 *  copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
 // 封装目的地
 FileOutputStream fos = new FileOutputStream("copy.mp4");
 // 复制数据
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = fis.read(bys)) != -1) {
 fos.write(bys, 0, len);
 }
 // 释放资源
 fos.close();
 fis.close();
 }
}

3:自学字符流

IO流分类

字节流:

InputStream

FileInputStream

BufferedInputStream

OutputStream

FileOutputStream

BufferedOutputStream

字符流:

Reader

FileReader

BufferedReader

Writer

FileWriter

BufferedWriter

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2016-12-10,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Java帮帮 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档