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如需转载请自行联系原作者
相关文章
|
4月前
|
存储 Java
【IO面试题 四】、介绍一下Java的序列化与反序列化
Java的序列化与反序列化允许对象通过实现Serializable接口转换成字节序列并存储或传输,之后可以通过ObjectInputStream和ObjectOutputStream的方法将这些字节序列恢复成对象。
|
5月前
|
Java 大数据
解析Java中的NIO与传统IO的区别与应用
解析Java中的NIO与传统IO的区别与应用
|
1月前
|
存储 弹性计算 固态存储
阿里云服务器ESSD Entry系统盘测评IOPS、IO读写和时延性能参数
ESSD Entry云盘是阿里云推出的新一代云盘,具备高IOPS、低延迟和企业级数据保护能力。适用于开发与测试场景,支持按量付费和包年包月计费模式。99元和199元的ECS经济型e实例和通用算力型u1实例均采用ESSD Entry系统盘,性价比高。详细性能参数和价格请参考阿里云官方页面。
79 0
|
3月前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流(Stream)、文件(File)和输入/输出(I/O)是处理数据的关键概念。`File`类用于基本文件操作,如创建、删除和检查文件;流则提供了数据读写的抽象机制,适用于文件、内存和网络等多种数据源;I/O涵盖更广泛的输入输出操作,包括文件I/O、网络通信等,并支持异常处理和缓冲等功能。实际开发中,这三者常结合使用,以实现高效的数据处理。例如,`File`用于管理文件路径,`Stream`用于读写数据,I/O则处理复杂的输入输出需求。
254 12
|
4月前
|
Java 数据处理
Java IO 接口(Input)究竟隐藏着怎样的神秘用法?快来一探究竟,解锁高效编程新境界!
【8月更文挑战第22天】Java的输入输出(IO)操作至关重要,它支持从多种来源读取数据,如文件、网络等。常用输入流包括`FileInputStream`,适用于按字节读取文件;结合`BufferedInputStream`可提升读取效率。此外,通过`Socket`和相关输入流,还能实现网络数据读取。合理选用这些流能有效支持程序的数据处理需求。
56 2
|
4月前
|
XML 存储 JSON
【IO面试题 六】、 除了Java自带的序列化之外,你还了解哪些序列化工具?
除了Java自带的序列化,常见的序列化工具还包括JSON(如jackson、gson、fastjson)、Protobuf、Thrift和Avro,各具特点,适用于不同的应用场景和性能需求。
|
4月前
|
Unix 数据处理 Perl
|
4月前
|
缓存 Java
【IO面试题 一】、介绍一下Java中的IO流
Java中的IO流是对数据输入输出操作的抽象,分为输入流和输出流,字节流和字符流,节点流和处理流,提供了多种类支持不同数据源和操作,如文件流、数组流、管道流、字符串流、缓冲流、转换流、对象流、打印流、推回输入流和数据流等。
【IO面试题 一】、介绍一下Java中的IO流
|
4月前
|
Ubuntu Linux
内核实验(九):添加IO驱动的阻塞读写功能
本文通过修改内核模块代码,介绍了如何在Linux内核中为IO驱动添加阻塞读写功能,使用等待队列和条件唤醒机制来实现读写操作的阻塞和非阻塞模式,并在Qemu虚拟机上进行了编译、部署和测试。
28 0
|
5月前
|
存储 缓存 Java
Java零基础入门之IO流详解(二)
Java零基础入门之IO流详解(二)