IO流
IO流用来处理设备之间的数据传输，Java对数据的操作都是通过流的方式，而操作流的对象都在IO包中。
流按操作数据分为两种：字符流和字节流，按流向分为输入流和输出流。
字节流的抽象基类：InputStream，OutputStream。
字符流的抽象基类：Reader，Writer。
注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。如：InputStream的子类FileInputStream。Reader的子类FileReader。
字符流
创建文件，写入文件：
1，创建流对象，建立数据存放文件。
FileWriter fw = new FileWriter（"Test.txt"）;2，调用流对象的写入方法，将数据写入流
fw.write（"text"）;3，关闭流资源，并将流中的数据清空到文件中。
fw.close（）；完整的代码示例：
FileWriter fw = null；
try{
fw = new FileWriter（"text.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());
}
}读取文件
1，建立流对象，将已存在的一个文件加载进流。
FileReader fr = new FileReader("Test.txt")2，创建一个临时存放数据的数组。
char[] ch = new char[1024];3，调用流对象的读取方法将流中的数据读入到数组中。
fr.read(ch);完整的代码示例：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader("demo.txt");
//调用读取流对象的read方法。
//read():一次读一个字符。而且会自动往下读。
int ch = 0;
while((ch=fr.read())!=-1)
{
System.out.println(
}
/*
while(true)
{
int ch = fr.read();
if(ch==-1)
break;
System.out.println("ch="+(char)ch);
}
*/
fr.close();
}
}
注意：
1，在定义文件路径时，可以用“/”或者“\\”。
2，在创建一个文件时，如果目录下有同名文件将被覆盖。
3，在读取文件时，必须保证该文件已经存在，否则出异常。
字符流缓冲区
缓冲区的出现提高了对数据的读写效率。对应的类有BufferWriter和BufferReader。缓冲区必须要结合流才可以使用，它在流的基础上对流的功能进行了增强。
字符流缓冲区提供了一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");
//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null)
{
System.out.print(line);
}
bufr.close();
}
}字节流
字节流的基本操作和字符流相同，但它不仅可以操作字符，还可以操作其他媒体文件。类似于字符流，它有InputStream和OutputStream
import java.io.*;
class FileStream
{
public static void main(String[] args) throws IOException
{
readFile_3();
}
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
// int num = fis.available();
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
public static void readFile_1()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
public static void writeFile()throws IOException
{
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
fos.close();
}
}字节流缓冲区
同字符流缓冲区，它也是提高了字节流的读写效率。
import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf = new byte[1024*4];
private int pos = 0,count = 0;
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
//一次读一个字节，从缓冲区(字节数组)获取。
public int myRead()throws IOException
{
//通过in对象读取硬盘上数据，并存储buf中。
if(count==0)
{
count = in.read(buf);
if(count<0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;
}
else if(count>0)
{
byte b = buf[pos];
count--;
pos++;
return b&0xff;
}
return -1;
}
public void myClose()throws IOException
{
in.close();
}
}转换流
转换流是字符流和字节流之间的桥梁，它方便了字节流和字符流之间的操作。当字节流中的数据都是字符时，可以转成字符流进行操作更加高效。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
//InputStream in = System.in;
//将字节流对象转成字符流对象，使用转换流。InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);
//键盘的最常见写法。
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();
}
bufr.close();
}
}流操作的基本规律
最痛苦的就是流对象有很多，而我们不知道该用哪一个。
通过两个明确来完成：
1、明确源和目的
源：输入流InputStream ， Reader
目的：输出流OutputStream ， Writer
2、操作的数据是否纯文本。
是：字符流。
否：字节流。
3.当体系明确后，再明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。
这三个分别对应（ArrayStream，FileStream，System）
通常我们在设计到字符编码转换时，需要用转换流
另外转换流可以直接与流关联：键盘，控制台。
但不能直接与文件相关联，它与文件之间还需要加一个操作文件的流对象（FileInputStream，FileOutputStream或者FileReader，FileWriter）class TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("PersonDemo.java"));
System.setOut(new PrintStream("zzz.txt"));
//键盘的最常见写法。
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();
}
bufr.close();
}
}标准输入输出流
在System类中有in和out流对象，他们代表了系统标准的输入和输出设备。默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream， System.out的类型是PrintStream，它是OutputStream子类FileOutputStream的子类
键盘录入：
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));控制台输出：
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
流操作小结：
流是用来处理数据的，处理数据时，一定要明确数据源和数据目的地（数据汇）。
数据源可以是文件，也可以是键盘。
数据目的地可以是文件、显示器或者其他设备。
而流只是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。
File类
用来将文件或者文件夹封装成对象。它方便对文件和文件夹的属性信息进行操作。
File对象也可以作为参数传递给流的构造函数。
File类常见方法：
1，创建。
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2，删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3，判断。
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4，获取信息。
getName():
getPath():
getParent():
getAbsolutePath()
long lastModified()
long length()
class FileDemo
{
public static void main(String[] args) throws IOException
{
method_5();
}
public static void method_5()
{
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename:"+f2.renameTo(f1));
}
public static void method_4()
{
File f = new File("file.txt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
//如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void method_3()throws IOException
{
File f = new File("d:\\java1223\\day20\\file2.txt");
//f.createNewFile();
//f.mkdir();
//记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
//通过exists判断。
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());
sop(f.isAbsolute());
}
public static void method_2()
{
File f = new File("file.txt");
//sop("exists:"+f.exists());
//sop("execute:"+f.canExecute());
//创建文件夹
File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
sop("mkdir:"+dir.mkdirs());
}
public static void method_1()throws IOException
{
File f = new File("file.txt");
// sop("create:"+f.createNewFile());
//sop("delete:"+f.delete());
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和为出现的文件或者文件夹封装成对象。
File f1 = new File("a.txt");
//
File f2 = new File("c:\\abc","b.txt");
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
IO包中的其他类
RandomAccessFile
RandomAccessFile可以随机的访问文件，自身具备读写的方法。该类不能算是IO体系中的子类，因为它直接继承自Object，但它也是IO包中的成员，因为它具备读和写的功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。通过skipBytes（int x）和seek（int x）来达到随机访问的效果。其实完成读写的原理就是内部封装了字节输入流和输出流。
该类只能操作文件，而且操作文件有几种模式可选：只读r，读写rw等。如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile_2();
//readFile();
//System.out.println(Integer.toBinaryString(258));
}
public static void readFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
//调整对象中指针。
//raf.seek(8*1);
//跳过指定的字节数
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
raf.close();
}
public static void writeFile_2()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.seek(8*0);
raf.write("周期".getBytes());
raf.writeInt(103);
raf.close();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}管道流
pipedInputStream和pipedOutputStream，他们就像形同了管道，让输入输出连接起来，可以结合线程来使用。
import java.io.*;
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("开始写入数据，等待6秒后。");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
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();
}
}打印流
该流提供了打印方法，可以将各种数据类型的数据都原样打印。
字节打印流：PrintStream，构造函数可以接收的参数类型：1，file对象。File，2，字符串路径。String，3，字节输出流。OutputStream
字符打印流：PrintWriter，构造函数可以接收的参数类型：1，file对象。File，2，字符串路径。String，3，字节输出流。OutputStream，4，字符输出流，Writer。
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
//out.flush();
}
out.close();
bufr.close();
}
}序列流
SequenceInputstream，和SequenceOutputStream使用序列流可以将多个流合并。
import java.io.*;
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("开始写入数据，等待6秒后。");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
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();
}
}操作对象
ObjectInputStream和ObjectOutputStream，被操作的对象需要实现Serializable（标记接口）。
操作基本数据类型
DataInputStream和DataOutputStream可以用于操作基本数据类型的数据的流对象。
操作字节数组
用于操作字节数组的流对象。
ByteArrayInputStream ： 在构造的时候，需要接收数据源，而且数据源是一个字节数组。
ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。也就是数据的目的地。
注意：因为这两个流对象都操作的数组，并没有使用系统资源。所以不用进行close关闭。
操作字符数组
CharArrayReader与CharArrayWrite
操作字符串
StringReader与StringWriter
字符编码
字符流的出现是为了方便操作字符，而且更重要的是它加入了编码转换。
通过子类转换流来完成：inputStreamReader和OutputStreamWriter。
在两个对象进行构造的时候可以加入字符集。
它可以让字符以指定编码格式进行存储。
可以让文本数据以指定编码格式来解读。
623
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
