J2SE学习笔记（6）IO

在java.io包中，Java.io.InputStream表示字节输入流，java.io.OutputStream表示字节输出流。

 

public class FileDemo ...{
    public static void main(String[] args) ...{
        String s="Holle Gloomyboyo";
        byte[] buf=s.getBytes();
        //ByteArrayInputStream类本身采用了适配器模式，它把字节数组类型转换为输入流类型，
        //使得程序对字节数组进行操作。
        ByteArrayInputStream bai=new ByteArrayInputStream(buf);
        int data=-1;
        while((data=bai.read())!=-1)...{
            System.out.print((char)data);
        }
        try ...{
            bai.close();
        } catch (IOException e) ...{
            e.printStackTrace();
        }
    }
}

public class SequenceInputStreamDemo ...{

    public static void main(String[] args) throws Exception ...{
        
        InputStream is1 = new FileInputStream("g://1.txt");
        InputStream is2 = new FileInputStream("g://2.txt");
        InputStream is3 = new FileInputStream("g://3.txt");
        
        Vector v=new Vector();
        v.add(is1);
        v.add(is2);
        v.add(is3);
        
        //SequenceInputStream类可以将几个输入流串联在一起，合并为个输入流。

            //当通过着类来读取数据时，它会依次从所有被串联的输入流中读取数据。
        SequenceInputStream sis=new SequenceInputStream(v.elements());
        int length=-1;
        while((length=sis.read())!=-1)...{
            System.out.println((char)length);
        }
        sis.close();
    }
}

//文件读写
public class FileInputStreamDemo ...{
    public FileInputStreamDemo()...{
        File file = new File("g://1.txt");
        FileInputStream fis=new FileInputStream(file);
        byte[] buf=new byte[4];
        int length=-1;
        while((length=fis.read(buf))!=-1)...{
            System.out.println(length);
            System.out.println(new String(buf,0,length));
        }
        fis.close();
    }
    public static void main(String[] args) ...{
             new FileInputStreamDemo();
    }
}
public class FileOutputStreamDemo ...{
    public FileOutputStreamDemo() throws Exception...{
        OutputStream os=null;
        os=new FileOutputStream("g:/1.txt",true);//参数为true时，文本继续添加不删除前面的内容
        os.write(86);
    }
    public static void main(String[] args) ...{
            new FileOutputStreamDemo();

               //打印

               FileOutputStream fow=new FileOutputStream("g://1.txt",true);
               PrintWriter pw=new PrintWriter(new OutputStreamWriter(fow));
               pw.println("adsfasfdasfdasfddsafasd");

               //读取ini文件

               Properties prop = new Properties();
               InputStream in = new FileInputStream("db.ini");
               prop.load(in);
               System.out.println(prop.getProperty("username"));
               System.out.println(prop.getProperty("username1","dfdf"));
               System.out.println(prop.getProperty("password"));
    }
}

//键盘输出
public class StandardIn ...{
    public StandardIn()...{
        InputStream sin=System.in;
        char c=(char)-1;
        while((c=(char)sin.read())!='q')...{
            System.out.print(c);
        }
    }
    public static void main(String[] args) ...{
        new StandardIn();
    }
}

//复制文本
public class copyst ...{
    public static void copyst(File in,File out) throws IOException...{
        InputStream is=new FileInputStream(in);
        OutputStream os=new FileOutputStream(out);
            
        int data=-1;
        while((data=is.read())!=-1)...{
            os.write(data);
        }
        
    }
    
    public static void main(String[] args) ...{
        copyst(new File("g:/1.txt"),new File("g:/2.txt"));
    }
}

//DataInputStrea实现了DataInput接口，用于读取基本类型数据
public class DataInputStreamLab ...{
    public static void main(String[] args) throws Exception ...{
        FileOutputStream fos=new FileOutputStream("G;/1.txt");
        DataOutputStream dis=new DataOutputStream(fos);
        dis.writeDouble(100.11);//基本类型数据如 int、float、long、boolean等
        dis.flush();
        dis.close();
        FileInputStream fis=new FileInputStream("G;/2.txt");
        DataInputStream die=new DataInputStream(fis);
        System.out.println(die.readDouble());
    }
}

//管道流从一个管道输出流中的数据。通常由一个线程向管道输出流写出数据，
//由另一个线程从管道输入流中读取数据,两线程可以通过用管道来通讯。
public class PipedDemo ...{
    public static void main(String[] args) throws IOException ...{
        PipedOutputStream pos=new PipedOutputStream();
        PipedInputStream ps = new PipedInputStream(pos);
        pos.write(100);
        System.out.println(ps.read());
    }
}

//对象流的操作
public class SerializableDemo ...{
    public static void main(String[] args) throws IOException, Exception ...{
        FileOutputStream fos=null;
        try ...{
            fos=new FileOutputStream("g:/1.txt");
            ObjectOutputStream os=new ObjectOutputStream(fos);
            MsgPack mp = new MsgPack();
            mp.setType("0001");
            mp.setFrom("cqs");
            mp.setTo("ccc");
            mp.setContent("hello");
            mp.setPassword("8888");
            os.writeObject(mp);
            os.flush();
            os.close();
        } catch (FileNotFoundException e) ...{
            e.printStackTrace();
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        FileInputStream fis=null;
        try ...{
            fis=new FileInputStream("g:/1.txt");
        } catch (FileNotFoundException e) ...{
            e.printStackTrace();
        }
        ObjectInputStream ois=new ObjectInputStream(fis);
        Object o=ois.readObject();
        System.out.println(o);
    }
}