黑马程序员——Java IO流

来源：互联网发布：java 写excel换行编辑：程序博客网时间：2024/05/01 18:46

------- android培训、java培训、期待与您交流！ ----------

IO流

按流向分为：输入和输出流。按操作数据分为两种：字节流和字符流。

IO流用来处理设备之间的数据传输。

字节流的抽象基本类：InputStream，OutputStream。

InputStream：是表示字节输入流的所有类的超类。

|--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

|--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

|--- BufferedInputStream：该类实现缓冲的输入流。

|--- Stream：

|--- ObjectInputStream：

|--- PipedInputStream：

-----------------------------------------------

OutputStream：此抽象类是表示输出字节流的所有类的超类。

|--- FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。

|--- FilterOutputStream：此类是过滤输出流的所有类的超类。

|--- BufferedOutputStream：该类实现缓冲的输出流。

|--- PrintStream：

|--- DataOutputStream：

|--- ObjectOutputStream：

import java.io.*;
class ObjectStreamDemo01
{
public static void main(String[] args) throws Exception
{
readObj();
}
public static void readObj() throws Exception
{
//
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Person p = (Person)ois.readObject();//强转成person类型
System.out.println(p);
ois.close();
}
public static void writeObj() throws IOException
{
//ObjectOutputStream做出的文件只能用ObjectInputStream读取
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

oos.writeObject(new Person("lisi01",22));
oos.close();

}
}

|--- PipedOutputStream：

import java.io.*;
class PipedStreamDemo01
{
public static void main(String[] args) throws IOException
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();//建立管道输出输入流对象
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
class Read implements Runnable
{
private PipedInputStream in;

Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
//定义数组读取数据

byte[] buf = new byte[1024];
System.out.println("等待数据，阻塞");
int len = in.read(buf);
System.out.println("拿到数据，阻塞结束");
String s = new String(buf,0,len);//将数组中的有效数据转化成字符串
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;

}
public void run()
{
try
{
//写入数据
System.out.println("即将开始写入，请等待");
Thread.sleep(6000);
out.write("guandaoliale".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道写入流失败");
}
}
}

字符流的抽象基本类：Reader，Writer。

Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。

|---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

|---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。

|---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

|---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

|---CharArrayReader：

|---StringWriter：

Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。

|---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

|---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

|---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

|---PrintWriter：

|---CharArrayWriter：

|---StringWriter：

数据最常见的体现形式。

flush()：刷新流。close()。关闭流，在关闭之前会刷新流一次。

IO的异常处理

在代码中的体现方式。

import java.io.*;
class CopyDemo01
{
public static void main(String[] args)
{
copy();
}
public static void copy()
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("F:\\Demo.txt");//关联输出流
fr = new FileReader("F:\\test\\day01\\A.java");//关联输入流

char[] buf = new char[1024];//定义数组读取
int len =0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);//读取数组有效长度数据
}
}
catch (IOException e)
{

//处理异常
System.out.println("读写失败");
}
finally
{
if(fw!=null)
try
{
fw.close();
}
catch (IOException e)
{
}
} if(fr!=null)
try
{
fr.close();
}
catch (IOException e)
{
}
}
}

字符流缓冲区

缓冲区的出现提高了对数据的读写效率。

对应类

BufferedWriter和BufferedReader

缓冲区要结合流才可以使用。

关闭缓冲区就是关闭流。缓冲区在流的基础上对流的功能进行增强。

BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。

FileWriter fw = new FileWriter("bufdemo.txt");

BufferedWriter bufw = new BufferedWriter(fw);//让缓冲区和指定流相关联。

for(int x=0; x<4; x++){

bufw.write(x+"abc");

bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。

bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。

}

bufw.close();//关闭缓冲区，其实就是在关闭具体的流。

-----------------------------

BufferedReader：

FileReader fr = new FileReader("bufdemo.txt");

BufferedReader bufr = new BufferedReader(fr);

String line = null;

while((line=bufr.readLine())!=null){ //readLine方法返回的时候是不带换行符的。

System.out.println(line);

}

bufr.close();

-----------------------------

//记住，只要一读取键盘录入，就用这句话。

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

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//输出到控制台

String line = null;

while((line=bufr.readLine())!=null){

if("over".equals(line))

break;

bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出

bufw.newLine();

bufw.flush();

}

bufw.close();

bufr.close();

------------------------------

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的的操作规律。

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有功能，并提供加强功能。那么自定义的类称为装饰类。

装饰模式比继承要灵活，避免继承的体系臃肿，而且还降低了类与类之间的关系。

字节流

想要操作图片数据，这时就要用到字节流。

流操作的基本规律：

1：明确源和目的，源：输入流 InputStream Reader

2：操作的数据是否为纯文本。是使用字符流不是使用字节流。

3：当体系明确后再明确使用那个具体对象。通过设备区分：源设备：内存，硬盘，键盘。目的设备：内存，硬盘，控制台。

字符流和字节流之间的桥梁：转换流为InputStreamReader和OutputStreamWriter。

import java.io.*;
public class Test04 {
public static void main(String[] args){
System.out.println("请输入阿拉伯数字");
//定义缓冲区
BufferedReader bufr = null;
BufferedWriter bufw = null;
//捕捉异常
try{
bufr = new BufferedReader(new InputStreamReader(System.in));
//使用转换流来将字节流System.in和System.out转换成字符流
bufw = new BufferedWriter(new OutputStreamWriter(System.out));
//定义一个char数组使用查表法
char[] chs = {'零','一','二','三','四','五',
'六','七','八','九'};
String line = null;
//读取数据
while((line = bufr.readLine())!=null){
if("over".equals(line))
break;
//将读取的字符串转化为数组，就能操作角标了。
char[] arr = line.toCharArray();

for (int i = 0; i < arr.length; i++) {
//将数组中角标对应的至转化成字符串再转化成int类型值就可以查表了。
String led = new String(new char[]{arr[i]});
int index = Integer.parseInt(led);

bufw.write(chs[index]);
//刷新流
bufw.flush();
}
}
}
//处理异常
catch(Exception e){
throw new RuntimeException("读取失败，输入值为非法值");
}
finally{
try{
if(bufr!=null)
bufr.close();
}//关闭流
catch(Exception e){
throw new RuntimeException("读取流关闭失败");
}
if (bufw != null)
try {
bufw.close();
} catch (IOException e2) {
throw new RuntimeException("输出流关闭失败");
}

}

File类

用来将文件或者文件夹封装成对象，方便对文件以及文件夹的属性信息进行操作。

File对象可以作为参数传递给留得构造函数。

File类常见方法：

1：创建。

boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

boolean mkdir()：创建此抽象路径名指定的目录。

boolean mkdirs()：创建多级目录。

2：删除。

boolean delete()：删除此抽象路径名表示的文件或目录。

void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

long length()：获取文件大小。

String getName()：返回由此抽象路径名表示的文件或目录的名称。

String getPath()：将此抽象路径名转换为一个路径名字符串。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。

4：判断：

boolean exists()：判断文件或者文件夹是否存在。

boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

import java.io.*;
class FileDemo02
{
public static void main(String[] args)
{
consMethod();//调用方法
}
public static void consMethod()
{
File f1 = new File("F:"+File.separator+"demo\\a.txt");//"+File.separator+"
File f2 = new File("F:"+File.separator+"demo","b.txt");//为跨平台的目录分隔符，\\只是windows中的分隔符
File d = new File("F:\\demo");
File f3 = new File(d,"c.txt");
System.out.println("f1="+f1);
System.out.println("f2="+f2);
System.out.println("f3="+f3);

}

------- android培训、java培训、期待与您交流！ ----------

0 0