Java:IO流其他类(字节数组流、字符数组流、数据流、打印流、Properities、对象流、管道流、随机访问、序列流、字符串读写流)

简介:
一、字节数组流:
类 ByteArrayInputStream:在构造函数的时候,需要接受数据源,而且数据源是一个字节数组。
包含一个内部缓冲区,该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节
关闭ByteArrayInputStream流无效。此类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException
 
类 ByteArrayOutputStream:在构造函数的时候,不用定义数据目的,因为该对象中内部已经封装了可变长度的字节数组,这就是数据的目的地。
此类实现了一个输出流,其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。
可使用toByteArray()和toString()获取数据。 
关闭ByteArrayOutputStream流无效。此类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException。
 
这两个流对象操作的都是数组,并没有使用系统资源,所以,不用进行close()关闭。
用流的思想去操作数组。
 
在流操作讲解时:
源设备:键盘(System.in)、硬盘(FileStream)、内存(ArrayStream)
目的设备:控制台(System.out)、硬盘(FileStream)、内存(ArrayStream)
//例子1:
复制代码
import java.io.*;
class ByteArrayStreamDemo
{
    public static void main(String[] args)
    {
        //数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());//getBytes()是将一个字符串转化为一个字节数组
        
        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int by = 0;
        while((by = bis.read())!=-1)
        {
            bos.write(by);
        }
        
        System.out.println(bos.size());
        System.out.println(bos.toString());
        
        //bos.writeTo(new FileOutputStream("ByteArray.txt"));//只有此处需要对异常进行处理。
    }
}
复制代码
二、字符数组流:CharArrayReader和CharArrayWriter
 
类 CharArrayReader:在构造函数的时候,需要接受数据源,而且数据源是一个字符数组。
此类实现一个可用作字符输入流的字符缓冲区。读入流会产生IOException 
 
类 CharArrayWriter:在构造函数的时候,不用定义数据目的,因为该对象中内部已经封装了可变长度的字符数组,这就是数据的目的地。
此类实现了一个输出流,其中的数据被写入一个char数组。缓冲区会随着数据的不断写入而自动增长。
可使用toCharArray()和toString()获取数据。 
关闭CharArrayWriter流无效。此类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException。
 
这两个流对象操作的都是数组,并没有使用系统资源,所以,不用进行close()关闭。
用流的思想去操作数组。
//例子2:
复制代码
import java.io.*;
class CharArrayStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //数据源
        CharArrayReader car = new CharArrayReader("世界第一等".toCharArray());//toCharArray()是将一个字符串转化为一个字符数组
        
        //数据目的
        CharArrayWriter caw = new CharArrayWriter();
        int by = 0;
        while((by = car.read())!=-1)
        {
            caw.write(by);
        }
        
        System.out.println(caw.size());
        System.out.println(caw.toString());
        
        //caw.writeTo(new FileOutputStream("CharArray.txt"));//需要对异常进行处理。
    }
}
复制代码
三、数据流
DataInputStream: DataInputStream(InputStream in) 
DataOutputStream: DataOutputStream(OutputStream out) 
可以用于操作基本数据类型的数据的流对象。
//例子3:
复制代码
import java.io.*;
class DataStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //WriteData();
        //ReadData();
        WriteUTFDemo();
        ReadUTFDemo();
    }
    public static void WriteData()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data.txt"));
        dos.writeInt(10);
        dos.writeChar(97);
        dos.writeDouble(3.1415926);
        dos.writeBoolean(true);
        dos.close();        
    }
    public static void ReadData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("Data.txt"));
        System.out.println(dis.readInt());
        System.out.println(dis.readChar());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        dis.close();
    }
    
    
    public static void WriteUTFDemo()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data-UTF.txt"));
        dos.writeUTF("你好");
        dos.close();
    }
    public static void ReadUTFDemo()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("Data-UTF.txt"));
        System.out.println(dis.readUTF());
        dis.close();
    }
}
复制代码
四、管道流:
PipedInputStream 
PipedOutputStream 
作用:输入输出可以直接进行连接,通过结合线程使用。
//例子4:
复制代码
import java.io.*;
class ReadPiped implements Runnable
{
    private PipedInputStream in;
    ReadPiped(PipedInputStream in)
    {
        this.in = in;
    }
    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];
            
            System.out.println("读取前,没有数据,管道阻塞开始");
            int len = in.read(buf);
            System.out.println("读取数据,管道阻塞结束");
            
            String s = new String(buf,0,len);
            System.out.println(s);
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道读取流失败!");
        }
        finally
        {
            try
            {
               in.close();    
            }
            catch(IOException e)
            {
              throw new RuntimeException("流关闭失败!");
            }
        }
    }
}
class WritePiped implements Runnable
{
    private PipedOutputStream out;
    WritePiped(PipedOutputStream out)
    {
        this.out = out;
    }
    public void run()
    {
        try
        {
            System.out.println("开始写入数据,等待5秒");
            Thread.sleep(5000);
            out.write("guandao lai le".getBytes());
            out.close();    
        }
        catch(Exception e)
        {
            throw new RuntimeException("管道输出流失败!");
        }
    }            
}
class PipedStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);//使此管道输入流连接到管道输出流 
        
        ReadPiped r = new ReadPiped(in);
        WritePiped w = new WritePiped(out);
        
        new Thread(r).start();
        new Thread(w).start();
    }
}
复制代码
五、打印流:PrintStream 
        PrintWriter 
java.lang.Object
  继承者 java.io.OutputStream
      继承者 java.io.FilterOutputStream
          继承者 java.io.PrintStream
 
java.lang.Object
  继承者 java.io.Writer
      继承者 java.io.PrintWriter
--------------------------------------------------------
打印流提供了打印方法,可以将各种类型的数据原样打印出来。
 
PrintStream:字节打印流
构造函数可以接受的类型:1.file对象。File
                        2.字符串路径。String 
                        3.字节输出流。OutputStream
//PrintStream(OutputStream out, boolean autoFlush) 
 如果为 true,则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 ('\n') 时都会刷新
 
PrintWriter:字符打印流
构造函数可以接受的类型:
1.file对象。File
2.字符串路径。String 
3.字节输出流。OutputStream
4.字符数据流。Writer
//PrintWriter(OutputStream out, boolean autoFlush) 
autoFlush为true时,则println、printf或format将自动刷新输出缓冲流

 //例子5:

复制代码
import java.io.*;
class PrintStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        
        PrintWriter ps = new PrintWriter(System.out,true);//(new BufferedWriter(new FileWriter("F:\\myfile\\print.txt")),true)
        
        String line = null;
        
        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            ps.println(line.toUpperCase());
            //ps.flush();
        }
        ps.close();
        bufr.close();
    }
}
复制代码
六、Properties
它是hashtable的子类, 也就是它具备了Map集合的特点,而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点:可以用于键值对形式的配置文件
那么在加载数据时,需要数据有固定格式:键=值
 Object setProperty(String key, String value) 
          调用 Hashtable 的方法 put。 
 String getProperty(String key) 
          用指定的键在此属性列表中搜索属性。 
 String getProperty(String key, String defaultValue) 
          用指定的键在属性列表中搜索属性。 
 Set<String> stringPropertyNames()  
          返回此属性列表中的键集
 void load(InputStream inStream) 
          从输入流中读取属性列表(键和元素对)。 
 void load(Reader reader) 
          按简单的面向行的格式从输入字符流中读取属性列表(键和元素对)。
  void store(OutputStream out, String comments) 
          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式,并存储到打印流中 
 void store(Writer writer, String comments) 
          以适合使用 load(Reader) 方法的格式,并存储到打印流中 。 
//例子6:
复制代码
import java.io.*;
import java.util.*;
class PropertiesDemo
{
    public static void main(String[] args)throws IOException
    {
        //setAndget();
        //method_1();
        method_2();
    }
    //演示如何将流中的数据添加放到集合中
    //想要将key-value.txt数据存到集合进行操作
    /*
     步骤:1.用一个流和key-value相关联
           2.读一行数据,将该行数据用"="进行切割
           3.等号左边作为键,右边作为值,存入到Properties集合即可。
    */
    //方法1(load方法的原理)
    public static void method_1()throws IOException
    {
        Properties p = new Properties();
        //FileInputStream fis = new FileInputStream("F:\\myfile\\key-value.txt");
        BufferedReader bufr = new BufferedReader(new FileReader("F:\\myfile\\key-value.txt"));
        String str=null;
        while((str=bufr.readLine())!=null)
        {
            String[] s = str.split("=");
            System.out.println(s[0]+"...."+s[1]);
            p.setProperty(s[0],s[1]);
        }
        //System.out.println(p);
        p.list(System.out);
        bufr.close();
    }
    //方法2(直接调用load方法)
    public static void method_2()throws IOException
    {
        Properties p = new Properties();
        p.load(new FileReader("F:\\myfile\\key-value.txt"));//p.load(new FileInputStream("F:\\myfile\\key-value.txt"))
        
        p.setProperty("zhaoliu","100");//修改已有的姓名的年龄并保存在文件中
        p.store(new FileWriter("F:\\myfile\\key-value.txt"), p.toString());
        System.out.println(p);
    }
    

    
    //设置和获取元素
    public static void setAndget()
    {
        Properties p = new Properties();
        p.setProperty("zhangsan","30");
        p.setProperty("lisi","40");
        
        System.out.println(p);
        
        
        String value = p.getProperty("lisi");
        System.out.println("value="+value);

        //p.setProperty("lisi",89+"");//修改lisi年龄
        
        Set<String> name = p.stringPropertyNames();
        Iterator<String> it = name.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            System.out.println("key:"+key+" "+"value"+p.getProperty(key));
        }
        /*
        for(String key: name)
        {
            System.out.println("key:"+key+" "+"value"+p.getProperty(key));
        }
        */        
    }
}
复制代码
七、随机访问类
类 RandomAccessFile:此类的实例支持对随机访问文件的读取和写入
java.lang.Object
       继承者 java.io.RandomAccessFile
  
RandomAccessFile:RandomAccessFile(File file, String mode) 
该类不算是IO体系中的子类, 而是直接继承Object。
 
但是它是IO包中的成员,因为它具备读和写功能。
内部封装了一个数组,而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置或者通过seek改变指针的位置。
 
其实,完成读写的原理是内部封装了字节输入流和输出流。
 
通过构造函数可以看出,该类只能操作文件。
而且,操作文件还有模式mode:只读r、读写rw、rws、rwd
 
如果文件只读r,不会创建文件,而是会去读取一个存在的文件,如果该文件不存在,则会出现异常。
如果文件为读写rw,要操作的文件不存在,会自动创建,而且如果存在不会覆盖。 
//例子7:
复制代码
import java.io.*;
class RandomAccessFileDemo
{
    public static void main(String[] args)throws IOException
    {
        //WriteFile();
        //WriteFile2();
        ReadFile();
    }
    public static void WriteFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("Random.txt","rw");
        raf.write("李四".getBytes());
        raf.writeInt(65);
        raf.write("王武".getBytes());
        raf.writeInt(67);
        raf.close();
    }
    
    
    public static void WriteFile2()throws IOException
    {
        //改变指针,随机位置写入数据,还可以修改之前位置所写的数据(不会重新覆盖创建的文件)
        RandomAccessFile raf = new RandomAccessFile("Random.txt","rw");
        raf.seek(8*3);
        raf.write("周七".getBytes());
        raf.writeInt(69);        
        raf.seek(8*2);
        raf.write("赵六".getBytes());
        raf.writeInt(68);
        raf.close();        
    }
    
    
    
    public static void ReadFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("Random.txt","r");
        PrintStream ps = System.out;
        System.setOut(ps);
        byte[] buf = new byte[4];
        //ps.println(raf.getFilePointer());//获取当前指针位置
        //raf.seek(8*1);//改变当前指针的位置(可以前后移动)
        //raf.skipBytes(8);//跳过8个字节(只能往后跳)
        while(raf.read(buf)!=-1)
        {
            String name = new String(buf);
            ps.println("name="+name);
            
            int age= raf.readInt();
            ps.println("age="+age);
            
        }
            raf.close();            
    }
}
复制代码
八、序列流
java.lang.Object
  继承者 java.io.InputStream
      继承者 java.io.SequenceInputStream
类 SequenceInputStream:表示其他输入流的逻辑串联
构造方法:
SequenceInputStream(Enumeration<? extends InputStream> e) 
SequenceInputStream(InputStream s1, InputStream s2)  
合并文件
//例子8:
复制代码
import java.io.*;
import java.util.*;
class SequenceStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("F:\\myfile\\1.txt"));
        v.add(new FileInputStream("F:\\myfile\\2.txt"));
        v.add(new FileInputStream("F:\\myfile\\3.txt"));
        
        Enumeration<FileInputStream> enu = v.elements(); 
        SequenceInputStream sis = new SequenceInputStream(enu);//将多个流整合为一个流对象
        
        BufferedWriter bufw = new BufferedWriter(new FileWriter("F:\\myfile\\123.txt"));
        
        int num = 0;
        while((num=sis.read())!=-1)
        {
            bufw.write(num);
            bufw.flush();
        }
        sis.close();
        bufw.close();
    }
}
复制代码
九、字符串读写流
类 StringReader:其源为一个字符串的字符流。
    StringReader(String s) 创建一个新字符串 reader。
类 StringWriter:一个字符流,可以用其回收在字符串缓冲区中的输出来构造字符串。关闭 StringWriter 无效。 
                 此类中的方法在关闭该流后仍可被调用,而不会产生任何 IOException。
    StringWriter() 
          使用默认初始字符串缓冲区大小创建一个新字符串 writer。
//例子9:
复制代码
import java.io.*;
class StringReaderWriterDemo
{
    public static void main(String[] args)throws IOException
    {
        StringReader sr = new StringReader("Thank you very much");
        StringWriter sw = new StringWriter();
        
        //StringWriter s = sw.append('A');
        int by = 0;
        while((by=sr.read())!=-1)
        {
            sw.write(by);
        }
        
        System.out.println(sw.toString());
    }
}
复制代码
十、对象流
类 ObjectInputStream:  
 1.ObjectOutputStream() 
  2.ObjectOutputStream(OutputStream out)  
  3.void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
           
java.lang.Object
  继承者 java.io.InputStream
      继承者 java.io.ObjectInputStream
---------------------------------------------------------------------  
类 ObjectOutputStream:  
1.ObjectInputStream() 
2.ObjectInputStream(InputStream in)  
3.Object readObject() 从 ObjectInputStream 读取对象。
  
java.lang.Object
  继承者 java.io.OutputStream
      继承者 java.io.ObjectOutputStream
//例子10:
复制代码
import java.io.*;
class ObjectStreamDemo
{
    public static void main(String[] args)throws Exception
    {
        //writeObj();
        readObj();
    }
    public static void writeObj()throws IOException
    {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Object.txt"));
        oos.writeObject(new Person("zhangsan",25));
        oos.close();
    }
    public static void readObj()throws Exception
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Object.txt"));
        Person p =(Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
}
复制代码

 

程序猿神奇的手,每时每刻,这双手都在改变着世界的交互方式!
本文转自当天真遇到现实博客园博客,原文链接:http://www.cnblogs.com/XYQ-208910/p/4918714.html如需转载请自行联系原作者
相关文章
|
18天前
|
Java
Java 数组转字符串
Java 数组转字符串
|
1天前
|
Java
java去除重复字符串
java去除重复字符串
|
2天前
|
Java 程序员
java截取字符串的几种方法
java截取字符串的几种方法
|
17天前
|
算法 Java Go
【经典算法】LeetCode28 找出字符串中第一个匹配项的下标(Java/C/Python3实现含注释说明,Easy)
【经典算法】LeetCode28 找出字符串中第一个匹配项的下标(Java/C/Python3实现含注释说明,Easy)
7 0
|
17天前
|
存储 算法 Java
【经典算法】LeetCode 151. 反转字符串中的单词(Java/C/Python3实现含注释说明,中等)
【经典算法】LeetCode 151. 反转字符串中的单词(Java/C/Python3实现含注释说明,中等)
11 0
|
17天前
|
存储 算法 Java
【经典算法】LeetCode 1170:比较字符串最小字母出现频次(Java/C/Python3实现含注释说明,中等)
【经典算法】LeetCode 1170:比较字符串最小字母出现频次(Java/C/Python3实现含注释说明,中等)
11 0
|
18天前
|
Java
Java 截取字符串中指定的分隔符放入list中
Java 截取字符串中指定的分隔符放入list中
|
18天前
|
Java
io读两个文件,生成list 排重后写本地文件(Java)
io读两个文件,生成list 排重后写本地文件(Java)
|
22天前
|
存储 Java API
Java语言IO(输入/输出)编程技术深度解析
Java语言IO(输入/输出)编程技术深度解析
252 1
|
26天前
|
存储 Java API
Java IO流
Java IO流
28 2