以java程序为参照点:
java -->文件 (输出) Input 输入 -- 从文件中已有的数据到java程序
文件-->java(输入) Output 输出 -- java程序到文件中
字节流是用来操作文件-的
字符流是用来操作文本文件-的>
字节输出流(操作的数据是最小存储单元-->字节)
java.io.OutputStream 所有字节输出流的超类
package cn.bufanli.iodemo;
/**
* @author BFL
* 字节输出流
* java.io.OutputStream 所有字节输出流的超类
* 作用:
* 从java程序,写出文件
* 字节:
* 每次只操作文件中的一个字节,写任意文件
* 方法都是写入文件的方法
* write(int b)写入一个字节
* write(byte [] buf) buf 写入字节数组
* write(byte[] byf,int off,int len) byf 写入的数组,off 索引开始的位置, len写几个
* close(); 方法,关闭流对象,释放与流相关的资源
* 流对象操作文件的时候,自己不做,依赖于系统,当流用完之后要释放占用的系统资源
*/
public class OutputStreamDemo {
}
java.io.FileOutputStream; 子类
package cn.bufanli.iodemo;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author BFL
* FileOutputStream
* 写入数据文件
* 构造方法:
* 作用: 绑定输出的目的
* 参数: File 对象 、String 对象 文件名
* 使用步骤:
* 1.创建流的子类对象,绑定数据的目的地 具体文件对象
* 2.调用write方法写
* 3.close关闭流资源
* 流对象的构造方法可以根据我们的路径创建一个文件,如果文件已经存在直接覆盖
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("F:\\a.java");
//使用流对象的方法 writer
//写一个字节 将100转成一个二进制字节 显示b
fileOutputStream.write(100);
//1
fileOutputStream.write(49);
//0
fileOutputStream.write(48);
//0
fileOutputStream.write(48);
//写字节数组 A B C D
byte[] buf ={65,66,67,68};
fileOutputStream.write(buf);
//写入数组的简单方式
fileOutputStream.write("哈哈".getBytes());
//写数组的一部分 A->65 B->66 off:开始位置 len 写几个
fileOutputStream.write(buf,0,2);
fileOutputStream.close();
}
}
继续-- > 文件的续写和换行
package cn.bufanli.iodemo;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author BFL
* 文件的续写和换行
* FileOutputStream(File file,Boolean append) append true 为从文件末尾开始写
* 在文件中写入换行 \r\n
* \r\n 可以写在上一行的末尾,也可以写在下一行的开头
*/
public class FileOutputStreamDemo02 {
public static void main(String[] args) throws IOException {
File file = new File("F:\\a.java");
//文件续写,第二个参数为true
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
//\r\n 可以写在上一行的末尾,也可以写在下一行的开头
fileOutputStream.write("\r\nhello\r\n".getBytes());
fileOutputStream.write("\r\nhello".getBytes());
fileOutputStream.close();
}
}
继续 IO中异常的处理
package cn.bufanli.iodemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author BFL
* IO流的异常处理
* try cath finally
* 1.保证流对象的作用域够大
* 2.cath
*/
public class FileOutputStreamDemo03 {
public static void main(String[] args) {
File file = new File("F:\\a.java");
//声明变量
FileOutputStream fileOutputStream =null;
try {
fileOutputStream = new FileOutputStream(file);
fileOutputStream.write("\r\nhello测试异常处理".getBytes());
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
//判断是否有这个资源
if(fileOutputStream!=null){
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节输入流
java.io.InputStream;所有字节输入流的超类
package cn.bufanli.iodemo;
/**
* @author BFL
* java.io.InputStream;
* 所有字节输入流的超类 抽象类
* 作用:
* 读取任意文件而且每次只读取一个字节
* 读取字节的方法:
* read(); 读取一个字节 返回值 int
* read(byte [] b) 读取一定量的字节,存储到数组中 返回值为int
*/
public class InputStreamDemo01 {
}
java.io.FileInputStream; 子类
package cn.bufanli.iodemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author BFL
* java.io.FileInputStream; 读取文件
* 构造方法: 为这个流对象提供数据源
* 参数类型:
* File 类型 String 类型
* 输入流读取文件的步骤
* 1.创建字节输入流子对象
* 2.调用方法 read()方法读取
* 3.close() 方法关闭资源
* read()方法
* 执行一次就会自动读取下一个字节,当读取到文件的结尾标记的时候会返回一个 -1 每个文件都有我们看不到的结束标记
* read()方法参数
* read(byte [] b) 读取字节数组
*/
public class FileInputStreamDemo02 {
public static void main(String[] args) throws IOException {
//一个一个读的方式读到最后没有 方法返回值 int 为-1
// oneOneRead();
//由于我们不知道文件中有多少个字节所有使用while循环的方式读取
//allRead();
// 读取字节数组
byteArrayRead();
}
/**
* 一个一个读的方式读到最后没有 方法返回值 int 为-1
* @throws IOException
*/
public static void oneOneRead() throws IOException {
//创建子对象绑定数据源对象
FileInputStream fileInputStream = new FileInputStream(new File("f:\\a.java"));
//读取一个字节返回int
int read = fileInputStream.read();
System.out.println((char) read);
//再次读取会读取到下一个字节
read = fileInputStream.read();
System.out.println((char) read);
//关闭资源
fileInputStream.close();
}
/**
* 使用while循环的方式读取
* @throws IOException
*/
public static void allRead() throws IOException {
//创建子对象绑定数据源对象
FileInputStream fileInputStream = new FileInputStream(new File("f:\\a.java"));
//定义变量接受read()方法的返回值
int len =0;
while ((len=fileInputStream.read())!=-1){
System.out.println((char)len);
}
}
/**
* 读取字节数组
* @throws IOException
*/
public static void byteArrayRead() throws IOException {
//创建子对象绑定数据源对象
FileInputStream fileInputStream = new FileInputStream(new File("f:\\a.java"));
//定义变量接受read()方法的返回值
int len =0;
//创建字节数组 作用 缓冲、提高效率 byte的长度根据文件的大小来设定 1024 为 1kb
// 可以调整数组大小来看输出效果
byte[] b = new byte[12];
while ((len=fileInputStream.read(b))!=-1){
// new String(byte[] b,int offset,int length)
// byte 要解码的数组 offset 要解码数组的第一个索引 length 要解码的数组长度
//为什么要用这个String构造器,如果最后一次读取只是读取到2个字节,而数组的长度为12那么这两个字节把数组前两个索引位置覆盖,而后面的10个索引位置是上一次读取到的数据没有被覆盖掉会出现重复
System.out.println(new String(b,0,len));
}
}
}
复制图片文件
package cn.bufanli.iodemo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author BFL
* 文件copy
*/
public class Copy {
public static void main(String[] args) {
//创建字节输入流子类对象用于关流
FileInputStream fileInput =null;
//创建字节输出流 用于关流
FileOutputStream fileOutputStream =null;
try {
//创建字节输入流数据源
File InFile = new File("F:\\2.jpg");
//创建字节输入流子类对象
fileInput = new FileInputStream(InFile);
//创建字节输出流并且定义字节输出流文件数据源
fileOutputStream = new FileOutputStream(new File("F:\\3.jpg"));
//定义返回值变量
int len = 0;
//定义缓冲数组
byte[] bytes = new byte[14];
//循环读取
while((len=fileInput.read(bytes))!=-1){
fileOutputStream.write(bytes,0,len);
fileOutputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
/**
* 判断流是否开启
*/
if(fileInput!=null){
try {
fileInput.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
/**
* 判断流是否开启
*/
if(fileOutputStream!=null){
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
}
未完!!!!
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
