Java中字节流和异常处理

字节输入流

字节输入流流程

package com.cloud.day2;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

File类:
用于描述一个文件或者文件夹的。

通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。

IO流（Input Output）

IO流解决问题：解决设备与设备之间的数据传输问题。
内存--->硬盘
硬盘--->内存

IO流技术：

IO流分类：

如果是按照数据的流向划分：

输入流

输出流

如果按照处理的单位划分：

字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。

字符流：字符流读取的数据是以字符为单位的。字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能识别的字符。

字符流 =
字节流 + 解码

输入字节流：

--------| InputStream
所有输入字节流的基类
抽象类

------------| FileInputStream
读取文件数据的输入字节流

使用FileInputStream读取文件数据的步骤：

1.
找到目标文件

2.
建立数据的输入通道。

3.
读取文件中的数据。

4.
关闭资源.

public
class Demo1 {

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

readTest4();

}

//读取的方式一缺陷：无法读取完整一个文件的数据.

public
static void readTest1()
throws IOException{

//1.找到目标文件

File file = new File("F:\\a.txt");

//2.建立数据通道

FileInputStream fileInputStream =
new FileInputStream(file);

//3.读取文件的数据

int content = fileInputStream.read();

System.out.println("read content:"+(char)content);

//4.关闭释放资源

fileInputStream.close();

}

//方式2
：使用循环读取文件的数据

public
static void readTest2()
throws IOException{

long startTime = System.currentTimeMillis();

File file = new File("F:\\dd.jpg");

FileInputStream fileInputStream =
new FileInputStream(file);

int content = 0;

while((content = fileInputStream.read())!=-1){

System.out.print((char)content);

}

fileInputStream.close();

long endTime = System.currentTimeMillis();

System.out.println("读取时间："+(endTime-startTime));

}

//方式3：使用缓冲数组读取。
缺点：无法读取完整一个文件的数据。

public
static void readTest3()
throws IOException{

File file = new File("F:\\a.txt");

FileInputStream fileInputStream =
new FileInputStream(file);

byte []buf =
new byte[1024];

//
如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，

//而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。

int len = fileInputStream.read(buf);

System.out.println("len="+len);

//使用字节数组构建字符串

String content = new String(buf, 0, len);

System.out.println("content:"+content);

fileInputStream.close();

}

//方式4：使用缓冲数组配合循环一起读取

public
static void readTest4()
throws IOException{

long startTime = System.currentTimeMillis();

File file = new File("F:\\dd.jpg");

FileInputStream fileInputStream =
new FileInputStream(file);

int len = 0;

//存储读取到的数据
缓冲数组的长度一般是1024的倍数，因为与计算机的处理单位。

//理论上缓冲数组越大，效率越高

byte [] buf =
new byte[1024];

while((len = fileInputStream.read())!=-1){

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

}

fileInputStream.close();

long endTime = System.currentTimeMillis();

System.out.println("读取时间："+(endTime-startTime));

}

流关闭问题

先打开的流后关闭

package com.cloud.day2;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

问题1：读取完一个文件的数据的时候，我不关闭资源有什么影响?

答案：资源文件一旦使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他的操作。

public
class Demo2 {

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

//1.找到目标文件

File file = new File("F:\\a.txt");

//2.建立数据输入通道

FileInputStream fileInputStream =
new FileInputStream(file);

//3.缓冲字节数组读取文件

byte []buf =
new byte[1024];

int length = 0;

while((length=fileInputStream.read(buf))!=-1){

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

}

//4.释放资源文件

fileInputStream.close();

}

拷贝图片

package com.cloud.day3;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

需求：拷贝一张图片

public
class Demo1 {

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

File inFile = new File("F:\\dd.jpg");

File destFile = new File("E:\\dd.jpg");

FileInputStream fileInputStream =
new FileInputStream(inFile);

//每新创建一个FileOutputStream的时候，默认情况下FileOutputStream
的指针是指向了文件的开始的位置。

//每写出一次，指向都会出现相应移动。

FileOutputStream fileOutputStream =
new FileOutputStream(destFile);

//建立缓冲数据，边读边写

byte []buf =
new byte[1024];

int length=0;

while((length=fileInputStream.read())!=-1){

fileOutputStream.write(buf, 0, length);

}

//关闭原则，先开后关，后开先关

fileOutputStream.close();

fileInputStream.close();

}

字节输出流

字节输出流流程

package com.cloud.day3;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

字节输出流：

---| OutputStream
是所有输出字节流的父类。
抽象类

------| FileOutStream
向文件输出数据的输出字节流。

FileOutputStream如何使用呢？

1.
找到目标文件

2.
建立数据的输出通道。

3.
把数据转换成字节数组写出。

4.
关闭资源

FileOutputStream要注意的细节：

1.
使用FileOutputStream
的时候，如果目标文件不存在，那么会自动创建目标文件对象。

2.
使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。

3.
使用FileOutputStream写数据的时候,
如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。

4.
使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是

把低八位的二进制数据写出，其他二十四位数据全部丢弃。

public
class Demo2 {

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

writeTest1();

}

//使用字节数组写出数据

//每次只能写一个字节的数据出去

public
static void writeTest1()
throws IOException{

File file = new File("F:\\a.txt");

FileOutputStream fileOutputStream =
new FileOutputStream(file);

fileOutputStream.write(‘s‘);

fileOutputStream.write(‘p‘);

fileOutputStream.write(‘r‘);

fileOutputStream.write(‘i‘);

fileOutputStream.write(‘n‘);

fileOutputStream.write(‘g‘);

fileOutputStream.close();

}

写数据的类型

package com.cloud.day3;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Arrays;

4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一

个字节的数据，只是把低八位的二进制数据写出，其他二十四位数据全部丢弃。

public
class Demo3 {

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

readTest();

}

public
static void readTest()
throws IOException{

File file = new File("F:\\a.txt");

FileInputStream fileInputStream =
new FileInputStream(file);

byte []buf=new
byte[1024];

int length = fileInputStream.read(buf);

System.out.println("字节数组的内容是："+Arrays.toString(buf));

fileInputStream.close();

}

public
static void writeTest()throws FileNotFoundException,IOException{

File file = new File("F:\\a.txt");

FileOutputStream fileOutputStream =
new FileOutputStream(file);

fileOutputStream.write(511);

fileOutputStream.close();

}

IO流的异常处理

package com.cloud.day3;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

IO中的异常处理

public
class Demo4 {

public
static void main(String[] args) {

copyImage();

}

//拷贝图片

public
static void copyImage(){

FileInputStream fileInputStream =
null;

FileOutputStream fileOutputStream =
null;

try {

//找到目标文件

File inFile = new File("F:\\dd.jpg");

File outFile = new File("F:\\d.jpg");

//建立流通道

fileInputStream = new FileInputStream(inFile);

fileOutputStream = new FileOutputStream(outFile);

//建立缓冲数组，边读边写

byte[] buf =
new byte[1024];

int length = 0;

while((length = fileInputStream.read(buf))!=-1){

fileOutputStream.write(buf, 0, length);

}

} catch (IOException e) {

System.out.println("拷贝图片出错...");

throw
new RuntimeException(e);

}finally{

try {

if(fileOutputStream!=null){

fileOutputStream.close();

System.out.println("关闭输出流对象成功...");

}

} catch (IOException e) {

System.out.println("关闭输出流对象失败...");

throw
new RuntimeException(e);

}finally{

if(fileInputStream!=null){

try {

fileInputStream.close();

System.out.println("关闭输入流成功...");

} catch (IOException e) {

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

throw
new RuntimeException(e);

}

//读取文件测试

public
static void readTest(){

FileInputStream fileInputStream =
null;

try {

//找到目标文件

File file = new File("F:\\a.txt");

//建立数据输入通道

fileInputStream = new FileInputStream(file);

//建立缓冲数组读取数据

byte[] buf =
new byte[1024];

int length = 0;

while((length = fileInputStream.read(buf))!=-1){

System.out.println(new String(buf, 0, length));

}

} catch (IOException e) {

*
异常：阻止后面的代码执行，通知调用者这里出错

* RuntimeException(e)

*
把IOException传递给RuntimeException包装一层，然后抛出，使调用者使用变的灵活

System.out.println("读取资源文件出错...");

throw
new RuntimeException(e);

}finally{

try {

if(fileInputStream!=null){

fileInputStream.close();

System.out.println("关闭资源文件成功...");

}

} catch (IOException e) {

System.out.println("关闭资源文件失败...");

throw
new RuntimeException(e);

}

缓冲字节流

缓冲字节输入流

package com.cloud.day3;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

读取文件数据使用缓冲流效率最高--缓冲输入字节流对象

输入字节流体系

--|InputStream
输入字节流基类，抽象

----|FileInputStream
读取文件数据的输入字节流

----|BufferedInputStream
缓冲输入字节流
提高读取文件数据的效率，该类的内部维护了一个8kb的字节数组

注意：缓冲流不具备读写文件的能力

public
class Demo5 {

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

readTest();

}

public
static void readTest2()
throws IOException{

File file = new File("F:\\a.txt");

FileInputStream fileInputStream =
new FileInputStream(file);

BufferedInputStream bufferedInputStream =
new BufferedInputStream(fileInputStream);

bufferedInputStream.read();

FileOutputStream fileOutputStream =
new FileOutputStream(file);

BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(fileOutputStream);

fileOutputStream.write(null);

//读取文件数据

int content = 0;

while((content = fileInputStream.read())!=-1){

System.out.println((char)content);

}

//关闭资源,这里实际上是关闭FileInputSream

bufferedInputStream.close();

}

public
static void readTest()
throws IOException{

//读取文件使用缓冲数组

File file = new File("F:\\a.txt");

FileInputStream fileInputStream =
new FileInputStream(file);

//建立缓冲数组读取数据

byte[] buf =
new byte[1024];

int length = 0;

while((length = fileInputStream.read(buf))!=-1){

System.out.println(new String(buf, 0, length));

}

fileInputStream.close();

}

缓冲字节输出流

package com.cloud.day3;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

输出字节流

--|OutputStream
输出字节流的基类

----|FileOutputStream
输出字节流

----|BufferedOutputStream
缓冲字节输出流

注意：

1.BufferedOutputStream写数据的时候，它的write方法是先把数据写到它维护的字节数组中

2.BufferedOutputStream写数据的时候，它的write方法是先把数据写到它维护的字节数组中，如果需要把数据真正的

写到硬盘上面，调用flush方法或者是close方法，或者是内部维护的字节数组已经填满的时候

public
class Demo6 {

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

File file = new File("F:\\a.txt");

FileOutputStream fileOutputStream =
new FileOutputStream(file);

BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(fileOutputStream);

bufferedOutputStream.write("Hello,world".getBytes());

bufferedOutputStream.close();

}

缓冲字节流拷贝图片

package com.cloud.day3;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

拷贝图片

public
class Demo7 {

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

//找到目标文件

File inFile = new File("F:\\dd.jpg");

File outFile = new File("F:\\1.jpg");

//建立数据通道

FileInputStream fileInputStream =
new FileInputStream(inFile);

FileOutputStream fileOutputStream =
new FileOutputStream(outFile);

//建立缓冲流

BufferedInputStream bufferedInputStream =
new BufferedInputStream(fileInputStream);

BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(fileOutputStream);

//边读边写

int content = 0;

while((content = bufferedInputStream.read())!=-1){

bufferedOutputStream.write(content);

}

bufferedInputStream.close();

bufferedOutputStream.close();

}

时间： 2024-10-07 04:56:15

Java中字节流和异常处理的相关文章

java中的try-catch-finnal异常处理（学习笔记）

一.异常概述异常:Exception,是在运行发生的不正常情况. 原始异常处理: if(条件) { 处理办法1 处理办法2 处理办法3} if(条件) { 处理办法4 处理办法5 处理办法6} 代码阅读性差,臃肿不堪,与正常流程代码结合的很紧密,所以,在JAVA中进行一系列的改良,将一系列常见的问题,用面向对象的思考方式,对其进行了描述.封装. class 处理办法 { 处理办法1() { 举例1 } 处理办法2() { 举例2 } }if(出错了){ 抛出 new 处理办法1();此方法可能

Java中常用的异常处理情况及关于开发中异常处理的建议

本周四老师由一个简单程序将问题引出,讲授了Java中异常处理的情况.根据课件内容及上网查阅资料,将关于JAVA项目中的常用的异常处理情况总结如下: 首先什么是异常(Exception):发生于程序执行期间,表明出现了一个非法的运行状况.许多JDK中的方法在检测到非法情况时,都会抛出一个异常对象.异常处理的目的是依据实际情况提供不同的错误应对策略与手段,使程序更稳定,更安全.异常处理的主要用途是提供准确的错误消息,解释失败的原因.位置和错误类型等,同时提供一定的恢复能力,尽可能地保证数据完整性不被

Java中常用的异常处理情况课件动手动脑

1:请阅读并运行AboutException.java示例,然后通过后面的几页PPT了解Java中实现异常处理的基础知识. import javax.swing.*; class AboutException { public static void main(String[] a) { int i=1, j=0, k; k=i/j; try { k = i/j; // Causes division-by-zero exception //throw new Exception("Hello.

JAVA中IO和异常处理练习

1.SystemI\O练习:1)通过键盘输入若干字符,并通过显示器输出:2)定义一个静态方法validOrNot()用于对输入的字符进行合法性校验,若包含非英文字符,则抛出IllegalStringException异常:3)通过Try/Catch异常处理机制,处理异常:若包含非英文字符,给予相应提示:若只包含英文字符,则统计字符数量,并输出. 1 package iooutput; 2 3 import java.io.BufferedReader; 4 import java.io.IOEx

java中字节流与字符流的区别

字节流在I/O类库中,java.io.InputStream和java.io.OutputStream分别表示字节输入流和字节输出流,它们都是抽象类,不能实例化,数据流中的最小单位是字节,所以叫做字节流. 一.InputStream中的读取数据的方法如下: 1 .int read() 功能:读取一个字节的数据,并且返回读到得数据,如果返回-1,则表示读到输入流的末尾. 2.int read(byte[] b) 功能:从输入流中读取一定量的字节,并将其存储在字节数组b中,返回实际读取的字节数,如

Java中常见的异常处理汇总

1. java.lang.nullpointerexception 这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等.对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了.数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的

JAVA中常用的异常处理情况

1.java.lang.nullpointerexception程序遇上空指针这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等.对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了.数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,

Java中字节流如何转字符流，OutputStreamWriter用法

OutputStreamWriter 将字节流转换为字符流.是字节流通向字符流的桥梁.如果不指定字符集编码,该解码过程将使用平台默认的字符编码,如:UTF-8: 步骤: 1.创建流子类对象绑定数据目的. 1 FileOutputStream fos = new FileOutputStream("c:\\utf.txt"); 2.将字节转为字符,并声明utf-8格式(万国码). 1 OutputStreamWriter sow = new OutputStreamWriter(f

Java 中的 I/O 抽象

Table of Contents 前言字节流常用实现字符流常用实现缓冲区各种字节流结语前言由于在接触 Java 之前使用的语言是 Python,所以在转到 Java 后对 Java 的 I/O 操作各种不习惯. 研究后发现 Java 的 I/O 模型和 Python 的基本上还是一样的,只是在接口的设计上有些区别,主要是为了符合 OOP 的思想吧. 这篇博客的主要内容便是和 Java I/O 相关的总结. 字节流和 Python 一样,Java 中最底层的 I/O 接口处理