Java学习笔记之IO 4

IO学习笔记---不常用的流

一、基本数据类型流

1.概述：

    DataInputStream类:数据输入流，用来读取流中的java基本数据类型的数据

    DataOutputStream类:数据输出流，用来向字节流中写出java基本数据类型的数据

    作用：把基本数据类型在流中传输。以前学的流只能传输byte和char型。

    2.构造方法

       public DataInputStream(InputStream in)//使用指定的底层 InputStream 创建一个 DataInputStream。

       public DataOutputStream(OutputStream out)//创建一个新的数据输出流，将数据写入指定基础输出流。

         3.常用方法：

        DataInputStream类中常用方法

    public finalboolean readBoolean()

    public finalbyte readByte()

    public finalshort readShort()

    public final intreadInt()

    public final intreadInt()

public final char readChar()

    public finalfloat readFloat()

    public finalvoid writeDouble(double v)

    public finalvoid writeUTF(Stringstr)

    DataOutputStream类中常用方法

   public final void writeBoolean(booleanv)

   publicfinal void writeByte(int v)

public final void writeShort(int v)

public final void writeInt(int v)

public final void writeLong(long v)

public final void writeChar(int v)

public final void writeFloat(float v)

public final void writeDouble(double v)

public final void writeUTF(Stringstr)

4.测试案例：

public class BaseStream {

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

       //write();//第一步先写数据

       read();//第二步再读数据

    }

    //读数据

    private static void read() throws IOException {

       //通过基本字节输入流的方式把数据从指定的文件中读取出来

       DataInputStreamdis = new DataInputStream(new FileInputStream("d:\\lee\\111.java"));

       //调用DataInputStream类中的方法，把基本数据类型通过字节流的方式从文件中读取出来，并显示到控制台。

       System.out.println(dis.readByte());

       System.out.println(dis.readShort());

       System.out.println(dis.readInt());

       System.out.println(dis.readLong());

       System.out.println(dis.readFloat());

       System.out.println(dis.readDouble());

       System.out.println(dis.readChar());

       System.out.println(dis.readBoolean());

       System.out.println(dis.readUTF());

       dis.close();//关闭读取流

    }

    //写数据

    private static void write() throws IOException {

       DataOutputStreamdos = new DataOutputStream(new FileOutputStream("d:\\lee\\111.java"));

       //调用DataOutputStream类中的方法，把java中基本数据类型通过基本字节流写入到文件中。

       dos.writeByte(97);  

       dos.writeShort(1000);

       dos.writeInt(12345);

       dos.writeLong(1234567890123L);

       dos.writeFloat(3.14F);

       dos.writeDouble(3.1415926);

       dos.writeChar('A');

       dos.writeBoolean(false);

       dos.writeUTF("哈哈");

       dos.close();//关闭写入流

    }

}

注意：把数据写在111.java文件后，用记事本打开时，显示是乱码。当用基本数据输出流读取111.java文件中的数据显示到控制台，数据显示正常。

输出结果：

97

1000

12345

1234567890123

3.14

3.1415926

A

False

哈哈

二、内存操作流

简介：程序运行结束，流中的数据消失, 存取速度快，实际很少使用。该流把数据写到数组中，并没写到文件中

    分类：

字节数组输入输出流

       ByteArrayInputStream

       ByteArrayOutputStream

    字符数组输入输出流

       CharArrayReader

       CharArrayWrite

    字符串输入输出流

       StringReader

       StringWriter

    ByteArray构造方法：

       public ByteArrayInputStream(byte[] buf)

        public ByteArrayOutputStream()

    测试代码：

public class MemoryStream {

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

       method();

    }

    private static void method() throws IOException {

       //创建字节输出流对象

       ByteArrayOutputStreambaos =new ByteArrayOutputStream();

       //往流中写数据，把字符串转换成字符数组

       baos.write("abcde".getBytes());

       //获取写入到字符输出流中的数据

       byte[]byteArray =baos.toByteArray();

       //byte[] byteArray = baos.toString();

       //创建字节输入流对象,并把读到的数据作为参数传递给输入流

       ByteArrayInputStreambais =new  ByteArrayInputStream(byteArray);

       //从输入流中取数据

       int ch = -1;

       while ((ch =bais.read()) != -1) {

           System.out.print((char)ch);

//把数据输出到控制台，强转成字符型。

       }

    }

}

三、打印流 

    简介：打印流，相当于IO流中的输出流，只有打印流才能完成自动刷新，打印流只有输出流，没有输入流。

         PrintWriter：字符打印流，复制文本文件

         PrintStream：字节打印流，复制各种文件，推荐使用字节流

     构造方法：

     以PrintWriter为例，PrintStream类中的构造方法和普通方法和PrintWriter类似，用法也相同，此处省略。

         public PrintWriter(Writer out, boolean autoFlush)

         //创建新PrintWriter。

         public PrintWriter(OutputStream out,boolean autoFlush)

         //通过现有的OutputStream 创建新的 PrintWriter

     常用方法：

         public void print(typei)             //打印各种类型的数据，

         public void println(typei) //打印各种类型的数据,同时完成换行

         public void write(typei)            //写指定类型的数据：char，int，String

     测试案例1：

public class PrintWriterDemo2{

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

       //开启自动刷新的同时，实现数据的追加

       //FileWriter(File file, boolean append) //参数1(参数1文件，参数2自动追加),参数2自动刷新

       PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt",  true),true);

       //写数据

       //pw.write("赵日天");

       pw.println("自动刷新功能");

       //关闭流

       pw.close();

    }

}

测试案例2：文件复制

public class CopyText {

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

       //1、数据源：使用高效字符输入流，读取源文件文件中的数据

       BufferedReaderbr = new BufferedReader(new FileReader("d:\\lee\\1111.java"));//把基本字符输入流包装成高效字符输入流

       //2、目的地：使用打印流，把读到的源文件数据写到目的地文件中

       PrintWriter pw = new PrintWriter("c:\\lee\\1.java");//如果指定文件不存在，先创建该文件

       //3、用高效字符流读数据，一次读取一行数据

       String line= null;//默认文件为空

       while ((line =br.readLine()) !=null) {

           //4、用打印流写数据，一次写一行数据

           pw.println(line);

       }

       //关闭流

       br.close();//关闭源文件流

       pw.close();//关闭目标文件流

    }

    }

四、标准输入输出流

    简介：在 System类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法，从JDK1.0开始。

         字段

         in：InputStream      //“标准”字节输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。

         out：PrintStream    //“标准”字节输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标

         err：PrintStream    //“标准”错误字节输出流。此流已打开并准备接受输出数据

         备注：

                   System.in 等价于InputStreamis

                  System.out 等价于PrintStreamPS

     构造方法：

         System不能被实例化，所以无构造函数。

     常用方法：

         public staticvoid exit(int status)// 终止当前正在运行的Java 虚拟机

          publicstatic void gc()//运行垃圾回收器

注意事项：java中有3种键盘输入方式

        1：dos命令输入

        2：Scanner对象，调用nextxxx()方法

        3：System.in 标准输入流

2种数据输出方式

        1：System.out.println()

        2：System.out

五、随机访问流：不重要

    简介：RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对随机访问文件的读取和写入。

    构造方法：

public RandomAccessFile(File file,String mode)//创建从中读取和向其中写入（可选）的随机访问文件流，该文件由File参数指定。

       public RandomAccessFile(String name,String mode)//创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。

    mode:打开文件的模式

"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出IOException。

"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。

"rws"打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。

"rwd"打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备

    常用方法：

       public final type readtype()//读取各种类型的数据

       public void write(int b) //写各种类型数据

       public long getFilePointer()//返回此文件中的当前偏移量

       public void seek(long pos)//设置到此文件开头测量到的文件指针偏移量

六、序列化流：

简介：

序列化流：把new出来的对象写到流所对应的文件中,写对象。

        ObjectOutputStream

反序列化流：从流所对应的文件中，把对象读出来,读对象。

        ObjectInputStream

    序列化流的作用：把new出来的对象，通过IO流存储到某个文件中，或者通过IO流把一个对象传输到另一台计算机中使用，可以完成对象在网络中的传输。

    序列化流、反序列化流除了可以存储在文件中，还可以实现数据在网络中传输

    注意：

只能将支持 java.io.Serializable 接口的对象写入流中，未实现Serializable接口的类将无法使其任何状态序列化或反序列化。

    构造方法：

       public ObjectOutputStream(OutputStreamout)//可以把序列化对象存储 到指定的流所对应的文件中

    方法：

       public final void writeObject(Object obj)//将指定的对象写入ObjectOutputStream。

    测试案例：把自定义类对象写入文件中，再读取出来

public class ObjectStream {

    public static void main(String[] args) throws IOException,ClassNotFoundException {

       //write();

       read();

    }

    //从流中读对象

    private static void read() throws IOException,ClassNotFoundException {

       //创建流对象

       ObjectInputStreamois =new ObjectInputStream(new FileInputStream("oos.txt"));

       //从流中读取对象

       Object obj = ois.readObject();

       System.out.println(obj);

       //关闭流

       ois.close();

    }

    //把对象写到流中

    private static void write() throws IOException {

       //1、创建流对象

       ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("oos.txt"));

       //2、写对象到流中

       oos.writeObject(new Person("班长", 18));

       //3、关闭流

       oos.close();

    }

}

    //自定义类必须实现Serializable才能使用序列化或反序列化

public class Person implements Serializable {

    //序列化版本号,把类名、成员进行统一的编号

    //注意：用final修饰序列化号，无论类中的成员是否有变化，该序列号都不变

    private static final long serialVersionUID = -2957124311737443309L;

    private Stringname;

    //使用transient临时关键字声明不需要序列化的成员变量

    private transient int age;

    public Person() {

       super();

    }

    public Person(Stringname,intage) {

       super();

       this.name =name;

       this.age =age;

    }

    public String getName(){

       returnname;

    }

    public void setName(String name) {

       this.name =name;

    }

    public int getAge() {

       returnage;

    }

    public void setAge(intage) {

       this.age =age;

}

    @Override

    public StringtoString() {

       return"Person [name=" +name + ", age=" +age + "]";

    }

}

七、properties集合

简介：Properties 类表示了一个持久的属性集。可保存在流中或从流中加载.属于Map集合，它是Hashtable的子类与IO流进行交互的一个集合，键和值的数据类型都是String类型。从JDK1.0开始

构造方法：

public Properties()//创建一个无默认值的空属性列表

public Properties(Properties defaults)

//创建一个带有指定默认值的空属性列表。

常用方法：

public String getProperty(String key)//根据键找对应的值

public String getProperty(String key,String defaultValue)//根据键找对应的值，如果未找到属性，则此方法返回默认值变量

public Enumeration<?> propertyNames()//获取集合中所有的键

public Object setProperty(String key,String value)//调用 Hashtable 的方法 put。

public voidlist(PrintStream out)//把集合中的数据写到流所对应的文件中

public voidlist(PrintWriter out)//把集合中的数据写到流所对应的文件中

public voidload(InputStream inStream)//把流所对应的文件中的数据存储到指定的Properties集合中

       public void load(Reader reader)//把流所对应的文件中的数据存储到指定的Properties集合中

public void store(OutputStream out,String comments)//把集合中的数据 写到流 所对应的文件中

       public void store(Writer writer, String  comments)//把集合中的数据写到流所对应的文件中.参数comments:属性列表的描述（注释）

注意：store方法存储数据时，不支持中文。

测试案例：已知一个文件是键值对形式存在的，判断该文件是否有“lisi”这样的键，如果有就把值改为100，

public class PropertiesTest {

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

       //1: 创建一个空集合

       Properties prop = new Properties();

       //2: 把文件中的数据读取出来，存储到集合

       //用指定的文件路径创建一个字节输入流对象

       FileInputStreamfis = new FileInputStream("d:\\lee\\11.txt");

       prop.load(fis);//把文件中的内容加载到集合中

       fis.close();//关闭文件

       //获取集合中所有的键

       Set<Object>keys = prop.keySet();

       //3: 遍历集合，判断有没有键为"lisi"

       for (Objectkey :keys) {

           if ("lisi".equals(key)) {//通过键找值

              //把list对应的值改为100

              prop.setProperty((String)key,"100");

           }

       }

       System.out.println(prop);//打印集合中的值

       //4: 把集合存储到流所对应的文件中

       FileOutputStreamfos = new

           FileOutputStream("d:\\lee\\11.txt");

       prop.store(fos,"PropertiesTest");//保存，并添加注释

       fos.close();//关闭文件

    }

}

Properties类可以用于保存配置文件信息

八、NIO：新IO

简介：NIO其实就是新IO的意思，JDK1.4出现。新IO和传统的IO有相同的目的，都是用于进行输入输出的，但新IO使用了不同的方式来处理输入输出，采用内存映射文件的方式，将文件或者文件的一段区域映射到内存中，就可以像访问内存一样的来访问文件了，这种方式效率比旧IO要高很多，但是目前使用较多的还是旧IO。

JDK1.7的新IO类：

Files: 文件工具类

    publicstatic long copy(Path source,OutputStream out)//复制文件

    publicstatic Path write(Path path,Iterable<? extendsCharSequence> lines,Charset cs,OpenOption... options)//把集合的数据写到文件

    参数：

path:指定存储到的文件路径

lines:指定集合

cs:指定使用的编码

   Path: 它是接口，表示路径的意思

   Paths: 路径工具类

public static Path get(URI uri)//根据给定的URI来确定文件路径。

public static Path get(String first,String... more)//根据给定的String路径，得到一个路径对象

    测试案例：

public class NIODemo {

    public static void main(String[] args) throwsFileNotFoundException, IOException {

       //文件复制

       //Files.copy(Paths.get("d:\\lee\\11.txt"), new FileOutputStream("d:\\lee1.txt"));

       //把集合中的数据存储到文件

       ArrayList<String>list =new ArrayList<String>();

       list.add("Java基础知识");

       list.add("面向对象");

       list.add("图形化界面开发GUI");

       list.add("常用API");

       list.add("集合IO");

       //Files.write(Paths.get("study.txt"), list,

       Charset.forName("gbk"));//gbk编码

       Files.write(Paths.get("study.txt"),list,

       Charset.forName("utf-8"));//utf-8编码

    }

}