黑马程序员—JavaIO流

最新推荐文章于 2024-11-09 12:43:52 发布

yefeng2012417

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量237

点赞数

分类专栏： java学习文章标签： string class import system io java

本文链接：https://blog.csdn.net/yefeng2012417/article/details/7585288

版权

java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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

Input Output 流
1、IO概述
IO流用来处理设备之间的数据传输
java对数据的操作是通过流的方式
java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流。
流按流向分为：输入流，输入流。
2、IO流常用基类
字节流的抽象基类：InputStream，OutputStream。
字符流的抽象基类：Reader，Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream；Reader的子类FileReader。
3、字符流——创建文件
创建流对象，建立数据存放文件：FileWriter fw = new FileWriter(“test.txt”);
调用流对象的写入方法，将数据写入流：fw.write(“text”);
关闭流资源，并将流中的数据清空到文件中：fw.close();
代码如下：
public class IODemo {
public static void main(String[] args){
FileWriter fw = null;
try {
fw = new FileWriter("Test.txt");
fw.write("text");
}
catch(IOException e){
System.out.println(e.toString());
}
finally{
if(fw != null)
try{
fw.close();
}
catch(IOException e){
System.out.println(e.toString());
}
}
}
}

4、字符流——读取文件
建立一个流对象，将已存在的一个文件加载进流:FileReader fr = new FileReader(“Test.txt”);
创建一个临时存放数据的数组：char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组中：fr.read(ch);
代码如下：
public class IODemo2 {
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("c:\\test.txt");
char[] buf = new char[1024];
int len = 0;
while(len=fr.read(buf) != -1) {
System.out.printn(new String(buf,0,len));

}

}
catch(IOException e) {
System.out.println("read-Exception:"+e.toString());
}
finally {
if(fr != null) {
try {
fr.close();
}
catch(IOException e) {
System.out.println("close-Exception:"+e.toString());
}
}
}

}
}
5、字符流的缓冲区
缓冲区的出现提高了对数据的读写效率。
对应类：BufferedWriter，BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
6、转换流：InputStreamReader，OutputStreamWriter ：字符流与字节流之间的桥梁，方便了字符流于字节流之间的操作。字节流中的数据都是字符时，转成字符流操作更高效。
7、标准输入流输出流
System类中的字段：in，out。
它们个代表了系统标准的输入和输出设备。
默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream。
System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。
例：获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的。通过System类的setIn，setOut方法对默认设备进行改变。
通过System类的setIn，setOut方法对默认设备进行改变。
System.setIn(new FileInputStream("1.txt"));//将源改成文件1.txt。
System.setOut(new FileOutputStream("2.txt"));//将目的改成文件2.txt.
因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。
BfferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
流的基本应用
（1）流是用来处理数据的。
（2）处理数据时，一定要先明确数据源，与数据目的地（数据汇）。
（3）数据源可以是文件，可以是键盘。
（4）数据目的地可以是文件、显示器或者其他设备。
（5）而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理.转换处理等。
9、File类
（1）用来将文件或者文件夹封装成对象；
（2）方便对文件与文件夹的属性信息进行操作；
（3）File对象可以作为参数传递给流的构造函数。
10、IO异常处理方式
在一个简单IO程序中，我们会用到一些基本的语句：
（1）FileWriter fw = new FileWriter("demo.txt");
（2）fw.write("abcdefg");
（3）fw.close();
我们知道以上三个语句都是有异常抛出的，语句1中的路径不正确，语句2中的空间不足，以及语句3的使用后再调用语句2也会抛异常等等，那我们怎么样来处理这些异常呢？一种方式是在函数上直接抛出，虽然这种方式可以使程序正常编译，但这种方式是不合适的，真正的处理方式是下面的示例：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
我们知道在上面的try内的三条语句是有关联的，所以不需要对每一句都进行try和catch语句的处理，将他们三条语句放在一个try中就可以了，但是上面的语句中如果出现异常就被catch处理了，可是他所占的资源还在，这就需要用close进行流的关闭。所以应将close语句放在下面的finally语句中，如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
fw.close();
}

}
}
思路上这个代码好像没问题了，但其实他是有问题的，一个是对于try块内的对象fw在finally内是无法使用的，编译会提示在finally内找不到符号fw；另一个就是fw.close()语句本身也是有异常的，所以在finally内还是要再处理的。对于问题一，我们可以将创建对象语句放在try语句的外面，在外面只创建它的引用，而在try内进行初始化，因为初始化语句也是抛出异常的，都放在try外是不合适的。对于问题二，我们就是在finally内单独处理一次就可以了，修改后代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}

}

}
}
这样处理异常就可以了，但是在try内如果初始化不成功，比如路径不正确，那么对于finally内一定要执行的语句就会出现另一个非IO异常，java.lang.NullPointerException 。因为初始化不成功，在finally内就不能调用close语句进行流的关闭。所以在finally内应进行判断，判断fw是否初始化成功。标准的处理程序应该是：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if (fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}

}

}
}
当然对于多对象的程序应进行分别判断再处理，不应在判断语句中一起进行处理。

1、IO概述
IO流用来处理设备之间的数据传输
java对数据的操作是通过流的方式
java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流。
流按流向分为：输入流，输入流。
2、IO流常用基类
字节流的抽象基类：InputStream，OutputStream。
字符流的抽象基类：Reader，Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream；Reader的子类FileReader。
3、字符流——创建文件
创建流对象，建立数据存放文件：FileWriter fw = new FileWriter(“test.txt”);
调用流对象的写入方法，将数据写入流：fw.write(“text”);
关闭流资源，并将流中的数据清空到文件中：fw.close();
代码如下：
public class IODemo {
public static void main(String[] args){
FileWriter fw = null;
try {
fw = new FileWriter("Test.txt");
fw.write("text");
}
catch(IOException e){
System.out.println(e.toString());
}
finally{
if(fw != null)
try{
fw.close();
}
catch(IOException e){
System.out.println(e.toString());
}
}
}
}

4、字符流——读取文件
建立一个流对象，将已存在的一个文件加载进流:FileReader fr = new FileReader(“Test.txt”);
创建一个临时存放数据的数组：char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组中：fr.read(ch);
代码如下：
public class IODemo2 {
public static void main(String[] args) {
FileReader fr = null;
try {
fr = new FileReader("c:\\test.txt");
char[] buf = new char[1024];
int len = 0;
while(len=fr.read(buf) != -1) {
System.out.printn(new String(buf,0,len));

}

}
catch(IOException e) {
System.out.println("read-Exception:"+e.toString());
}
finally {
if(fr != null) {
try {
fr.close();
}
catch(IOException e) {
System.out.println("close-Exception:"+e.toString());
}
}
}

}
}
5、字符流的缓冲区
缓冲区的出现提高了对数据的读写效率。
对应类：BufferedWriter，BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
6、转换流：InputStreamReader，OutputStreamWriter ：字符流与字节流之间的桥梁，方便了字符流于字节流之间的操作。字节流中的数据都是字符时，转成字符流操作更高效。
7、标准输入流输出流
System类中的字段：in，out。
它们个代表了系统标准的输入和输出设备。
默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream。
System.out的类型是PrintStream是OutputStream的子类FilterOutputStream的子类。
例：获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的。通过System类的setIn，setOut方法对默认设备进行改变。
通过System类的setIn，setOut方法对默认设备进行改变。
System.setIn(new FileInputStream("1.txt"));//将源改成文件1.txt。
System.setOut(new FileOutputStream("2.txt"));//将目的改成文件2.txt.
因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。
BfferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
流的基本应用
（1）流是用来处理数据的。
（2）处理数据时，一定要先明确数据源，与数据目的地（数据汇）。
（3）数据源可以是文件，可以是键盘。
（4）数据目的地可以是文件、显示器或者其他设备。
（5）而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理.转换处理等。
9、File类
（1）用来将文件或者文件夹封装成对象；
（2）方便对文件与文件夹的属性信息进行操作；
（3）File对象可以作为参数传递给流的构造函数。
10、IO异常处理方式
在一个简单IO程序中，我们会用到一些基本的语句：
（1）FileWriter fw = new FileWriter("demo.txt");
（2）fw.write("abcdefg");
（3）fw.close();
我们知道以上三个语句都是有异常抛出的，语句1中的路径不正确，语句2中的空间不足，以及语句3的使用后再调用语句2也会抛异常等等，那我们怎么样来处理这些异常呢？一种方式是在函数上直接抛出，虽然这种方式可以使程序正常编译，但这种方式是不合适的，真正的处理方式是下面的示例：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
我们知道在上面的try内的三条语句是有关联的，所以不需要对每一句都进行try和catch语句的处理，将他们三条语句放在一个try中就可以了，但是上面的语句中如果出现异常就被catch处理了，可是他所占的资源还在，这就需要用close进行流的关闭。所以应将close语句放在下面的finally语句中，如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
fw.close();
}

}
}
思路上这个代码好像没问题了，但其实他是有问题的，一个是对于try块内的对象fw在finally内是无法使用的，编译会提示在finally内找不到符号fw；另一个就是fw.close()语句本身也是有异常的，所以在finally内还是要再处理的。对于问题一，我们可以将创建对象语句放在try语句的外面，在外面只创建它的引用，而在try内进行初始化，因为初始化语句也是抛出异常的，都放在try外是不合适的。对于问题二，我们就是在finally内单独处理一次就可以了，修改后代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}

}

}
}
这样处理异常就可以了，但是在try内如果初始化不成功，比如路径不正确，那么对于finally内一定要执行的语句就会出现另一个非IO异常，java.lang.NullPointerException 。因为初始化不成功，在finally内就不能调用close语句进行流的关闭。所以在finally内应进行判断，判断fw是否初始化成功。标准的处理程序应该是：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
try
{
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdefg");

}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if (fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}

}

}
}
当然对于多对象的程序应进行分别判断再处理，不应在判断语句中一起进行处理。

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

详细请查看：http://edu.csdn.net/heima