黑马程序员------IO流使用

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

Properties:属于map集合，不用指定泛型，内部只能存放字符串类型
方法：
p.put();放入字符串
p.loag(输入流)
p.store(输出流，注释)
p.clear();”清空集合”
p.containsKey(key);”是否包含某个key”
p.containsValue(value);”是否包含某个value”
p.entrySet();”返回Set集合，包含所有键值对信息”
p.keySet();”返回Set集合，包含所有键”
p.get(key);”根据key获取value”
p.getProperty(key);”根据key返回键，返回值是string类型”
p.getProperty(key, defaultValue);”根据key返回键，返回值是string类型，没有值的时候使用默认值”
p.isEmpty();”集合是否为空”
p.size();”集合长度”

    public static void propertiesDemo() {
        Properties p = new Properties();
        p.put("zhangsan", "10");
        p.put("zhangsan1", "101");
        p.put("zhangsan2", "102");
        p.put("zhangsan3", "103");
        "//把Properties 内的数据以列表形式输出"
        p.list(new PrintStream(System.out));

        "/**
         * 模拟load()和store()
         * load()：读取的文件内部必须是键值对的形式，
         * a = b
         */"
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String line = null;
        try {
            while ((line = br.readLine()) != null) {
                if ("over".equals(line))
                    break;
                    "//对字符串根据 = 分割"
                String[] s = line.split("=");
                bw.write(s[0] + " : " + s[1]);
                bw.flush();
                "//换一行"
                bw.newLine();
            }
            br.close();
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        "/**
         * 使用load和stroe来加载文件和输出文件
         */"
        try {
            "//读取文件"
            p.load(new FileInputStream("d://c.txt"));
            "//把p对象中的内容写入到文件中"
            p.store(new OutputStreamWriter(new FileOutputStream("c://cc.txt"), "utf-8"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

RandomAccessFile 随机文件读写
（即可以读，也可以写，创建对象时声明权限即可,r:读,w:写）
raf.setLength(newLength);设置一个文件的大小(设置后文件大小立即为设置的大小，凡是内部没有数据)
raf.length();获取文件大小
raf.read();读取文件
raf.write();写文件:可以读写基本数据类型
raf.readLine();读取一行
raf.seek(int);从哪里开始读取或写入
raf.skipBytes(n);跳过多少字节
可以多个RandomAccessFile 对象同时对一个文件进行读写操作（多线程下载）

    public static void demo3() {
        try {
            "通过url获取网络资源对象"
            URL url = new URL("http://127.0.0.1:8080/demo.avi");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setReadTimeout(3000);
            conn.connect();
            InputStream in = conn.getInputStream();
            "获取网络文件大小"
            long length = conn.getContentLength();
            "创建本地文件，并设置大小"
            File file = new File("c://demo//t.avi");
            if (file.exists()) {
                file.delete();
                file.createNewFile();
            } else {
                file.createNewFile();
            }
            RandomAccessFile raf = new RandomAccessFile(file, "rw");
            "设置文件大小，只有RandomAccessFile才有这个方法"
            raf.setLength(length);
            raf.close();
            conn.disconnect();
            "开启三个线程，并传入开始和结束位置"
            method(0, length / 3);
            method(length / 3, length / 3 * 2);
            method(length / 3 * 2, length);

        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

    public static void method(final long start, final long end) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                File file = new File("c://demo//t.avi");
                if (!file.exists()) {
                    throw new RuntimeException("找不到文件");
                }
                try {
                    "三个线程共三个RandomAccessFile对象，
                    他们同时操作一个文件"
                    RandomAccessFile raf = new RandomAccessFile(file, "rwd");
                    "设置URL"
                    URL url = new URL("http://127.0.0.1:8080/demo.avi");
                    "获取httpUrlConnextion对象"
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    "连接方法"
                    conn.setRequestMethod("GET");
                    "读取超时时间"
                    conn.setReadTimeout(3000);
                    "设置提交属性"
                    conn.setRequestProperty("Range", "bytes=" + start + "-" + end);
                    conn.connect();
                    System.out.println("开始下载:" + Thread.currentThread());
                    System.out.println("开始下载:" + start + "  :  " + end);
                    InputStream in = conn.getInputStream();
                    byte[] by = new byte[1024];
                    "设置从文件哪个位置开始写入数据"
                    raf.seek(start);
                    while ((len = in.read(by)) != -1) {
                        "写入数据"
                        raf.write(by, 0, len);
                    }
                    System.out.println("关闭:" + Thread.currentThread());
                    raf.close();
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }
        }).start();
    }

PrintStream
只有输出流，没有输入流
可以操作字节流和字符流，一般经常使用字符流
一般使用在打印日志信息中，方便

    public static void demo2() {
        try {
            File f = new File("c://demo//b.txt");
            int[] i = new int[1];
            i[3] = 4;
        } catch (Exception e) {
            try {
                "获取时间"
                Date date = new Date();
                "当参数是输出流的时候，可以指定自动刷新，指定自动刷新后只有println()，printf(),formar()方法有用,若参数是file，不能设置自动刷新
                print()不会自动刷新"
                "FileOutputStream 若文件已经存在采用追加模式，我不是覆盖"
                PrintStream ps = new PrintStream(new FileOutputStream("c://demo//d.txt"，true),
                        true);
                "打印的是字节流"
                ps.write(date.toString().getBytes());
                "打印时间,打印的是字符流"
                ps.println(date);
                "把异常信息打印到ps对象中"
                e.printStackTrace(ps);
            } catch (FileNotFoundException e1) {
                throw new RuntimeException("日志文件创建失败!");
            }

        }
    }

LinenumberReader：
没有LinenumberWriter
使用lnr.getLineNumber()获取行号，默认从0开始
使用lnr.setLineNumber(10);这是行号的起始位置
LinenumberReader自带缓存，有readLine()方法

    public static void lineNum() {
        LineNumberReader lnr = null;
        BufferedWriter bw = null;

        try {
            lnr = new LineNumberReader(new FileReader("d://demo.txt"));
            bw = new BufferedWriter(new FileWriter("c://demo.txt"));
            String line = null;
            "设置行号从10开始"
            lnr.setLineNumber(10);
            while ((line = lnr.readLine()) != null) {
                bw.write(lnr.getLineNumber() + " : " + line);
                "// 最好使用自带的方法换行，这样可以跨平台"
                bw.newLine();
                bw.flush();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            "关闭资源"
            try {
                if (lnr != null)
                    lnr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bw != null)
                    bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

流的切割和合并
序列流：
对流进行合并，只有InputStream，不能使用字符流(Reader,Writer)
输入流是一个有序集合，当读取到第一个流的末尾处，会继续读第二个流的开始，直到结束

    public static void sequenceInputStream() {
        "/**
         * 文件的切割
         * 实际上就是在输出时候指定输出的大小
         * 例：定义的缓冲区大小是多大，那么分割的就是多大
         */"
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            "// 获取文件输入流"
            fis = new FileInputStream("d://love.mp3");
            int num = 0;
            int count = 0;"// 文件名的计数"
            "// 缓存大小是1m"
            byte[] by = new byte[1024 * 1024];
            while ((num = fis.read(by)) != -1) {
                count++;
                "/**
                 * 在内部进行创建输出流，当第一个数组存满后
                 * 创建输出流进行存储，然后立刻关闭
                 * 当再次循环的时候重新创建输出流，重新放新的数据
                 */"
                fos = new FileOutputStream("c://" + count + "1.part");
                fos.write(by, 0, num);
                fos.flush();
                fos.close();
            }
            fis.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        "// 声明集合，内部存放输入流，若是输入流数量小于两个不用创建集合，直接使用构造方法传递就可以"
        ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
        try {

            "// 添加输入流"
            list.add(new FileInputStream("c://11.part"));
            list.add(new FileInputStream("c://21.part"));
            list.add(new FileInputStream("c://31.part"));
            "// 获取每一个输入流，由于被Enumeration使用，他是匿名内部类，要使用final修饰"
            final Iterator<FileInputStream> it = list.iterator();
            "/**
             * SequenceInputStream中只能接收Enumeration集合，不能使用Iterator
             * 使用Enumeration集合是vector，但是已经被ArrayList代替
             * 所以重写Enumeration的方法
             */"
            Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {

                @Override
                public boolean hasMoreElements() {
                    return it.hasNext();"// 是否有下一个"
                }

                @Override
                public FileInputStream nextElement() {
                    return it.next();"// 获取下一个对象"
                }
            };
            FileOutputStream fos2 = new FileOutputStream("c://lov1.mp3");
            SequenceInputStream sis = new SequenceInputStream(en);
            "/**
             * 最后进行输出
             */"
            int num = 0;
            byte[] by = new byte[1024];
            while ((num = sis.read(by)) != -1) {
                fos2.write(by, 0, num);
            }
            sis.close();
            fos2.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

对象的持久化存储：
ObjectOutputStream,ObjectInputStream
将一个对象进行持久化存储，存储的对象必须实现Serializable接口，打上标记
实现Serializable的类默认会生成一个UId：
public static final long serialVersionUID = 10;
它会根据这个值进行判断是不是原来的对象，默认是根据类中的成员进行计算，也可以手工指定
当对象进行持久化存储后，这时候修改了类中的一些值，例如添加了一个成员等
这时候再读取对象文件的时候会报错：java.io.InvalidClassException
静态不能被序列化
非静态不想被序列化使用关键字：transient

    public static void serializable() {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("d://demo2.txt"));
            ois = new ObjectInputStream(new FileInputStream("d://demo2.txt"));
            "// 写入一个对象"
            oos.writeObject(new Persion("lisi", 31));
            oos.writeObject(new Persion("lisi1", 31));
            oos.writeObject(new Persion("lisi2", 32));
            oos.close();
            "// 读取一个对象,并进行强转"
            Persion p = (Persion) ois.readObject();
            Persion p1 = (Persion) ois.readObject();
            Persion p2 = (Persion) ois.readObject();
            System.out.println(p.getName() + "  " + p.getAge());
            System.out.println(p1.getName() + "  " + p1.getAge());
            System.out.println(p2.getName() + "  " + p2.getAge());

        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
import java.io.Serializable;

public class Persion implements Serializable {
    private static final long serialVersionUID = 1;
    private String name;
    private int age;
    public Persion(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

管道流:
PipedInputStream PipedOutputStream
一般应用在多线程中，一个线程负责输入，而另一个线程负责输出
当一段连接线程提前结束的时候：会报错

    public static void guanDaoDemo() {
        "创建一个输入管道流,这里使用了匿名内部类，局部变量要声明为final"
        final PipedInputStream pis = new PipedInputStream();
        "创建一个输出管道流"
        final PipedOutputStream pos = new PipedOutputStream();
        try {
            "两个流进行连接"
            pis.connect(pos);
        } catch (IOException e) {
            e.printStackTrace();
        }
        "输出管道流"
        new Thread(new Runnable() {

            @Override
            public void run() {
                int num = 0;
                System.out.println("正在读取数据...");
                try {
                    while ((num = pis.read()) != -1) {
                        System.out.println(num);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        "输入管道流"
        new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    System.out.println("正在写入数据...");
                    Thread.sleep(3000);
                    pos.write("--------".getBytes());
                    System.out.println("写入完成...");
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

存储基本数据类型
DataInputStream,DateOutputStream
注意：
写入顺序和读取顺序必须相同(第一个写入的是int类型，则读取的时候第一个必须是int类型，如果是long类型，则会多读取数据,造成数据错误)
gbk编码表：一个中文占2个字节
utf -8:一个中文占3个字节
utf-8改：一个中文占4个字节
当存储的数据大于256时，最好是用writeInt()，他是直接存储32位，而write()只是存储8位，
会造成损失精度
writeUTF(“你好”);当写入时使用了这个方法，取出时一定要使用readUTF();取出

public static void dataDemo() {
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream("d://demo3.txt"));
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("d://demo3.txt"));
            dos.writeInt(78);"// 写入32位"
            dos.write(455);"// 写入8位，会造成精度损失"
            dos.writeBoolean(true);
            dos.writeUTF("你好");
            dos.close();

            int a = dis.readInt();
            int b = dis.read();
            boolean c = dis.readBoolean();
            String s = dis.readUTF();
            System.out.println(a + " " + b + " " + c + " " + s);
        } catch (FileNotFoundException e) {
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

字节数组操作数据,字符数组,字符串：
ByteArrayInputStream ByteArrayOutputStream
实例：把文件的中内容读取到内存中
不需要关闭，因为没有调用底层资源，关闭也没用
bos.size()获取输出长度
这个是直接输出到内存中

    public static void arrayDemo() {
        BufferedReader br;
        try {
            "读取一个文件"
            br = new BufferedReader(new FileReader("d://demo.txt"));
            "定义输出文件"
            FileOutputStream fos = new FileOutputStream("d://demo4.txt");
            StringBuilder sb = new StringBuilder();
            String line = null;
            "把文件读取的内容添加到StringBuilder中"
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            System.out.println(sb.toString());
            "// 读取字节数据"
            ByteArrayInputStream bis = new ByteArrayInputStream(sb.toString().getBytes());
            "ByteArrayOutputStream 是把数据写入到内存中"
            ByteArrayOutputStream bos = new ByteArrayOutputStream();"// 长度自动增加"
            int by = 0;
            while ((by = bis.read()) != -1) {
                "// 输出,这里是输出到内存中"
                bos.write(by);
            }
            "// 输出到outputstream,必须要先执行完上面while循环,把数据写入内存后,才能执行writeTo()"
            bos.writeTo(fos);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-