javaIO包

Java IO流： 
流是一组有序的有头有尾的字节集合，是数据传输总称或抽象。 
IO流是用来处理设备之间的数据传输 
Java对数据的操作是通过流的方式 
Java用于操作流的对象都在IO包中 
流按操作数据分为两种：字节流与字符流 
流按流分为：输入流（input），输出流（output）(相对于内存来说的) 

根据处理的数据不同：分为：字节流和字符流。 

**所有的数据都是以字节体现的，后期产生了字符流，因为字符数据涉及到了编码问题，所以在字符流对象中加入了编码机制。如果处理的数据都是字符数据，只是可以使用字符流对象来完成。 

IO流常用基类： 
　　字节流的抽象基类： 
　　InputStream，OutputStrean 
　　 
　　字符流的抽象基类： 
　　Reader，Writer 
　　 
　　**由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。 
　　如：InputStream的子类FileInputStream 
　　如：Reader的子类FileReader 

IO程序的书写 
1，导入IO包中的类 
2，进行IO异常处理 
3，在finally中对流进行关闭 

FileWriter类： 

FileWriter fw = new FileWriter(“Demo.txt”);
//FileWriter：用来操作文件的字符串输出流对象 
/* 
创建该对象做的事情: 
1,在堆内存中产生了一个实体 
2，调用了系统底层资源，其实是调用了windows的功能，在指定位置创建了一个文件，建立数据存储的目的地。用于存放即将写入的数据。 
3，因为目的地可能因为路径错误，而导致失败，所以抛出了IOException，需要对其处理。 

**如果创建的文件已经存在，那么会覆盖原文件。 
*/ 

//既然有了流对象，指定具体数据，使用fw对象的write方法将数据写成，fw对象的write 
//方法，将数据写入到了流中，其实就是内存中。 
Fw.write(“abcdefg”); 

//刷洗缓冲区，将流中的数据刷到目的地中。 
Fw.flush(); 

Fw.write(“kkkkkk”); 

Fw.flush(); 

Fw.write(“qqqqqq”); 

/* 
Close方法： 
1，先刷新缓冲区的数据到目的地，其实就是调用了一次flush。 
2，关闭了调用底层的资源。将资源释放。 
*/ 
Fw.close(); 


Flush()和close()的不同： 
Flush():只会刷新缓冲区，流依然存在，并可以继续使用 
Close():也会刷新缓冲区，但是刷新后，立刻关闭流资源，流不可以在继续使用。 


FileReader类：【 


　　/* 
　　创建一个读取流对象，并关联要读取的文件。 
　　将要读取的文件作为构造函数的参数传递，对象一初始化就必须有一个已经存在的数据。 
　　*/ 
　　FileReader fr = new FileReader(“Demo.txt”); 
　　 
　　/* 
　　//调用了读取流对象的read方法，一次读一个字符。 
　　Int ch = fr.read(); 
　　*/ 
　　 
　　Int ch = 0; 
　　While((ch = fr.read())!=-1){//当为-1的时候就不读了 
　　System.out.println((char)ch); 
　　} 
　　 
　　System.out.println((char)ch); 
　　 
　　Fr.close(); 
　　 
　　或者：(这种方法比较好，循环次数较少) 
　　 
　　FileReader fr = new FileReader(“Demo.txt”); 
　　 
　　Char[] buf = new char[1024]; 
　　 
　　Int len = 0; 
　　While((len=fr.read(buf))!=-1){ 
　　System.out.println(new String(buf,0,len)); 
　　} 

】 


BufferedWriter类：（带缓冲技术的字符输出流） 
　　FileWriter fw = new FileWriter(“bufdemo.txt”); 
　　BufferedWriter bufw = new BufferedWriter(fw); 

　　Bufw.write(“haha”); 
　　Bufw.newLine();//依据不同的平台，进行换行的操作 
　　Bufw.write(“hehe”); 
　　bufw.newLine(); 
　　Bufw.flush();//养车一个习惯，只要用到了缓冲区，就记着一定要刷新 
　　Bufw.close();不用关闭fw了，因为缓冲区是提高流的操作效率而存在，只是内部提供了 数组，对数据进行缓冲，最终的写入还是流完成的，所以关闭缓冲区，其实就是在关闭 流，也就是bufw.close其实内部调用的就是fw.close(); 


BufferedReader类： 
　　FileReader fr = new FileReader(“bufdemo.txt”); 
　　BufferedReader bufr = new BufferedReader(fr); 
　　String line = null; 
　　While((line=bufr.readLine())!=null){ 
　　System.out.println(line); 
　　} 
　　Bufr.close(); 


复制的原理： 
　　对源文件进行读取。 
　　并将读取的数据存储到目的文件中。 
　　 
　　1，（不同缓冲区） 
　　FileReader fr = null; 
　　FileWriter fw = null; 
　　Try{ 
　　Fr = new FileReader(“Demo.txt”); 
　　Fw = new FileWriter(“copyDemo.txt”); 
　　Char[] buf = new char[1024]; 
　　Int len = 0; 
　　While((len=fr.read(buf))!=-1){ 
　　Fw.write(buf,0,len); 
　　} 
　　}catch(IOException e){ 
　　Throw new RuntimeException(“读写失败”): 
　　}finally{ 
　　Try{ 
　　If(fw!=null) 
　　Fw.close(); 
　　}catch(IOException e){ 
　　Throw new RuntimeException(“写入关闭失败”): 
　　} 
　　Try{ 
　　If(fr!=null) 
　　Fr.close(); 
　　}catch(IOException e){ 
　　Throw new RuntimeException(“读取关闭失败”); 
　　} 
　　} 
　　 
　　2，（使用缓冲区） 
　　import java.io.*; 
　　 
　　class TestBuffer { 
　　 public static void main(String[] args){ 
　　 FileReader fr = null; 
　　 FileWriter fw = null; 
　　 BufferedReader br = null; 
　　 BufferedWriter bw = null; 
　　 try 
　　 { 
　　 fr = new FileReader("E:\\ITcast\\day24\\copyText.java"); 
　　 fw = new FileWriter("E:\\ITcast\\day24\\Copy.txt"); 
　　 br = new BufferedReader(fr); 
　　 bw = new BufferedWriter(fw); 
　　 String str = null; 
　　 while ((str=br.readLine())!=null) 
　　 { 
　　 bw.write(str); 
　　 bw.newLine(); 
　　 bw.flush(); 
　　 } 
　　 } 
　　 catch (IOException e) 
　　 { 
　　 throw new RuntimeException("复制不成功"); 
　　 }finally{ 
　　 try 
　　 { 
　　 if(br!=null) 
　　 br.close(); 
　　 } 
　　 catch (IOException e) 
　　 { 
　　 throw new RuntimeException("关闭输入失败"); 
　　 } 
　　 
　　 try 
　　 { 
　　 if(bw!=null) 
　　 bw.close(); 
　　 } 
　　 catch (IOException e) 
　　 { 
　　 throw new RuntimeException("关闭输出失败"); 
　　 } 
　　 } 
　　 } 
　　} 




字符流的缓冲区，是为了提高效率而存在的。 
BufferedWriter 
　　NewLine(); 
BufferedReader 
　　readLine();调用基础流对象的read方法，一次读一个字符，并吧该字符进行了临时存储。直到读到回车换行符为止，将存储的数据作为字符串返回。 
缓冲区的出现提供了比以前流对象功能更前的函数。 


异常处理方式： 

Import java.io.*; 
Class FileWriterDemo2{ 
　　Public static void main(String[] args){ 
　　FileWirter fw = null 
　　Try{ 
　　Fw = new FileWriter(“d:\\Demo.txt”); 
　　Fw.write(“abcdef”); 
　　}catch(IOException e){ 
　　System.out.println(e.toString()); 
　　Throw new RuntimeException(“写入失败”); 
　　}finally{ 
　　Try{ 
　　If(fw != null) 
　　Fw.close(); 
　　}catch(IOException e){ 
　　System.out.println(e.toString()); 
　　Throw new RuntimeException(“关闭失败”); 
　　} 
　　} 
　　} 
} 

这样写的好处，就是写入的时候发生了错误，finally中的代码也会继续执行，也就是说可以执行到close方法，将流关闭，将FileWriter写在try catch的外面，是为了让finally中的变量也try中的变量指向同一个流。


如何对已有的文件进行数据的续写？ 
使用FileWriter对象的另一个构造函数，带一个boolean类型的参数的构造函数。只要boolean类型值为true，就可以完成续写。 
**如果写入回车换行符，在windows中需要\r\n来完成。 

FileReader 
FileWriter 
BufferedWriter 
BufferedReader 
凡是直接操作数据的流对象，或者操作文件的流对象，都是最常用的流对象。 
因为文件就是数据体现形式。 
而操作流就需要提高效率，所以带缓冲的流对象，也是常用对象。 

inputStream类： 
　　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(); 


outputStream类： 
　　FileOutputStream fos = new FileOutputStream(“fos.txt”); 
　　Byte[] buf = “abcde”.getBytes(); 
　　Fos.write(buf);//字节流的写入方法，直接将数据写到了目的地，因为对象中不存在缓冲区 
　　Fos.close();//关闭资源 


复制图片：(复制的几种方式) 
1， 
　　FileInputStream fis = new FileInputStream(“c:\\0.bmp”); 
　　FileOutputStream fos = new FileOutputStream(“c:\\1.bmp”); 
　　Byte[] byf = new byte[1024]; 
　　Int len = 0; 
　　While((len=fis.read(buf))!=-1){ 
　　Fos.write(buf,0,len); 
　　} 
　　Fos.close(); 
　　Fis.close(); 

2， 
　　FileInputStream fis = new FileInputStream(“c:\\1.mp3”); 
　　BufferedInputStream bufis = new BufferedInputStream(fis); 
　　FileOutputStream fos = new FileOutputStream(“c:\\3.mp3”); 
　　BufferedOutputStream bufos = new BufferedOutputStream(fos); 
　　 
　　Int by = 0; 
　　While((by = byfis.read())!=-1){ 
　　Byfos.write(by); 
　　} 
　　Bufos.close(); 
　　Bufis.close(); 



不能通过字符流复制图片，因为读取图片数据时，字符流会查默认的编码表。如果在编码表中没有查到具体的数据，就会用其他数据替代。这时，元数据错乱，导致生成的图片无法观看。所占字节也不同。 
**只要操作数据是文本，建议使用字符流，因为它可以进行指定编码的转换，除此之外，都用字节流。 


键盘的录入：（将输入的字符转成大写，如果是over就结束） 
　　Int ch = 0; 
　　InputStream in = System.in; 
　　StringBuilder sb = new StringBuilder(); 
　　While(true){ 
　　Ch = in.read(); 
　　If(ch == -1){ //通过控制台的ctrl+c可以强制结束录入，其实就是给流定义了结束标记 
　　System.out.println(“------”); 
　　Break; 
　　} 
　　If(ch == ‘\r’) 
　　Countinue; 
　　If(ch == ‘\n’){ 
　　String s = sb.toString(); 
　　If(s.equals(“over”)) 
　　Break; 
　　System.out.println(s.toUpperCase()); 
　　Sb.delete(0,sb.length()); //清空缓冲区 
　　}else 
　　Sb.append((char)ch); 
　　 
　　} 
转换流：（字符流） 
InputStreamReader字节通向字符流的桥梁 
OutputStreamWriter字符通向字节的桥梁 


InputStream in = System.in;//获取键盘录入读取流对象。//这个是字节流对象 

//流转换，将字节流转成字符流 
InputStreamReader isr = new InputStreamReader(in); 

对字符流进行读取效率的提高，意思操作一行数据 
BufferedReader bufr = new BufferedReader(isr);//这个是字符流对象 

OutputStream out = System.out; 
OutputStreamWriter osw = new OutputStreamWriter(out); 
BufferedWriter bufw = new BufferedWriter(osw); 

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(); 



**//一次读键盘一行 
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in))); 
BufferedWriter bufw = new BufferedWriter(new OutStreamWriter(System.out))); 

流的操作规律？ 
因为io包中的对象很多，最重要的是要知道完成数据处理时，要使用哪个对象最合适。 
如何判断要使用那些对象？ 
　　通过几个明确来判断对象的使用。 
　　1，明确数据源，和数据目的（数据汇） 
　　数据源：InputStream Reader 
　　数据目的：OutputStream Writer 
　　2，明确数据的内容是否是纯文本。 
　　数据源：是：Reader 
　　数据目的：是：Writer 
　　如果不是：就使用InputStream或者OutputStream 
　　 
　　如果数据不能明确，只有使用字节流。 
　　这样就可以将四个基类，进行确定，要使用哪个。 
　　3，明确具体设备。 
　　数据源：键盘（System.in），内存(数组)，硬盘(File开头的流对象)。 
　　数据目的：控制台（System.out），内存(数组)，硬盘(File开头的流对象)。 
　　4，明确是否需要提高效率？ 
　　是：使用带Buffer对象 
　　 

Writer 
　　|--OutputStreamWriter 
　　|--FileWriter 
Reader 
　　|--InputStreamReader 
　　|--FileReader 
转换流其实就是将字节流和编码表相结合，将字节流中的字节数据去查了具体的编码表。 
所以转换流才可以获取一个中文字符。 
那么转换流的子类用于操作文件的对象FileReader就直接使用父类的具体有转换功能的read方法，就可以一次读一个字符。 

FileReader fr = new FileReader(“a.txt”);//该对象中已经内置了本机默认的字符编码表 
　　//对于简体中文版的机器默认编码表示gbk 
//通过字节读取流读取a.txt中中文数据，按照gbk编码表的来读取中文字符。 
InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),”gbk”); 

InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),”gbk”); 
FileReader fr = new FileReader(“a.txt”); 
这两句代码的功能是一样的。 

区别： 
第一句可以指定编码表 
第二句，固定本机默认编码表 

如果操作中文数据，仅使用本机默认码表，那么第二句简单 
如果操作中文数据，使用指定码表，必须使用第一句，而且要将指定码表作为字符串传递到构造函数中。 

File类： 
数据存放的形式最常见的就是文件。 
文件的属性较多，如文件名称，路径，大小等属性。 
为了方便与操作java就将其视为对象。 
通过File类对其描述。 
提供了多个属性和行为。便于对文件进行操作。 

而流对象只能用于操作文件中的数据。 
对于文件的属性，都是通过File对象来完成。 

File类可以是文件，也可以是路径。 
将制定文件封装成File对象。 
File f = new File(“c:\\a.txt”); 

File f1 = new File(“c:\\”,”a.txt”); 

File dir = new File(“c:\\”); 
File f2 = new File(dir,”a.txt”); 

File f3 = new File(“c:”+File.separator+”a.txt”); 
File.separator是跨平台性的目录分隔符 

File常见的方法： 
1，创建文件 
　　Boolean createNewFile();//如果f这个文件不存在，该方法会对其创建 
　　//如果f已经存在，该方法不会创建 
　　//而输出流创建文件，如果该文件存在，会覆盖，但是，如果输出流 
　　//的构造函数传入参数为true，不覆盖文件，可以完成续写。 
　　创建文件夹 
　　Boolean mkdir();//创建单级目录，如果已经存在不创建 
　　Boolean mkdirs();//创建多级目录（就是目录下还有子目录），可以在已存在的目录下继 //续创建 
2，删除 
　　Boolean delete();//java中的删除不走回收站 
　　//删除目录时，如果目录中有内容，应该先将内部内容删除，再删该目录 
　　//windows的删除就是从里往外删 
　　Void deleteOnExit();//程序退出时，把该文件删除。 
3，判断（想要判断file对象封装的是文件还是目录，必须要确定内容是存在的） 
　　Boolean isFile()//是不是文件 
　　Boolean isDirectory()//是不是目录 
　　Boolean isAbsolute()//是不是据对路径 
　　Boolean exists()//判断封装的对象是否存在 
　　Boolean canExecute()//判断文件是否可以执行 
　　Boolean isHidden()//判断文件是否是隐藏文件 
4，获取 
　　String getAbsolutePath();//获取绝对路径（完整路径） 
　　String getPath();//获取相对路径（file内封装的路径内容） 
　　String getName();//获取文件名 
　　String getParent();//获取父目录 
　　Long length();//获取文件的长度（文件的字节数，该方法只针对于与文件而言） 
　　Long lastModified();//文件最后一次修改的时间 
5，重命名 
　　Boolean renameTo(file);//将文件名修改，可以进行文件的移动（剪切+重命名） 
6，文件列表 
　　Static File[] listRoots();//列出系统的根 
　　String[] list();//获取当前目录下的文件夹和和文件的名称，如果file中封装的是一个文件，那么返回数组为null，所以最好做一个安全的判断 
　　File[] listFiles();//获取的是当前目录下文件或者文件夹对应的对系那个。 
　　 
　　（如果仅获取文件名称，就用list方法。如果还用获取文件的其他信息，最好用listFiles，因为它可以获取到文件对象，这样就可以通过文件对象方法，获取其他内容） 



IO包中的其他类： 
PrintWriter与PrintStream 
可直接操作输入流和文件。 

PrintStream:字节流中的打印流，可以直接操作设备的流对象。 
　　构造函数的参数特点： 
　　1，字符串路径。 
　　2，File对象。 
　　3，字节输出流。 
　　 
PrintWriter:字符流中的打印流。 
　　构造函数的参数特点： 
　　1，字符串路径 
　　2，File对象 
　　3，字节输出流 
　　4，字符输出流 
　　 
打印流可以直接操作文件，算是较为常用的流对象。 
可以打印任意数据类型。 


管道流： 
　　PipedInputStream和PipedOutputStream 
　　输入输出可以直接进行连接，通过线程使用。 
　　读取流和写入流可以进行连接。 
　　但是需要被多线程操作。 
　　因为read方法是阻塞式方法。容易引发死锁。 



RandomAccessFile： 
随机访问文件，自身具备读写的方法。 
通过skipBytes(int x),seek(int x)来达到随机访问。 
特点： 
　　1，既可以读又可以写。 
　　2，内部封装了一个大的byte类型的数组，这就说明该对象操作的数据是字节数据，说明其中封装了字节的读取流和写入流。而且可以使用内部的指针对这个数组进行数据的操作 
　　3，提供了getFilePointer方法获取指针的位置，还提供了seek方法设置指针的位置。 
　　4，通过该对象的构造函数可以得知，该对象只能操作文件。 
　　也就是说源和目的都是一个文件。 
　　并通过构造函数的另一个参数来确定，访问方式。该变量只能接收四个值。 
　　R:只读，rw：读写。Rws，rwd 
　　5，该对象中的方法可以操作基本数据类型。 
　　6，注意被操作的文件数据，希望有规律。这样可以通过数据的整数倍来控制指针的偏移。 
　　 对数据进行操作，达到，随机访问的效果。 

　　可以应用于多线程对大数据的写入。同时写入，只要给每一个线程分配 
　　起始索引位，就可以完成多线程随机写入。 
　　提高了写入效率。 
　　 
　　 
　　使用的前提： 
　　1，必须是文件。 
　　2，数据有规律。比如等长数据。 

*/ 

class RandomAccessFileDemo 
{ 
public static void main(String[] args) throws IOException 
{ 
writeDemo3(); 
// readDemo2(); 
} 


//对已有数据进行修改。 
public static void writeDemo3()throws IOException 
{ 
RandomAccessFile raf = new RandomAccessFile("info.txt","rw"); 

raf.seek(8*3);//从指针索引位8开始进行写入。 
raf.write("赵六".getBytes()); 
raf.writeInt(72); 

raf.close(); 
} 

/* 
既然能写，那么读也应该没有问题。 
通过指针的操作，完成读取的随机效果。 
*/ 
public static void readDemo2()throws IOException 
{ 
RandomAccessFile raf = new RandomAccessFile("info.txt","r"); 

raf.seek(8*1); 


byte[] buf = new byte[4]; 

int len = raf.read(buf); 
String s= new String(buf,0,len); 

System.out.println("name="+s); 
int age = raf.readInt();//一次读四个字节并转成int数值。 
System.out.println("age="+age); 
raf.close(); 
} 



//通过seek方法指定指针的位置，进行数据写入。 
/* 
发现RandomAccessFile操作的文件如果已经存在，不会再次创建，直接操作已有文件。。 

发现通过seek的指针定位，就可以完成数据的随机写入。 

它可以完成已有数据的修改。 
*/ 
public static void writeDemo2()throws IOException 
{ 
RandomAccessFile raf = new RandomAccessFile("info.txt","rw"); 

raf.seek(8*2);//从指针索引位8开始进行写入。 
// raf.write("李四".getBytes()); 
// raf.writeInt(67); 
raf.write("王武".getBytes()); 
raf.writeInt(68); 

raf.close(); 

} 
/* 
通过该对象写点数据。 
数据： 人员信息： 姓名，年龄 
*/ 
public static void writeDemo()throws IOException 
{ 
RandomAccessFile raf = new RandomAccessFile("info.txt","rw"); 

raf.write("张三".getBytes()); 
//raf.writeBytes("张三");//解析出了问题。 
//raf.writeChars("张三");//解析出了问题。 
//raf.write(65);//write:只将一个int整数的最低字节写出。 


raf.writeInt(65); 

raf.close(); 

} 

public static void readDemo()throws IOException 
{ 
RandomAccessFile raf = new RandomAccessFile("info.txt","r"); 

byte[] buf = new byte[4]; 

int len = raf.read(buf); 
String s= new String(buf,0,len); 

System.out.println("name="+s); 
int age = raf.readInt();//一次读四个字节并转成int数值。 
System.out.println("age="+age); 
raf.close(); 
} 

} 




序列流： 
SequenceInputStream 
对多个流进行合并。 

操作对象： 
ObjectInputSteam与ObjectOutputStream 
被操作的对象需要实现 


ProPerties类： 
Map 
　　|--Hashtable 
　　|--Properties 
Properties:该集合中存储的键和值都是字符串类型的数据，通常同于配置文件的定义。 
Properties类表示了一个持久的属性集，Properties可以保存在流中或从流中加载，属性列表中每个键及其对应都是一个字符串。 
1，添加元素： 
　　Properties prop = new Properties(); 
prop.setProperty("xiaowang","12"); 
prop.setProperty("xiaozhang","13"); 
prop.setProperty("xiaoli","14"); 
　　System.out.println(prop); 

2,列表方法： 
　　Properties prop = new Properties(); 
prop.setProperty("xiaowang","12"); 
prop.setProperty("xiaozhang","13"); 
prop.setProperty("xiaoli","14"); 
　　prop.list(System.out);//打印到控制台，只要让参数是System.out 
　　------------------------------------------------------------------ 
Properties prop = System.getProperties(); 
　　Prop.list(new PrintStream(“sys.txt”));//将系统信息写入到sys.txt文件中去 

3， 
Properties prop = new Properties(); 
System.out.println(prop); 
FileReader fr = new FileReader("prop.txt"); 
prop.load(fr); 
//使用集合的特有方法load 
System.out.println(prop); 
4， 
//将硬盘中的键值对加载到Properties集合中。 
Properties prop = new Properties(); 
System.out.println(prop); 
FileInputStream fis = new FileInputStream("info.txt"); 
//使用集合的特有方法load，将流的特定规则信息存储到集合中，注意：流中的信息必须有规则是键值对。用=分隔 
prop.load(fis); 
System.out.println(prop); 
fis.close(); 
5， 
//模拟一个load方法。 
/* 
其实load方法很简单，就是通过流对象，读取文本中一行数据 。 
在将该行数据通过=进行切割。左边作为键，右边作为值。 
存入到Properties集合中。 
*/ 
Properties prop = new Properties(); 
BufferedReader bufr = 
new BufferedReader(new FileReader("info.txt")); 
String line = null; 
while((line=bufr.readLine())!=null) 
{ 
String[] arr = line.split("="); 
prop.setProperty(arr[0],arr[1]); 
} 
System.out.println(prop); 
bufr.close(); 
6， 
/* 
将硬盘上的数据进行集合的存储，希望在运算后，将改变后的结果，重新存回配置文件中。 
*/ 
Properties prop = new Properties(); 
FileInputStream fis = new FileInputStream("info.txt"); 
prop.load(fis); 
System.out.println(prop); 
prop.setProperty("wangwu","29");//把集合修改后的数据重新存回配置文件。 
//需要写入流。需要一个存储方法。store(outputStream.string); 
FileOutputStream fos = new FileOutputStream("info.txt"); 
prop.store(fos,"hah"); 
System.out.println(prop); 
fos.close(); 
fis.close(); 


SequenceInputStreamm类： 
可以将多个读取流变成一个读取流。 


操作对象流： 
　　ObjectInputStream和ObjectOutputStream 
　　对象的持久化存储。 
　　也就是说将对象中封装的数据保存到持久化的设备上，比如硬盘。 
　　那么其他应用程序都需要建立该对象，直接读取设备上的对象即可。 
　　 
　　ObjectInputStream ObjectOutputtStream 
　　专门用于操作对象的流，封装了直接操作对象的方法。 

写入对象： 
　　使用输出流中的writerObject();方法，里面传递一个对象。 
　　如果一个对象要被写入，必须具备序列化功能，也就是说必须要实现Serializable接口 


读取对象： 
　　使用输入流中的readObject();方法，要注意的是需要强制转换， 
　　Person p = (Person)ois.readObject(); 


**对象中的静态数据是不会被持久化的。 
只要将不需要被持久化的非静态数据进行transient关键字修饰即可。 

Sirializable序列化接口： 
　　用于给类文件加一个UID，就是一个序列号。 
　　该序列通过类中的成员的数字签名完成运算得来的。 
　　 
　　 
　　当类中的成员发生大的改动时，类会重新编译，生成带有新的UID的序列号。这样就 可以和曾经存储的原来的类生成的对象的序列号不匹配。 
　　这样就可以让使用者必须重新对新类产生的对象进行存储。避免新类接收老对象出现安 全隐患，这就是序列号的功能所在。 
　　 
　　如果类中没有成员大的改动，只是有个别的一些修改，没有对对象产生打的影响，这时 候，不必去重新对类进行存储，这时可以在定义类时指定序列化，而不让jvm自动算 该序列化。 
　　 
　　Public static final long serialVersionUID = 42L;//给person指定一个固定的序列化。这样就 可以保证该类即使被改动，序列化也不会变 





操作基本数据类型 
　　DataInputStream与DataOutputStream 
　　DataInputStream和DataOutputStream： 
　　writeUTF()方法一般流对里面的数据读取不出来，因为它用的是utf的修改表。只能用 DataInputStream中的readUTF()方法进行读取。 
　　 
　　 
操作字节数组 
　　ByteArrayInputStream与ByteArrayOutputStream 
　　操作数组流对象，它对应的设备就是内存。 
　　ByteArrayOutputStream：内部封装了一个可变长度的字节数组 
　　关闭它是无效，因为该对系那个根本就没有调用过底层资源 
　　可以通过toByteArray()或者toString()获取数组中的数据 
　　 
　　ByteArrayInputStream负责数据源，在初始化的时候，必须要有一个数据源内容。 
　　因为操作的是数组，所以源就是一个字节数组。 
　　该对象中不会有异常发生，因为没有调用过底层资源。 
　　 
　　为什么不直接操作byte[]，还要用到流？ 
　　因为数组的操作，无非就是数组中的元素进行设置和获取，这个操作正好符合了读和写 的操作。 
　　使用流的操作思想在操作数组 
　　 
操作字符数组 
　　CharArrayReader与CharArrayWrite 
操作字符串 
　　StringReader与StringWriter 


字符编码： 
　　字符流的出现为了方便操作字符 
　　更重要的是加入了编码转换。 
　　通过子类转换流来完成 
　　InputStreamReader OutputStreamWriter 
　　在两个对象进行构造的时候可以加入字符集。 


常见的编码表： 
　　ASCII:美国标准信息交换码 
　　用一个字节的7位可以表示 
　　ISO8859-1：拉丁码表，欧洲码表 
　　用一个字节的8位表示 
　　GB2312：中国的中文编码表 
　　GBK：中国的中文编码表升级，融合了更多的中文文字符号。 
　　Unicode：国际标准码，融合了多种文字。 
　　所有文字都用两个字节来表示，java语言使用的就是unicode 
　　UTF-8：最多用三个字节表示一个字符 

字符流 = 字节流+编码表，能指定编码表的转换流 
内部默认了编码表的是转换流的子类FileReader，FileWriter，默认的是本机码表 

OutputStreamWriter osw = new OutputStreamWrtier(new FileOutputStream(“gbk.txt”)); 
OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream(“gbk,txt”),”GBK”); 
FileWriter fw = new FileWriter(“gbk.txt”); 
这三句是一样的，都是在使用默认的GBK表，在操作gbk.txt 


编码解码问题： 
编码：字符串——》字节数组。 
　　使用的是String类中的getBytes(charset); 
　　Byte[] buf = “你好”.getBytes(“utf-8”); 
　　 
解码：字节数组——》字符串。 
　　使用String类中的构造函数。 
　　String s = new String(buf,”utf-8”); 

在gb2312的码表中，中文是两个字节，都是负数，也就是每一个字节的最位都是1 
在gbk的码表中，中文还是两个字节，第一个字节最高位是1，第二个字节最高位可能是0