[黑马程序员]（第16-22天）IO流（下）

------- android培训、 java培训、期待与您交流！ ---------- DataInputStream和DataOutputStream 
用于储存对象的成员数据（字节，字符，布尔值，字符串---字符串会被转为UTF-8）
public Example15{
        public static void main(String[] args){
                FileOutputStream fos = new FileOutputStream("d:\BaiduYunGuanjia\feriosa");
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                DataOutputStream dos = new DataOutputStream(bos);        

                dos.writeByte(12);
                dos.writeChar('f');
                dos.writeBoolean(true);
                dos.writeUTF("freosa");
                
                dos.close();

                FileInputStream fis = new FileInputStream("d:\BaiduYunGuanjia\feriosa");
                BufferedInputStream bis = new BufferedInputStream(fis);
                DataInputStream ds = new DataInputStream(bis);
                
                System.out.println(ds.readByte());
                System.out.println(ds.readChar());
                System.out.println(ds.readBoolean());
                System.out.println(ds.readUTF());
        }
}


printStream:
可以实现将基本数据类型或引用数据类型的对象格式化成字符串后再输出
（这个流就不要BufferedInputStream了，因为它是直接打印）
public Example16{
        public static void main(String[] args){
                //创建一个PrintStream对象，将FileOutputStream读取到的数据输出
                PrintStream ps = new PrintStream(new FileOutputStream("feriosa.txt),true);
                ps.print("这里有一个神奇的数字:");
                ps.println("20");
                ps.println(new Student());
        }
}
class Student {
        //重写Object类的toString()方法，这个方法在该类被实例化时会被自动调用
        public void toString(){
                return "mad max"
        }
}



标准输入输出流：
上午学了一个scanner类（
Scanner scanner = new Scanner();
int num = scanner.nextInt();)可以获得键盘输入的数字
然后再除了args[],就是这种标准输入输出流了

在System类中定义了三个常量：in,out,err
in:标准输入流，默认情况下读取键盘输入的数据
out:标准输出流，是PrintStream类型的，默认将数据输入到命令行窗口（err同理，只是它输出的是错误信息）


public class Example17 {
        public static void main(String[] args){
                StringBuffer sb = new StringBuffer();
                
                /*这里复习一下StringBuffer都有哪些方法：
                   append(),insert(),toString(),setCharAt(),delete()
                */
                int len;
                while((len = System.in.read) != -1){
                        if(len == "/n" || len == "/r"){
                                break;
                        }
                        sb.append(len);
                }
        System.out.println(sb);
        }
}

标准输入输出流的重定向：
在看这个之前，复习一下转换流：
转换流是把字节流转换为字符流，在InputStreamReader之后一定要有BufferedReader
重定向流三个方法：
void setIn(InputStream in)
void setOut(PrintStream out)
void setErr(PrintStream out)
都是静态方法

System.out.println---哈哈有没觉得这句话很熟悉。。。重定向之前是打印出来在控制台，重定向之后就可以在其他地方了）

public class Example18 {
        public static void main(String[] args) {
                
System.setIn(new FileInputString("resource.txt");
                System.setOut(new PrintStream("target.txt");
                //in常量本身是一个InputStream
                InputStreamReader isr = new InputStreamReader(System.in));
                BufferedReader br = new BufferedReader(isr);
                
                //只有BufferedReader是用readline()
                String line ;
                while((line = br.readline()) != null){
                        System.out.println(line);
                }
        }
}


PipedInputStream和PipedOutputStream:
第一次看的时候真的很打脑壳
管道流，其作用是实现多个线程之间通过IO流实现数据的传输
写这个程序也可以顺便复习一下其他流
public class Example19{
        public static void main(String[] args){
                //由于是线程间的数据通信，故没有参数
                PipedInputStream pis = new PipedInputStream();
                PipedOutputStream pos = new PipedOutputStream();
                //pis和pos建立连接
                pis.connect(pos);
                new Thread(new Runnable() {
                        public void run(){
                                //读入从键盘键入的数据
                                BufferedReader br = new BufferedReader(new                                                 InputStreamReader(System.in));
                                //另一个PrintStream，需要记忆的是，它的参数见后边详解        
                                PrintStream ps = new PrintStream(pos);
                                //循环读取
                                while(true){
                                        String line;
                                        line = br.readLine();
                                        ps.println(line);
                                        System.out.println(Thread.currentThread                                        ().getName() + "要求输入内容："); 

                                        }


                        }
                }
                //另另一个线程，实现数据的通信
                new Thread(new Runnable() {
                        public void run() {
                                BufferedReader br  = new BufferedReader(new InputStreamReader(pis));
                                while(true){
                                        System.out.println(Thread.currentThread().getName() +"收到的数据" +br.readLine());
                                }
                        }
                }
        } 
}                        


在字符流中也有一对PipedReader和PipedWriter，其用法与这一对完全相同


PrintStream目前接收两种参数：
PrintStream(FileOutputStream fos, boolean b)
PrintStream(PipedOutputStream pos)


ByteArrayInputStream和ByteArrayOutputStream：
ByteArrayInputStream类会在创建对象时就创建一个byte型数组的缓冲区，该流会把数据先写入缓冲区，最后一次性写入文件。

SequenceInputStream（序列流）
sequence：顺序，连续
当用这个流来读取数据时，它会依次从所有被串联的输入流中读取数据


public class Example23 {
        public static void main(String[] args){
                FileInputStream fis1 = new FileInputStream("stream1.txt");
                FileInputStream fis2 = new FileInputStream("stream2.txt");
                //创建一个序列流，传入各流以合并
                SequenceInputStream sis = new SequenceInputStream(fis1,fis2);
                FileOutputStream fos = new FileOutputStream("sequence.txt");
                String len;
                byte[] arr = new byte[1024];
                while((len = sis.read(arr)) != -1){
                        fos.write(arr,0,len);
                        //这里要复习一下String类的常用方法
                        fos.write("\n\r".getBytes());
                }
                sis.close();
                out.close();
        }
}


如果要传入多个流进行合并，就要用下一种构造方法：
SequenceInputStream(Enumeration<? extends InputStream>e)

enumeration对象会返回一系列InputStream类型的对象
关键代码：
Enumeration e = new vector.elements();
//Enumeration的复习：jdk1.2以前还没有Iterator接口的时候，遍历集合需要使用Enumeration接口，
而配套的类就是Vector集合，该集合是List接口的实现类，用法与ArrayList完全相同，区别在于Vector集合是线程安全的。其element()方法用于返回Enumeration对象，然后Enumeration对象的boolean  hasMoreElements()和Object nextElement()可以实现Vector集合的遍历（迭代器）
//vector类的添加元素方法：boolean addElement(Object o)

class Example24 {
        public static void main(String[] args){
                Vector vector = new Vector();
                FileInputStream fis1 = new FileInputStream("feriosa.txt");
                FileInputStream fis2 = new FileInputStream("nux.txt");
                FileInputStream fis3 = new FileInputStream("max.txt");
                //将这三个文件输入流添加到vector集合中
                vector.addElement(fis1);
                vector.addElement(fis2);
                vector.addElement(fis3);
                //获取Vector的迭代器，以获取Vector中的元素
                Enumeration e = vector.elements();
                SequenceInpuStream sis = new SequenceInputStream(e);
                FileOutputStream fos = new FileOutputStream("madmax.txt");        
                int len;
                byte[] arr= new byte[1024];
                while((len = sis.read(arr) != -1){
                        fos.write(arr,0,len);
                        fos.write("/n/r".getBytes());
                }
                sis.close();
                fos.close();
        }
}


File:
该类封装了一个路径，并提供了一系列方法用于操作该路径所指向的文件

File类常用的构造方法：
File(String pathname)
File(String parent, String child)---@param parent child  分别表示父路径和子路径
File(File parent,String child)---根据指定的File类的父路径和字符串类型的子路径（包括文件名称）创建一个File对象

File类的常用方法：
boolean exists()
boolean delete()
boolean createNewFile()---当File对象对应的文件不存在时，该方法将新建一个此File对象所指定的新文件
boolean canRead()
boolean canWrire()
boolean isFile()---判断File对象对应的时候是文件而不是目录
boolean isDirectory()---也上一个方法相反
boolean isAbsolute()---判断File对象对应的文件或目录是否是绝对路径
String getName()
String getPath()
String getAbsolutePath()---从盘符开始的路径就是绝对路径
String [] list()---列出指定目录的全部内容，只列出名称
long lastModified()---返回1970年1月1日0时0分0秒到文件最后修改时间的毫秒值
long length()
File[] listFiles()---返回一个包含了File对象所有的子文件和子目录的File数组


public class Exaple30{
        public static void main(String[] args){        
                File file = new File(s;