java 常见io流 万字详解
文章目录
- 1.IO简介
-
- 1.1什么是IO流。
- 1.2数据源（Data Source）
- 1.3什么是流
- 1.4处理对象分类
- 1.5 java四大io抽象类及其他
-
- 1.6inputStream
-
- 1.61简介
- 1.62常用方法
- 1.7OutputStream
-
- 1.71简介
- 1.72常用方法：
- 1.8Reader
-
- 1.81简介
- 1.82Writer
- 1.9总结
-
- 1.91规律
- 1.92常用操作
- 2 文件
-
- 2.0用FileInputStream读取文件（输入文件到程序中）
- 2.1file类使用
- 2.2操作file文件。
- 2.3操作目录
- 3常用流对象
-
- 3.1文件字节流
-
- 3.11读取图片文件（文件字节流输入）
- 3.12复制文件位置（文件字节流输出）
- 3.13通过缓冲区提高读写效率（建立缓冲区）
- 3.14方法2（一次性搬完available()）
- 3.15通过字节缓冲流提高读写效率（BufferedInputStream，BufferedOutputStream）
- 3.16定义文件拷贝工具类
- 3.2文件字符流
-
- **3.21文件字符输入流 FileReader**
- 3.22文件字符输出流
- 3.23问题
- 3.24使用字符流实现文本文件拷贝
- 3.25字符输入缓冲流
- 3.26字符输出缓冲流
- 3.27实现文本文件的拷贝
- 3.28为文件中的内容添加行号
- 4转换流
-
- 4.11通过转换流实现键盘输入屏幕输出
- 4.12通过字节流读取文件并添加行号
- 4.2字符输出流 PrintWriter
-
- 4.21字节数组输入流 ByteArrayInputStream 和 ByteArrayOutputStream
- 4.22字节数组输出流 ByteArrayInputStream
- 5数据流DataInputStream 和 DataOutputStream
-
- 5.1数据输出流DataInputStream
- 5.2数据输入流 DataOutputStream
- 6对象流ObjectOutputStream ObjectInputStream
-
- 6.1操作基本数据类型
-
- 6.11写出基本数据类型数据
- 6.12读基本数据类型
- 6.2将对象序列化到文化
-
- 6.21创建对象Serializable
- 6.22序列化对象ObjectOutputStream
- 6.23将对象反序列化到磁盘当中ObjectInputStream
- 6.3随机访问流
-
- getFilePointer() 获得流的当前读写位置
- 6.5file在IO中的作用
- 7阿帕奇包的应用
-
- 7.1使用
- 7.2IOUtils使用
1.IO简介
1.1什么是IO流。
(input)输入：播放器打开视频。（读，东西类容不变）
(output)输出：写word到磁盘（写）。（东西类容增加）
1.2数据源（Data Source）
提供数据的媒介。（数据的来源）
源设备：为程序提供数据。一般为输入流。
目标设备：程序数据的目的，地一般对应输出流。
程序相当于一个黑盒子。（对于普通人来说）
1.3什么是流
输入/输出流的划分是相对程序而言的，并不是相对数据源。
- 是一连串连续动态的数据集合。
- 就是形容数据传输的过程。
1.4处理对象分类
节点流：可以直接读取数据的。（必须有）
处理流：（锦上添花）不直接连接到数据源或目的地的，（目的：提高性能）
如 BufferedInputStream、BufferedReader 等。处理流也叫 包装流。
1.5 java四大io抽象类及其他
InputStream/OutputStream 和 Reader/Writer 类是所有 IO 流类的抽象父类
1.6inputStream
1.61简介
- 由于是抽象类，需要子类进行重写。
- 向程序中输入数据。且数据单位字节为8bit。
- 返回-1读取完毕。
1.62常用方法
- int read();读取1字节数据，并将字节的值作为int类型返回范围（0~255）。常用
- void close();关闭输入流对象，释放相关系统资源。
- 如果未读出字节则返回-1（返回值为-1 表示读取结束）。
1.7OutputStream
1.71简介
抽象类是表示自己输出流的所有类的父类。输出流接收输出字节并将好这些字节发送到某地。
1.72常用方法：
void write(int n);向目的地写入一个字节。
void close();关闭输出流对象，释放相关资源。
1.8Reader
1.81简介
- 用于读取字符流抽象类。数据单位为字符。
- int read():读取一个字符的数据，并将这个数据的值作为int 类型返回返回（0~65535）Unicode。
- 如果读取完毕，则返回-1；
- void close()；关闭流对象释放相关系统资源。
1.82Writer
用于输出字符流抽象内数据单位为字符。
void Writer(int n); 向输出流中写入一个字符。
void close();关闭输出流对象，释放相关系统资源。
1.9总结
1.91规律
以字节为单位获取数据，命名以上Stram结尾的流一般是字节流。（FileinputStream）（图片，视频，甚至字符）
也只有字节流的.read();会返回（0-255）或者（0-65535）
以字符为单位数据获取数据，命名以上Reader/Writer结尾的流一般是字符流，如FileReader,FileWriter。（文本文件）。
都需要关闭，代表需要try {}catch以及其他报错方式。
传入的都是int类型。void write(int n)；
1.92常用操作
InputStream/OutputStream 字节流的抽象类。（输入流/输出流）
Reader/Writer 字符流的抽象类。 （读/写）
不会直接调用。FileInputStream/FileOutputStream 节点流：以字节为单位直接操作“文件”。（文件输入流/文件输出流）
ByteArrayInputStream/ByteArrayOutputStream 节点流：以字节为单位直接操作“字节数组对象”。（字节数组输入流/字节数组输出流）
ObjectInputStream/ObjectOutputStream 处理流：以字节为单位直接操作“对象”。 （对象输入流/对象输出流）
DataInputStream/DataOutputStream 处理流：以字节为单位直接操作“基本数据类型与字符串类型”。 （数据输入流/数据输入流）
FileReader/FileWriter 节点流：以字符为单位直接操作“文本文件”（注意：只能读写文本文件）。（文件读/文件写）
BufferedReader/BufferedWriter 处理流：将 Reader/Writer 对象进行包装，增加缓存功能，提高读写效率。 （缓冲读/缓冲写）
BufferedInputStream/BufferedOutputStream 处理流：将 InputStream/OutputStream 对象进行包装，增加缓存功能，提高 读写效率。 （缓冲输入流/缓冲输出流）
InputStreamReader/OutputStreamWriter 处理流：将字节流对象转化成字符流对象。（输入流读/输出流写）有字符流与字节流之间的共同结尾特征。
PrintStream 处理流：将 OutputStream 进行包装，可以方便地输出字符，更加灵活。（输出流）
2 文件
浅尝
2.0用FileInputStream读取文件（输入文件到程序中）
注意：
只能一个一个读。
package javaio;
import java.io.FileInputStream;
public class firm01 {
public static void main(String[] args) {
//创建字节输入流
FileInputStream fis=null;//在try的外面关闭流对象，原因是以后还要关闭。不能成为局部变量。
try {
fis = new FileInputStream("D:/a.txt.txt");//注意文件名
char s1=(char)fis.read();//只能打印一个值
char s2=(char)fis.read();//只能打印一个值
char s3=(char)fis.read();//只能打印一个值
int s4=fis.read();//只能打印一个值
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis!=null)
{
fis.close();}
}catch (Exception e){
e.printStackTrace();//e是Throwable的实例异常对象，
// 用在catch语句中，相当于一个形参，
// 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
}
}
}
}
改进
说明：
- //强制转化 （类型）变量名 高->底
//自动转化 底到高
//byte ，short ->char->int->long->float->double - 速度：StringBuilder>StringBuffer>String
package javaio;
import java.io.FileInputStream;
public class firmo2 {
public static void main(String[] args) {
//创建字节输入流
FileInputStream fis=null;//在try的外面关闭流对象，原因是以后还要关闭。不能成为局部变量。
try {
StringBuilder SB=new StringBuilder();
fis = new FileInputStream("D:/a.txt.txt");//注意文件名
int temp=0;//因为最后输出完会返回-1.所以用int型，然后可以//强//制转化为char型
// while(fis!=null)若这样写，fis会一直输出因为java.io.FileInputStream@1b6d3586，永远不为null
while((temp=fis.read())!=-1)//读完之后会返回-1，读完之前返回（0~255的int值）
{
// System.out.println(temp);
SB.append((char)temp);//SB获取所有temp。
}
System.out.println(SB.toString());//输出。SB调用stringbuilder类的方法toString。
} catch (Exception e) {
e.printStackTrace();
}finally {
if(fis!=null) {
try {
fis.close();
}catch (Exception e){
e.printStackTrace();//e是Throwable的实例异常对象，
// 用在catch语句中，相当于一个形参，
// 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
}
}
}
}
2.1file类使用
File 类是 Java 提供的针对磁盘中的文件或目录转换对象的包装类。一个 File 对象而可以 代表一个文件或目录，File 对象可以实现获取文件和目录属性等功能，可以实现对文件和目 录的创建，删除等功能。
2.2操作file文件。
package javaio.fail;//对文件进行操作
import java.io.File;
public class firm0 {
public static void main(String[] args)throws Exception {
File file =new File("d:/ssds.txt");//创建，没有也会自动创建
System.out.println( file.createNewFile());//成功返回ture
// System.out.println(file.delete());//删除
System.out.println(file.exists());//看是否存在
System.out.println(file.getName());//返回文件名
System.out.println(file.isFile());//是不是文件(可能为文件夹)
System.out.println(file.isHidden());//是不是影藏文件(属性->影藏文件)
}
}
2.3操作目录
package javaio;
//针对目录==文件夹
import 常用类.string;
import java.io.File;
public class file1 {
public static void main(String[] args) {
//创建File对象
File file1 = new File("D:/SAM");//没有文件类型，就是目录
System.out.println(file1.mkdir());//创建单级目录
File file12 = new File("D:/S/m/q");//没有文件类型，就是目录
System.out.println(file12.mkdirs());//mkdirs创建多级目录
System.out.println(file1.isFile());//判断是不是一个文件
System.out.println(file1.exists());//查询目录是否存在
System.out.println(file1.isDirectory());//判断当前路径是否为目录
System.out.println(file12.getParentFile());
System.out.println(file12.getParentFile().getName());///调用单级目录可能不输出
;//
File file2 = new File("d:/");//注意文件的格式 “d:/”
String[] srr = file2.list();
//String temp="ff";
for (String temp : srr) {//返回所有文件与目录
System.out.println(temp);
}
System.out.println("################################");
File[] arr2=file2.listFiles();
for(File temp:arr2)
{
System.out.println(temp);
}
}
}
3常用流对象
3.1文件字节流
可以处理所有文件（所有文件都是数字）。
3.11读取图片文件（文件字节流输入）
package javaio;
import java.io.File;
import java.io.FileInputStream;
//读取文本文件
public class fileinputstream {
public static void main(String[] args) {
//几乎固定模板//
FileInputStream fis4 = null;
try {//创建文件字节输入流
fis4=new FileInputStream("d:/实验图片.jpg");
int temp=0;
while((temp=fis4.read())!=-1)//未读完时会返回（0-255）之间的数组，有时还需要一个容器进行接收
{
System.out.println(temp);
}
} catch (Exception e)
{
e.printStackTrace();
} finally {
try {
if (fis4 != null) {//不等于空，就把它关了？
fis4.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
//输出图片贼长的int类型不过在（0~255）之间。
3.12复制文件位置（文件字节流输出）
输出必先有输入
package javaio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class fileoutputstream {
public static void main(String[] args) {
FileInputStream fis5 = null;
FileOutputStream fos = null;
try {
fis5 =new FileInputStream("d:/实验图片.jpg");
fos=new FileOutputStream("d:/复制图片位置.jpg");
int temp =0;
while((temp=fis5.read())!=-1) {
fos.write(temp);
}//将数据从内存写入磁盘
fos.flush();//清空缓存区的残留文件，详见http://t.csdn.cn/gqQKO
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis5!=null) {
fis5.close();
}
if(fos!=null)
{
fos.close();
}
}catch (Exception e ) {
e.printStackTrace();
}
}
}
}
3.13通过缓冲区提高读写效率（建立缓冲区）
之前：一次一个一个字节搬。
之后：一次2的N次（1024等等）方方个字节搬
通过创建一个指定长度的字节数组作为缓冲区，以此来提高 IO 流的读写效率。该方式 适用于读取较大图片时的缓冲区定义。一般情况下 1024 长度较为合适。
一般用于大文件。
方法1
buff意为缓冲。
搬大米。
package javaio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class quickfileoutputstream {
public static void main(String[] args) {
FileInputStream fis5 = null;
FileOutputStream fos = null;
try {
fis5 =new FileInputStream("d:/瀑布.jpg");//创建输入流
fos=new FileOutputStream("d:/复制瀑布位置.jpg");//创建输出流
/
byte[]buff=new byte[2048];//创建缓冲区，提高读写效率。【创建拿大米的包】
/
int temp =0;
// while((temp=fis5.read())!=-1) {//返回当前数组长度
while((temp=fis5.read(buff))!=-1) {//返回当前数组长度【把大米放入包里】
//fos.write(temp);//改进
fos.write(buff,0,temp);//循环一次，从buff数组里面读，从0开始读，读到temp大小
}//将数据从内存写入磁盘
fos.flush();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis5!=null) {
fis5.close();
}
if(fos!=null)
{
fos.close();
}
}catch (Exception e ) {
e.printStackTrace();
}
}
}
}
3.14方法2（一次性搬完available()）
适用于小文件（大文件占用内存）
不需要while循环。
通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的 available()返回当前 文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的
package javaio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class twoquickfileoutput {
public static void main(String[] args) {
FileInputStream fis5 = null;
FileOutputStream fos = null;
try {
fis5 =new FileInputStream("d:/瀑布.jpg");//创建输入流
fos=new FileOutputStream("d:/复制f瀑布位置.jpg");//创建输出流
/
//改为 读取预估大小长度进行
byte[]buff=new byte[fis5.available()];//创建缓冲区，提高读写效率。
fis5.read(buff);//读入
fos.write(buff);//写入
fos.flush();//将数据从内存写入磁盘
/
// int temp =0;
// while((temp=fis5.read())!=-1) {//返回当前数组长度
// while((temp=fis5.read(buff))!=-1) {//返回当前数组长度
// //fos.write(temp);//改进
// fos.write(buff,0,temp);//写入内存
// }
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(fis5!=null) {
fis5.close();
}
if(fos!=null)
{
fos.close();
}
}catch (Exception e ) {
e.printStackTrace();
}
}
}
}
可以正常读入
3.15通过字节缓冲流提高读写效率（BufferedInputStream，BufferedOutputStream）
本身不具有io流的读写，只是在别的流加缓冲功能提高效率。就像是把别的流包装起来，因此缓冲流是一种处理流。
适用于对数据进行频繁读写操作时。
原理：当对文件或者其他数据源进行频繁的读写操作时**，效率比较低，这时如果使用缓冲流就** 能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷 新时再一次性的读取到程序或写入目的地
package javaio;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class 拷贝文件 {
public static void main(String[] args) {
FileInputStream fis =null;
FileOutputStream fos=null;
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try{
fis=new FileInputStream("D:/瀑布.jpg");//节点流创建
bis=new BufferedInputStream(fis);//处理流
fos=new FileOutputStream("D:/FF.jpg");
bos=new BufferedOutputStream(fos);
int temp=0;
//缓冲流中的 byte 数组长度默认是 8192
while((temp=bis.read())!=-1)
{
bos.write(temp);
}
bos.flush();
}catch(Exception e)
{
e.printStackTrace();
}finally {
try {//关闭顺序：后开先关闭，只是基于节点流与处理流之间的比较，节点流与节点流之间没有先后关闭顺序要求，处理流之间同理。
if(bis!=null)
{
bis.close();
}
if(fis!=null)
{
fis.close();
}
if(bos!=null)
{
bos.close();
}
if(fos!=null)
{
fos.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.16定义文件拷贝工具类
package javaio;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class 自定义文件拷贝工具类 {
public static void main(String[] args) {
copyFile("d:/瀑布.jpg","d:/少了-1.jpg");
}
/*
*文件拷贝方法
*/
public static void copyFile(String src,String des){
FileInputStream fis =null;
BufferedInputStream bis=null;
FileOutputStream fos=null;
BufferedOutputStream bos=null;
try{
//fis=new FileInputStream(src);//接收数据
//bis=new BufferedInputStream(new FileInputStream(src));
bis=new BufferedInputStream(new FileInputStream(src));
bos=new BufferedOutputStream(new FileOutputStream(des));
int temp=0;
while((temp=bis.read())!=-1)//草
{
bos.write(temp);
}
bos.flush();
}catch(Exception e)
{
e.printStackTrace();
}finally {
try {//后开，先关闭
if(bis!=null)
{
bis.close();
}
if (fis!=null)
{
fis.close();
}
if(bos!=null)
{
bos.close();
}
if(fos!=null)
{
fos.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.2文件字符流
处理的是文本文件
3.21文件字符输入流 FileReader
package javaio;
import java.io.FileReader;
public class 文件字符流 {
public static void main(String[] args) {
FileReader frd = null;
try {//创建文件字符输入流
frd = new FileReader("d:/a.txt.txt");
int temp = 0;
while ((temp = frd.read()) != -1) {//返回文本文件uncode的值，而字节流返回的就是字节数
// frd.read();
System.out.println((char) temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (frd != null) {
frd.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
3.22文件字符输出流
文件字符输入流，不需要输入，要程序在执行框里面输出
*//（系统发现没有输入的文件名时，会把文件创建出来，创建出来也可以写入，不过之前写的会被覆盖）
要想不被覆盖则添加新参数 fw2 = new FileWriter(“d:/sxt.txt”,true);
package javaio;
//文件字符输入流，不需要输入，要程序在执行框里面输出
import java.io.FileReader;
public class 文件字符流 {
public static void main(String[] args) {
FileReader frd = null;
try {//创建文件字符输入流
frd = new FileReader("d:/a.txt.txt");
// int temp = 0;
// while ((temp = frd.read()) != -1) {
// // frd.read();
// System.out.println((char) temp);
// }
int temp=0;
while((temp=frd.read())!=-1)
{
System.out.println(temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (frd != null) {
frd.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
3.23问题
在try catch外面定义FiileWriter会报错，在里面Finaly里面无法关闭。所以依照上面代码就ok。
try { FileWriter fw = new FileWriter("d:/sxt.txt");
fw=null;
fw.write("百变小樱");
fw.flush();
}catch (Exception e) {
e.printStackTrace();
}finally {//因为要关闭对象，close也会出现隐异常
try
{
fw.close();
//文件字符输出流2.java
//找不到符号
3.24使用字符流实现文本文件拷贝
package javaio;
import java.io.FileReader;
import java.io.FileWriter;
public class 使用字符流实现文本文件拷贝 {
public static void main(String[] args) {
FileReader fr=null;
FileWriter fw=null;
try {
fr =new FileReader("D:/a.txt.txt");
fw=new FileWriter("D:/aaaaa.txt");
//
char[] buffer=new char[1024];//改进,读到buffer数组里面
//
int temp=0;
// while((temp=fr.read())!=-1)
// {
// fw.write(temp);
// }
while ((temp=fr.read(buffer))!=-1)
{
fw.write(buffer,0,temp);//写，从buffer中从0写到temp(所有长度)。
}
fw.flush();
}catch(Exception e)
{
e.printStackTrace();
}finally {
try {//对于输入流与输出流关闭谁都可以。
if(fr!=null)
{
fr.close();
}
if(fw !=null)
{
fw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.25字符输入缓冲流
。
package javaio;
import java.io.BufferedReader;
import java.io.FileReader;
public class 字符输入缓冲流 {
public static void main(String[] args) {
FileReader fr=null;
BufferedReader br=null;
try {
fr=new FileReader("D:/a.txt.txt");
br=new BufferedReader(fr);//套壳
String temp="";//int temp=0;异曲同工
while ((temp=br.readLine())!=null)//因为readline返回是string类型，所以用null
//返回的字符串是它在文件里所读取的一行。
{
// br.read();
System.out.println(temp);
}
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(br!=null)
{
br.close();
}
if(fr!=null)
{
fr.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.26字符输出缓冲流
bw.newLine();//换行
package javaio;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class 字符输出缓冲流 {
public static void main(String[] args) {
FileWriter fw=null;
BufferedWriter bw=null;
try {
fw=new FileWriter("D:/通达.txt");
bw=new BufferedWriter(fw);
/
bw.write("辅导员退退退");//输入东西。
bw.write("北有清华，南有通达");
bw.newLine();//换行
bw.write("还是上网课好");
bw.flush();
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(bw!=null)
{
bw.close();
}
if(fw!=null)
{
fw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.27实现文本文件的拷贝
//关闭顺序没有要求，（后开先关闭，只存在于处理流与节点流之间的比较）。
package javaio;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class 基于字符缓冲流实现文件拷贝 {
public static void main(String[] args) {
filecopychar("d:/a.txt.txt","d:/q.txt");
}
public static void filecopychar(String src,String des)
{
BufferedReader br=null;
BufferedWriter bw =null;
try {
br=new BufferedReader(new FileReader(src));
bw=new BufferedWriter(new FileWriter(des));
String temp="";
while ((temp=br.readLine())!=null)//temp读入文件//因为readline返回是string类型，所以用null
//返回的字符串是它在文件里所读取的一行。
{
//bw.write(src);//这句话代表写入什么东西。而src只是一个string字符。
bw.write(temp);//代表读入字符。
bw.newLine();//换行处理。
}
bw.flush();
}catch (Exception e)
{
e.printStackTrace();
}finally {//关闭顺序没有要求，后开先关闭，只存在于处理流与节点流之间的比较
try {
if(br!=null)
{
br.close();
}
if(bw!=null)
{
bw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3.28为文件中的内容添加行号
package javaio;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
public class 为文件中的内容添加行号 {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader("d:/a.txt.txt"));
bw = new BufferedWriter(new FileWriter("d:/abc.txt.txt"));
String temp = "";
int i=1;
while ((temp = br.readLine()) != null)//temp读入文件
{
// System.out.println();
//bw.write(src);//这句话代表写入什么东西。而src只是一个string字符。
bw.write(i+","+temp);//代表写入字符。
bw.newLine();//换行处理。
i++;
}
bw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (bw != null) {
bw.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
4转换流
InputStreamReader/OutputStreamWriter 用来实现将字节流转化成字符流
system.in/system.out为字节流对象，如果我们想按行接收用户的输入时，就必 须用到缓冲字符流 BufferedReader 特有的方法 readLine()，但是经过观察会发现在创建 BufferedReader 的 构 造 方 法 的 参 数 必 须 是 一 个 Reader 对 象 ， 这 时 候 我 们 的 转 换 流 InputStreamReader 就派上用场了。
4.11通过转换流实现键盘输入屏幕输出
加入了System.in/System.out
System.in会返回一个inputstream类型，虽然inputstream不可以实例化。
inputst ip=system.in
try {
InputStream is=System.in;//基于字节的方式来获取用户在键盘所输入的类容
int inputa=is.read();
System.out.println(inputa);
system.in会获取用户输入的字节文件，为了读出一行，要转化为字符型。
关于equals详见http://t.csdn.cn/4QjtZ
目的是为了一次读取一行
package javaio.转换流;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class 通过转换流实现键盘输入屏幕输出 {
public static void main(String[] args) {
BufferedWriter bw=null;
BufferedReader br=null; //为了获取一行，定义字符输入缓冲流
try { //system是标准输入流（int型）
br=new BufferedReader(new InputStreamReader(System.in));//输入流读取器（转化为string类型）//InputStreamReader把字节流转换为字符
bw=new BufferedWriter(new OutputStreamWriter(System.out));
//System.out.println(input);
while (true) {
bw.write("请输入：");
// bw.flush();
String input = br.readLine();
if("exit".equals(input))//判断是否相等
{
break;
}
bw.write("you input is"+input);
bw.newLine();
bw.flush();
}
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(bw!=null)
{
bw.close();
}
if(br!=null)
{
br.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
注意：
BufferedReader br=null; //为了获取一行，定义字符输入缓冲流
//system是标准输入流（int型）
bw=new BufferedWriter(new OutputStreamWriter(System.out));
String input=br.readLine();
bw.write(input);
bw.flush();
与` 功能一致
String input=br.readLine();
System.out.println(input);
4.12通过字节流读取文件并添加行号
package javaio.转换流;
import java.io.*;
public class 通过字节流读取文件并添加行号 {
public static void main(String[] args) {
BufferedReader br=null;
BufferedWriter bw=null;
try {
br =new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt.txt")));
bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:/qq.txt")));
String temp="";
int i=1;
while ((temp=br.readLine())!=null)
{
bw.write(i+","+temp);
bw.newLine();
i++;
}
bw.flush();
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(br!=null)
{
br.close();
}
if(bw!=null)
{
bw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
4.2字符输出流 PrintWriter
该对象具有自动行刷 新缓冲字符输出流，特点是可以按行写出字符串，并且可通过 println();方法实现自动换行
package javaio.转换流;
import java.io.*;
//
public class 字符输出流 {
public static void main(String[] args) {
BufferedReader br=null;
PrintWriter pw=null;
try {
br=new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt.txt")));
pw=new PrintWriter("D:/jjj.txt");//PipedWriter本身就是节点流，不用做节点流包装。
String temp="";
int i=1;
while ((temp=br.readLine())!=null)
{
pw.println(i+","+temp);
i++;
}
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if(br!=null) {
br.close();
}
if(pw!=null)
{
pw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
4.21字节数组输入流 ByteArrayInputStream 和 ByteArrayOutputStream
经常用在需要流和数组之间转化的情况。
不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly。
package javaio.转换流;
/、、、、、、、、、、、、、、、、、、、、、、
import java.io.ByteArrayInputStream;
//不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly
public class 字节数组输入流 { /其实是字节数组输入流
public static void main(String[] args) {
byte[] arr="abcdefg".getBytes();//完成字节数组。
ByteArrayInputStream bis=null;
StringBuilder sb=new StringBuilder();
try {//改构造方法的参数是一个字节数组，这个字节数组就是数据源
bis=new ByteArrayInputStream(arr);
int temp=0;
while ((temp=bis.read())!=-1)
{
sb.append((char) temp);
}
System.out.println( sb.toString());
}finally {
try {
bis.close();
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
4.22字节数组输出流 ByteArrayInputStream
FileInputStream 是把文件当做数据源。ByteArrayInputStream 则是把内存中的” 字节数组对象”当做数据源
package javaio.转换流;
/、、、、、、、、、、、、、、、、、、、、、、
import java.io.ByteArrayOutputStream;
//不会有编译异常出现，所以不用try catch ，但要关闭所以用try ——finaly
public class 字节数组输出流正版 { /其实是字节数组输入流
public static void main(String[] args) {
ByteArrayOutputStream bos=null;
try {//改构造方法的参数是一个字节数组，这个字节数组就是数据源
StringBuilder sb=new StringBuilder();
bos=new ByteArrayOutputStream();//输出不需要参数
bos.write('f');//写入
bos.write('q');
bos.write('e');
bos.write('t');
bos.write('y');
byte[] arr= bos.toByteArray();//基于字节形式放到了数组当中
for(int i=0;i<arr.length;i++)
{
//System.out.println(arr[i]);
sb.append((char)arr[i] );
}
System.out.println(sb.toString());
}finally {
try {
if(bos!=null) {
bos.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
5数据流DataInputStream 和 DataOutputStream
数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式 从底层输入输出流中操作 Java 基本数据类型与字符串类型。
成功避免了当输入输出时还要进行数据转换的问题。
5.1数据输出流DataInputStream
package javaio.数据流;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class dataoutput {
private static DataOutputStream dos;
private static DataOutputStream dos1;
public static void main(String[] args) {
dos = null;
try {
dos =new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/qq.txt"))) ;
dos.writeChar('a');
dos.writeInt('a');
dos.writeDouble('a');
dos.writeBoolean(true);
dos.writeUTF("我擦");
dos.flush();
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(dos !=null)
{
dos.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
5.2数据输入流 DataOutputStream
注意要按照写入顺序。
package javaio.数据流;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
public class datainputstream {
public static void main(String[] args) {
DataInputStream dis=null;
try {
dis=new DataInputStream(new BufferedInputStream(new FileInputStream("d:/qq.txt")) );
//直接读取数据，读取顺序与写入一致，
System.out.println("char"+dis.readChar());
System.out.println("整型"+dis.readInt());
System.out.println("浮点"+dis.readDouble());
System.out.println("bool"+dis.readBoolean());
System.out.println("文字"+dis.readUTF());
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(dis!=null)
{
dis.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
6对象流ObjectOutputStream ObjectInputStream
将对象存储到 硬盘上的文件（序列化），将对象通过网络传输到另一个电脑（反序列化）。
只有实现了 Serializable 接口的类的对象才能被序列化。Serializable 接口是一个空接口， 只起到标记作用。
序列化和反序列化是什么
二进制文件的编码与解码。
6.1操作基本数据类型
6.11写出基本数据类型数据
package javaio.数据流;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class 写出基本数据类型 {
public static void main(String[] args) {
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/a.txt")));
oos.writeChar('a');
oos.writeInt('a');
oos.writeDouble('a');
oos.writeBoolean(true);
oos.writeUTF("我擦");
oos.flush();
} catch (Exception e) {
e.printStackTrace();
try {
} finally {
try {
if (oos != null) {
oos.close();
}
} catch (Exception g) {
g.printStackTrace();
}
}
}
}
}
6.12读基本数据类型
package javaio.对象流;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class 读基本数据类型对象 {
public static void main(String[] args) {
ObjectInputStream ois=null;
try {
ois=new ObjectInputStream(new BufferedInputStream(new FileInputStream("d:/a.txt")));
System.out.println(ois.readChar());
System.out.println(ois.readInt());
System.out.println(ois.readDouble());
System.out.println(ois.readBoolean());
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(ois!=null)
{
ois.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
6.2将对象序列化到文化
ObjectOutputStream可以将一个内存中的ava对象通过序列化的方式写入到磁盘的文
件中。被序列化的对象必须要实现Serializable序列化接口，否则会抛出异常。
6.21创建对象Serializable
public class users1 implements Serializable {
package javaio.对象流;
import java.io.Serializable;
//创建对象 此接口无任何抽象方法
public class users1 implements Serializable {
private int userid;
private String username;
private String userage;
public users1(int userid, String username, String userage) {
this.userid = userid;
this.username = username;
this.userage = userage;
}
public int getUserid() {
return userid;
}
public String getUsername() {
return username;
}
public String getUserage() {
return userage;
}
public void setUserid(int userid) {
this.userid = userid;
}
public void setUsername(String username) {
this.username = username;
}
public void setUserage(String userage) {
this.userage = userage;
}
}
6.22序列化对象ObjectOutputStream
package javaio.对象流;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class objectoutstreamobjectty {
public static void main(String[] args) {
ObjectOutputStream oos=null;
try { //一定需要一个字节输出流对象。。因为是二进制文件。
oos=new ObjectOutputStream(new FileOutputStream("d:/qqq.txt"));
users user=new users(1,"xiaomi","three");
oos.writeObject(user);//ObjectOutputStream下面的writrobject，
oos.flush();
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(oos!=null)
{
oos.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
6.23将对象反序列化到磁盘当中ObjectInputStream
package javaio.对象流;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class objectinpuctstream {
public static void main(String[] args) {
ObjectInputStream ois=null;
try {
ois=new ObjectInputStream((new FileInputStream("D:/qqq.txt")));
users user = (users) ois.readObject();
System.out.println(user.getUserid());
System.out.println(user.getUsername());
System.out.println(user.getUserage());
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(ois!=null)
{
ois.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
6.3随机访问流
- 实现对一个文件的读写。
- 可以访问文件的任意位置，不像其他牛只能按照先后顺序读取。适用于客户端。
- RandomAccessFile(String name, String mode) name 用来确定文件； mode 取 r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
- seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头的字节个数。
getFilePointer() 获得流的当前读写位置
package javaio;
import java.io.RandomAccessFile;
public class 随机访问流 {
public static void main(String[] args) {
RandomAccessFile raf=null;
try {
raf =new RandomAccessFile("d:/qqq.txt","rw");
//写入文件当中
int [] arr=new int[]{1,23,44,56,5,4,67,8};
for(int i=0;i<arr.length;i++)
{
raf.writeInt(arr[i]);
}
//访问
raf.seek(8);//注意不是数组下标，而是字节如int为4个字节，只能是0 ，4,8，。。。。。
// System.out.println(raf.readInt());
//交替打印
for(int i=0;i<8;i+=2)
{
raf.seek(i*4);
System.out.println(raf.readInt()); //输出指定位置
}
//替换以前某位置文件。
System.out.println("***************");
raf.seek(8);//定位
raf.writeInt(876);//赋值
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
6.5file在IO中的作用
当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我 们也可以使用 File 类指定.
package javaio.fail;
import java.io.*;
public class failinio {
public static void main(String[] args) {
BufferedReader br=null;
BufferedWriter bw=null;
try {
// br=new BufferedReader(new FileReader("d:/qqq.txt"));//以前
br=new BufferedReader(new FileReader(new File("d:/a.txt.txt")));//现在
bw=new BufferedWriter(new FileWriter(new File("d:/qqq.txt")));
String temp="";
int i=1;
while ((temp=br.readLine())!=null)
{
bw.write(i+","+temp);
bw.newLine();
i++;
}
}catch (Exception e)
{
e.printStackTrace();
}finally {
try {
if(br!=null)
{
br.close();
}
if(bw!=null)
{
bw.close();
}
}catch (Exception e)
{
e.printStackTrace();
}
}
}
}
7阿帕奇包的应用
7.1使用
package javaio.apacheio包;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.FileFilter;
public class fileutilsdemo {
public static void main(String[] args) throws Exception{
//文件输出
// new InputStreamReader(new FileInputStream("d:/a.txt","utf-8"));
//这玩意被弃用了？
// String content= FileUtils.readFileToString(new File("d:/qqq.txt","utf-8"));
// System.out.println(content);
//文件拷贝
FileUtils.copyDirectory(new File("D:/XXX"),new File("c:/www"),(new FileFilter() {
@Override
//在文件拷贝时过滤条件
public boolean accept(File pathname) {
if(pathname.isDirectory()||pathname.getName().endsWith("txt"))
{
return true;
}
return false;
}
}) );
}
}
7.2IOUtils使用
package javaio.apacheio包;
import org.apache.commons.io.IOUtils;
import java.io.FileInputStream;
public class ioutils {
public static void main(String[] args) throws Exception{
String contrnt= IOUtils.toString(new FileInputStream("d:/q.txt"),"utf-8" );
System.out.println(contrnt);
}
}