IO流

分隔符：在window系统中分隔符是“ c:\ ”我们在java可以用“ c:\com ”来表示或者“ c:/com ”来表示
IO流，位于java.IO包中。
File类：一个File类的对象，表示磁盘上的文件或目录。
File类提供类了与平台无关的方法来对磁盘上的文件目录进行操作。
File类直接处理文件和文件系统。
File类没有指定信息怎样从文件读取或想文件存储。
File类的构造方法：

import java.io.File;
import java.io.IOException;

public class IOTest {
    public static void main(String[] args) throws IOException {
        File file=new File("c://abc.txt");
        System.out.println(file.createNewFile());
    }
}

import java.io.File;
import java.io.IOException;

public class IOTest {
    public static void main(String[] args) throws IOException {
//        File file=new File("c://abc");
//        File file2=new File(file,"xyz//hello.txt");
//        file2.createNewFile();
//        System.out.println(file.createNewFile());
       File file=new File("D:\\");
//       String []names=file.list();
//       for (String name:names){
//       System.out.println(name);
     File[]files= file.listFiles();
    for (File name:files){
        System.out.println(name);
         }
    }
}

import java.io.File;
import java.io.IOException;

public class TestIO {
    public static void main(String[] args) throws IOException {
        File file = new File("C:\\abc\\xyz");
        String[] files = file.list();
        for (String name:files){
            if (name.endsWith(".java")){
                System.out.println(name);
            }
        }
    }
}

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;

public class TestIO {
    public static void main(String[] args) throws IOException {

        File file = new File("C:\\abc\\xyz");
        String []name=file.list(new FilenameFilter() {
            @Override
            public boolean accept(File file, String name) {
                if (name.endsWith(".java"))
                    return true;
                return false;
            }
        });
        for (String names:name)
        System.out.println(names);
    }
}

流类
流的概念：java程序通过流来完成输入/输出。流是生产或消费信息的抽象。流通过java的输入/输出系统与物理设备链接。尽管与他们链接的物理设备不尽相同，所有的流的行为具有相同的方式。这样，相同的输入/输出类和方法适用于所有类型的外部设备。这意味着一个输入流能够抽象多做不同类型的输入：从磁盘文件，从键盘或网络套接字。同样，一个输出流可以输出到控制台，磁盘文件或相连的网络。流是处理输入/输出的一个洁净的方法，列如它不需要代码理解键盘和网络的不同。java中流的实现是在java.io包定义的类层次结构内部。
输入/输出流概念
输入/输出时，数据在通信通道中流动。所谓数据流“数据流（stream）”指的是所有数据通信通道之中，数据的起点和终点。信息的通道就是一个数据流。只要是数据从一个地方“流”到另一个地方这种就是数据流动的通道都可以为数据流。
输入/输出是相对程序来说的。程序在使用数据时扮演有两个角色：源和目的。
若程序是数据流的源，暨数据的提供者，这个就是一个“输出数据流”（数据从程序流出）。若程序是数据流的终点，这个数据流对程序而言就是一个“输入数据流”（数据从程序外流向程序）。
功能上分：输入流和输出流
结构上分：字节流（以字节为处理单位）和字符流（以字符为处理单位）。
字节流的输入流和输出流基础是InputStream和OutputStream这两抽象类，字节流的输入输出是有这两的子类实现的。字符流是java 1.1后新增加的一字符为单位进行输入输出处理的流，字符流的输入输出的基础是抽象的Reader和Writer。
在底层所有的输入输出都是字节流完成的。
输入流：
读数据的逻辑：
open a stream
while moreinformation
read information
close the stream
流的分类
节点流：从特定的地方读写的流类，列如：磁盘或一块内存区域。
过滤流：使用节点流作为输出或输入。过滤流是使用一个已经存在的输入或输出流连接创建的。
字节流

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamTest {
    public static void main(String[] args) throws IOException{
        InputStream io=new FileInputStream("c:/新建文本文档.txt");
        byte[] buffer=new byte[200];
        int length=0;
        while (-1!=(length=io.read(buffer,0,200)))
        {
            String str=new String(buffer,0,length);
            System.out.println(str);
        }
        io.close();
     }
}

这是读文档的常用方式。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStreamTest  {
    public static void main(String[] args) throws IOException {
        OutputStream io=new FileOutputStream("C:/新建文本文档.txt");
        String str="welcome aaa!";
        byte [] bytes=str.getBytes();
        io.write(bytes);
        io.close();
    }
}

这是写文件的一个模式。
BufferOutputStream

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class BufferOutputStreamTest {
    public static void main(String[] args) throws Exception{
        OutputStream os = new FileOutputStream("C:/新建文本文档.txt");
        BufferedOutputStream bos=new BufferedOutputStream(os);
        bos.write("My Name Is LC".getBytes());
        bos.close();
        os.close();
    }
}

ByteArrayInputStream是把字节数组当成源的输入流。

import java.io.ByteArrayInputStream;
public class ByteArrayInputStreamTest {
    public static void main(String[] args) {
        String temp="abcdefg";
        byte[]b=temp.getBytes();
        ByteArrayInputStream io=new ByteArrayInputStream(b);
        for (int i=0;i<temp.length();i++){
            int c;
            while ((c=io.read())!=-1){
                if (i==0){
                    System.out.println((char)c);
                }else {
                    System.out.println(Character.toUpperCase((char)c));
                }
            }
            System.out.println();
            io.reset();
        }
    }
}

DataOutputStream与DataInputStream
使用数据文件流的一般对象
（1）建立字节流对象。
（2）基于字节流对象建立数据文件流对象。
（3）用流对象的方法对基本类型的数据进行输入/输出。

public class DataStream1 {
    public static void main(String[] args) throws Exception{
        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(new FileOutputStream("data.txt")));
                byte b=3;
                int i=12;
                char c='a';
                float f=3.3f;
               dos.writeInt(i);
               dos.writeByte(b);
               dos.writeChar(c);
               dos.writeFloat(f);
               dos.close();
        DataInputStream dis=new DataInputStream
                ( new BufferedInputStream(new FileInputStream("data.txt")));
                 System.out.println(dis.readInt());
                 System.out.println(dis.readByte());
                System.out.println(dis.readChar());
                System.out.println(dis.readFloat());
    }
}

自己手写一个InputStream：

import java.io.IOException;
import java.io.InputStream;

public class MyOwnStream extends InputStream {
    protected byte[] data;
    protected int ptr=0;
    protected  int mark=0;
    public MyOwnStream(byte[]b)
    {
        this.data=b;
    }
    public int read(){
        return (ptr<data.length)?(data[ptr++]):-1;
    }
    @Override
    public int available() throws IOException {
        return data.length-ptr;
    }
    @Override
    public void close() throws IOException {
        ptr=data.length;
    }
    @Override
    public synchronized void mark(int readlimit) {
        this.mark=readlimit;
    }
    @Override
    public synchronized void reset() throws IOException {
        if (mark<0||mark>=data.length){
            throw new IOException("the position is not valid");
        }
        ptr=mark;
    }
    @Override
    public boolean markSupported() {
        return true;
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
      if (this.ptr>=data.length||len<0){
          return -1;
      }
      if ((this.ptr+len)>data.length){
          len=data.length-this.ptr;
      }
      if (len==0){
          return 0;
      }
      System.arraycopy(data,ptr,b,off,len);
      ptr+=len;
      return len;
    }
}

查看系统的字符集：

import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedMap;

public class CharSetTest {
    public static void main(String[] args) {
        SortedMap<String, Charset> map= Charset.availableCharsets();
        Set <String > set=map.keySet();
        for (Iterator<String> iterator=set.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }
    }
}

序列化
将对象转化为字节流保存起来，并在以后还原这个对象，这种机制叫做对象的序列化。
将一个对象保存到永久存储设备上称为持久化。
1、一个对象想要能够实现序列化，必须实现Serializabke接口或Externalizable接口（java.io.Serializable接口是一个标示性接口（Marker Interface），当一个类实现了该接口，就表示可以序列化的）
当一个对象被序列化是，只保存对象的非静态成员变量，不能保存任何成员的方法和静态的成员变量。
如果A包含了B的引用，那么在序列化A的时候也会将B一并地序列化。
如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化会失败并且抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象任然可以序列化。
序列化与反序列化：

import java.io.*;

public class SerializableTest {
    public static void main(String[] args) throws Exception {
        Person p1=new Person(20,"zhangsan",3.2);
        Person p2=new Person(10,"lisi",46.8);
        FileOutputStream fileOutputStream=new FileOutputStream("person.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fileOutputStream);
        oos.writeObject(p1);
        oos.writeObject(p2);
        System.out.println("___________________");
        FileInputStream fis=new FileInputStream("person.txt");
        ObjectInputStream ois=new ObjectInputStream(fis);
        Person p;
        for (int i=0;i<2;i++)
        {
            p=(Person)ois.readObject();
            System.out.println(p.age+","+p.name+","+p.height);
        }
        ois.close();
    }
}
class Person implements Serializable{
    int age;
    String name;
    double height;
    public Person(int age,String name,Double height){
        this.age=age;
        this.height=height;
        this.name=name;
    }
}

总结：
InputStream和OutputStream：字节流得输入输出。
Reader和Writer：字符流输入输出。
流的连接是依靠的装饰模式。
wait和notify方法是定义在Object类中的，无法重写的，这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法应该放在synchronized方法中。当线程执行wait方法是，它会释放点对象的锁。
另一个会导致线程暂停的方法就是sleep方法，它会导致线程指定的毫秒数，但线程在睡眠过程中是不会释放掉对象的锁的。