Day23（CopyFile，InputStreamReader,OutputStreamWruiter,Buffered,BufferedInputStream,BufferedOutputStr）

最新推荐文章于 2024-10-11 17:30:36 发布

刘浩浩yyds

最新推荐文章于 2024-10-11 17:30:36 发布

阅读量140

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_65996579/article/details/123057931

版权

Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、CopyFileDemo1

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/*
    把当前目录下的a.txt内容复制到当前项目目录下的b.txt中

    输入流
      InputStream--FileInputStream
      一次读取一个字节
      一次性读取一个字节数组
      a.txt

    输出流
      OutputStream--FileOutputStream
      以西写一个int类型数值
      一次写一个字节数组
      一次血一个字节数组的一部分
      b.txt
 */
public class CopyFileDemo1 {
    public static void main(String[] args) throws Exception{
        //1、创建字节输入流对象和字节输出流对象
        FileInputStream fis = new FileInputStream("a.txt");
        FileOutputStream fos = new FileOutputStream("f.txt");

        //2、读取数据
        //a:一次读取一个字节
//        int i = 0;
//        while ((i = fis.read())!=-1){
//            System.out.println();
//            fos.write(i);
//        }

        //b:一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int length = 0;
        while((length = fis.read(bytes))!=-1){
            fos.write(bytes,0,length);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

---------------------------------------------------------------------------------------------------------------------------------

二、CopyFileDemo2

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
    把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

    数据源：
      a.txt -- 读取数据--字符输入流--Reader--InputStreamReader

    目的地：
      b.txt--写出数据--字符输出流--Writer--OutputStreamWriter

 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws Exception{
        //1、创建字符输入流对象和字符输出流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));

        //读写数据
        //第一种方式
        int ch = 0;
        while((ch=isr.read())!=-1){
            osw.write(ch);
            osw.flush();
        }
        //第二种方式
        char[] chars = new char[1024];
        int length = 0;
        while((length = isr.read(chars))!=-1){
            osw.write(chars,0,length);
            osw.flush();
        }

        //释放资源
        osw.close();
        isr.close();
    }
}

--------------------------------------------------------------------------------------------------------------------------------

三、CopyFileDemo3

package com.shujia.lhw.day23;

import java.io.*;

/*
    由于我们常见的操作都是用基本默认的编码，我们基本上使用的时候不去指定编码
    但是呢，我觉得创建字符转换流对象的时候，名字有点长，所以Java提供了子类供我们使用
    字符流 = 字节流 + 编码表
    OutputStreamWriter = FileOutputStream + 编码表
    InputStreamReader = FileInputStream + 编码表

    把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt当中
    数据源：
      a.txt--读取数据--字符输入流--Reader--InputStreamReader--FileReader
    目的地：
      b.txt--写出数据--字符输出流--Writer--OutputStreamWriter--FileWriter
 */
public class CopyFileDemo3 {
    public static void main(String[] args) throws Exception{
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));

        //FileReader(String fileName)
        //创建一个新的FileReader，给定要读取的文件的名称
        FileReader fr = new FileReader("a.txt");
        //创建字符输出对象
        //FileWriter(String fileName)
        //构造一个给定文件名的FileWriter对象
        FileWriter fw = new FileWriter("b.txt");

        //一次读写一个字符
        int ch = 0;
        while((ch=fr.read())!=-1){
            fw.write(ch);
            fw.flush();
        }

        //一次读写一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while((length = fr.read(chars))!=-1){
            fw.write(chars,0,length);
            fw.flush();
        }

        //释放资源
        fw.close();
        fr.close();
    }
}

-------------------------------------------------------------------------------------------------------------------------

四、CopyFileDemo4

package com.shujia.lhw.day23;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/*
    把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

    数据源：
      a.txt--读取数据--字符输入流--Reader--InputStreamReader--FileReader--BufferedReader

    目的地：
      b2.txt--写入数据--字符输出流--Writer--OutputStreamWriter--FileWriter--BufferWriter

 */
public class CopyFileDemo4 {
    public static void main(String[] args) throws Exception{
        //1、创建字符缓冲输入流对象和字符缓冲输出流对象
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("b2.txt"));

        //一次读写一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while((length=br.read(chars))!=-1){
            bw.write(chars,0,length);
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();
    }
}

--------------------------------------------------------------------------------------------------------------------------

五、CopyJpgDemo1

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/*
    把当前项目下的冯提莫.jpg复制到当前项目下day23目录下

    数据源：从哪来
    冯提莫.jpg--读取数据--InputStream--FileInputStream

    目的地：到哪里去
    com\\shujia\\lhw\\day23\\ftm.jpg--写出数据--OutputStream--FileOutputStream
 */
public class CopyJpgDemo1 {
    public static void main(String[] args) throws Exception{
        //创建字节输入流对象和字节输出流对象
        FileInputStream fis = new FileInputStream("冯提莫.jpg");
        FileOutputStream fos = new FileOutputStream("src\\com\\shujia\\lhw\\day23\\ftm.jpg");

        byte[] bytes = new byte[1024];
        int length = 0;
        while((length = fis.read(bytes))!=-1){
            fos.write(bytes,0,length);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

---------------------------------------------------------------------------------------------------------------------------------

六、CopyMp4Demo1

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/*
    将D盘下的大数据.mp4复制到D盘数加科技目录下
    数据源：D:\\大数据.mp4
      读取数据--InputStream--FileInputStream

    目的地：D:\\数加科技\\大数据.mp4
      写出数据--OutputStream--FileOutputStream
 */
public class CopyMp4Demo1 {
    public static void main(String[] args) throws Exception{
        //1、创建字节输入流对象和字节输出流对象
        FileInputStream fis = new FileInputStream("D:\\大数据.mp4");
        FileOutputStream fos = new FileOutputStream("D:\\数加科技\\大数据.mp4");

        //2、读取数据
        byte[] bytes = new byte[1024];
        int length = 0;
        while((length=fis.read(bytes))!=-1){
            fos.write(bytes,0,length);
        }

        //3、释放资源
        fos.close();
        fis.close();
    }
}

----------------------------------------------------------------------------------------------------------------------------

七、FileInputStreamDemo1

package com.shujia.lhw.day23;

import java.io.File;
import java.io.FileInputStream;

/*
    字节输入流：InputStream（抽象类）
      FileInputStream

    FileInputStream的构造方法
      FileInputStream(File file)
      FileInputStream(String name)

    字节输入流读取数据的两种方式：
      FileInputStream的成员方法：
        public int read
        public int read(byte[] b)
 */
public class FileInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        //1、创建字节流输入对象
        //FileInputStream(File file)
        //读取数据的时候，如果文件不存在，报错
//        File file = new File("f.txt");//f.txt(系统找不到指定的文件)
//        File file = new File("e.txt");
//        FileInputStream fis = new FileInputStream(file);

        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("e.txt");

        //调用read方法读取数据，并输出在控制台上
        //public int read(),一次只能读取一个字节，返回的值是ASCII码值，强制类型转换
//        int read = fis.read();
//        System.out.println((char)read);

//        int read2 = fis.read();
//        System.out.println((char)read2);

        //如果文件中的数据很多的话，还是这样一个字节一个字节的读取，没有做任何改进，即将会很麻烦
        //使用循环改进读取
        //由于我们不知道什么时候将文件数据读取完毕，所以使用wile循环
        //控制跳出wile循环的条件是什么，数据的下一个字节，如果达到文件的末尾，-1
//        int read = fis.read();
//        while (read != -1) {
//            System.out.println((char) read);
//            read = fis.read();
//    }

        //字节输入流读取数据的第一种方式最终版写法：
        int i = 0;
        while ((i = fis.read()) != -1) {
            System.out.print((char) i);
        }

        //释放资源
        fis.close();
    }
}
---------------------------------------------------------------------------------------

八、FileInputStreamDemo2

package com.shujia.lhw.day23;

import java.io.FileInputStream;

/*
    字节输入流读取数据的第二种方式：一次读取一个字节数组
    public int read(byte[] b)
 */
public class FileInputStreamDemo2 {
    public static void main(String[] args) throws Exception {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("e.txt");

        //2、读取数据
        //public int read(byte[] b)
        //定义一个字节数组
//        byte[] bytes = new byte[8];
//        //一旦调用这个方法，将实际获取到的字节存储到数组中，返回的是，数组实际读取到的字节数
//        int i = fis.read(bytes);
//        System.out.println(i);
//        for (byte b : bytes) {
//            System.out.print((char) b);
//        }
//        System.out.println("======================================");
//        String s = new String(bytes);
//        System.out.println(s);
//        String s = new String(bytes,0,i);
//        System.out.println(s);

        //用循环改进
        //字节流读取数据的第二种方式最终代码
        //读入缓冲区的总字节数，如果没有更多的数据，文件的结尾已经达到，-1
        byte[] bytes = new byte[1024];
        int length = 0;
        while((length=fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,length));
        }

        //释放资源
        fis.close();
    }
}

-------------------------------------------------------------------------------------------------------------------------------

九、InputStreamReaderDemo1

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/*
    Reader
      InputStreamReader:字符输入流
      public InputStreamReader(InputStream in)
      读取数据，根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
      public InputStreamReader(InputStream in,String charsName)
      读取数据，根据指定的编码用字符作为桥梁将字节流的数据转换为字符流

 */
public class InputStreamReaderDemo1 {
    public static void main(String[] args) throws Exception{
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("bbb.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("ccc.txt"), "GBK");

        //一次读取一个字符
        int c = 0;
        while ((c=isr.read())!=-1){
            System.out.print((char)c);
        }

        //释放资源
        isr.close();

    }
}

------------------------------------------------------------------------------------------------------------------------------

十、InputStreamReaderDemo2

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/*
    InputStreamReader:字符输入流
      读取数据的方法：
        public int read()
        public int read(char[] cbuf)
 */
public class InputStreamReaderDemo2 {
    public static void main(String[] args) throws Exception{
        //1、创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("e.txt"));

        //一次只读一个字符
        //字符读取，如果已经达到流的结尾，则为-1
//        int i = 0;
//        while((i=isr.read())!=-1){
//            System.out.print((char) i);
//        }

        //一次读取一个字符数组
        //读取的字符数组，如果已经达到流的结尾，则为-1
        char[] chars = new char[1024];
        int length = 0;
        while((length = isr.read(chars))!=-1){
            System.out.println(new String(chars,0,length));
        }

        //释放资源
        isr.close();
    }
}

--------------------------------------------------------------------------------------------------------------------------------

十一、Output StreamWriter Demo1

package com.shujia.lhw.day23;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/*
    字符流：
      字符输入流
        Reader
      字符输出流
        Writer

    Writer
      OutputStreamWriter:字符输出流是以字节流加上编码表得到的一个转换流，后期写数据的时候可以
      根据自己指定的编码进行写入
      public OutputStreamWriter(OutputStream out)
      创建一个使用默认字符编码的OutputStreamWriter。根据默认的编码用字符作为桥梁将字节流的数据
      转换成字符流
      public OutputStreamWriter(OutputStream out,String charsName)
      根据指定的编码用字符作为桥梁将字节流的数据转换为字符流

      把字节流转化字符流

      字符流 = 字节流 + 编码表

 */
public class OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception {
        //1、创建字符输出流对象
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("aaa.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("bbb.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ccc.txt"), "GBK");

        osw.write("中国");

        //释放资源
        osw.close();
    }
}

------------------------------------------------------------------------------------------------------------------------------

十二、OutputStreamWriterDemo2

package com.shujia.lhw.day23;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/*
    OutputStreamWriter写数据的方法：
      public void write(int c)
      public void write(char[] cbuf)
      public void write(char[] cbuf,int odd,int len)
      public void write(String str)
      public void write(String str,int off,int len)

    flush()和close()的区别：
      1、调用完flush()后，流对象没有关闭，还能继续写数据
      2、调用完close()后，流对象关闭了，后续无法再通过这个对象写数据
 */
public class OutputStreamWriterDemo2 {
    public static void main(String[] args) throws Exception{
        //1、创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ddd.txt"));

        //写数据
        //public void write(int c)写一个字符
//        osw.write(99);
//        osw.write('a');

        //现象，我们在把close去掉之后，发现数据没有写入到数据中
        //原因
        //文件实际上在硬盘存储的是字节，需要手动转换一下进行存储
        //void flush()
        //刷新流
//        osw.flush();
//        osw.write();

        //public void write(char[] cbuf)写一个字符数组
        char[] chars = {'a','b','c','d','e'};
        osw.write(chars);

        //public void write(char[] cbuf,int off,int len)写字符数组的一部分
        osw.write(chars,1,3);

        //public void write(String str)
        osw.write("明旺和王宇真帅");

        //public void write(String str,int off,int len)写字符串的一部分
        osw.write("明旺和王宇真帅",3,2);

        //释放资源
        osw.close();//包含了flush()操作

//        osw.write();
    }
}

---------------------------------------------------------------------------------------------------------------------------------

十三、BufferedDemo1

package com.shujia.lhw.day23;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/*
    字符缓冲流的特殊读写方法：
    BufferedWriter:
      void newLine()
      写一行行分隔符。行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符('\n')字符

    BufferedReader：
      public String readLine()
      读一行文字。一行被视为由换行符('\n')，回车符('\r')中的任何一个或随后的换行符终止

 */
public class BufferedDemo1 {
    public static void main(String[] args) {
        try {
            write();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            read();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void read() throws Exception{
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //public String readLine() 一次读取一行文字
        //包含行的内容的字符串，不包括任何终止字符，如果已达到流的末尾，则为null
        String s = br.readLine();
        System.out.println(s);
        String s2 = br.readLine();
        System.out.println(s2);

        //用循环读取
        String line = null;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

        //释放资源
        br.close();
    }

    public static void write() throws Exception{
        //创建字符流缓冲输出对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("a3.txt"));
        for(int i=1;i<=10;i++){
            bw.write("大数据"+i);
            bw.write("\r\n");
            bw.newLine();//根据系统写入换行符
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}

-------------------------------------------------------------------------------------------------------------------------

十四、BufferedInputStreamDemo1

package com.shujia.lhw.day23;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
    字节缓冲输入流
      BufferedInputStream

 */
public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        //BufferedInputStream
        //BufferedInputStream(InputStream in)
        //创建一个BufferedInputStream并保存其参数，输入流in，供以后使用
//        FileInputStream fis = new FileInputStream("g.txt");
//        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("g.txt"));
//
        //读取数据
        //一次读取一个字节
//        int b = 0;
//        while((b=bis.read())!=-1){
//            System.out.print((char)b);
//        }
        System.out.println("=====================================");

        byte[] bytes = new byte[1024];
        int length = 0;
        while((length=bis.read(bytes))!=-1){
            System.out.print(new String(bytes,0,length));
        }

        //释放资源
        bis.close();

    }
}

----------------------------------------------------------------------------------------------------------------------------

十五、BufferedInputStreamDemo2

package com.shujia.lhw.day23;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
    字节流一次只读一个字节的时候，如果数据是中文，出现了我们看不懂的符号
 */
public class BufferedInputStreamDemo2 {
    public static void main(String[] args) throws Exception{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("g.txt"));

        //读取数据
        //一次读取一个字节
        int b = 0;
        while((b=bis.read())!=-1){
            System.out.println((char)b);
        }

        //释放资源
        bis.close();
    }
}

---------------------------------------------------------------------------------------------------------------------------------

十六、BufferedOutputStreamDemo1

package com.shujia.lhw.day23;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/*
    缓冲区类（高效类）

      字节缓冲输出流
        BufferedOutputStream
      字节缓冲输入流
        BufferedInputStream
 */
public class BufferedOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedOutputStream(OutputStream out)
        //创建一个新的缓冲输出流，以将数据写入指定的底层输出流
//        FileOutputStream fos = new FileOutputStream("g.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("g.txt"));

        //一次性写一个字节数组
        bos.write("大数据".getBytes());

        bos.close();
    }
}

-------------------------------------------------------------------------------------------------------------------------------

十七、BufferedReaderDemo1

package com.shujia.lhw.day23;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;

/*
    BufferedReader:字符缓冲输入流
    从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取
    可以指定缓冲区大小，或者可以使用默认大。默认值足够大，可用于大多数用途

    BufferedReader(Reader in)
    创建使用默认大小的输入缓冲区的缓冲字符输入流
 */
public class BufferedReaderDemo1{
    public static void main(String[] args) throws Exception{
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));

        //1、一次读取一个字符
//        int ch = 0;
//        while((ch=br.read())!=-1){
//            System.out.println((char)ch);
//        }

        //2、一次读取一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while((length=br.read(chars))!=-1){
            System.out.println(new String(chars,0,length));
        }

        //释放资源
        br.close();
    }
}

------------------------------------------------------------------------------------------------------------------------------

十八、BufferedWriterDemo1

package com.shujia.lhw.day23;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;

/*
    字符流为了高效读写，也提供了对应的字符缓冲流
    字符缓冲输出流：BufferedWriter
    字符缓冲输入流：BufferedReader

    BufferedWriter:
      将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入
      可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途。

    BufferedWriter(Writer out)
      创建使用默认大小的输出缓冲区的缓冲字符数输出流

 */
public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception{
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a2.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("a2.txt"));

        bw.write("hello");
        bw.write("\r\n");
        bw.write("world");
        bw.write("\r\n");
        bw.write("java");
        bw.write("\r\n");
        bw.write("hadoop");

        bw.flush();

        //释放资源
        bw.close();
    }
}

----------------------------------------------------------------------------------------------------------------------------

十九、DataOutputStreamDemo1

package com.shujia.lhw.day23;

import java.io.DataOutputStream;
import java.io.FileOutputStream;

/*

 */
public class DataOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //创建字节输出流操作基本数据类型数据
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("b3.txt"));

        //写基本类型的数据
        dos.writeInt(10);
        dos.writeShort(5);
        dos.writeByte(1);
        dos.writeLong(1000L);
        dos.writeFloat(12.34F);
        dos.writeDouble(23.45);
        dos.writeChar('a');
        dos.writeBoolean(true);

        //释放资源
        dos.close();
    }
}

--------------------------------------------------------------------------------------------------------------------------------

二十、DataInputStreamDemo1

package com.shujia.lhw.day23;

import java.io.*;
/*
   读的顺序与写的顺序一致

 */
public class DataInputStreamDemo1 {
    public static void main(String[] args) throws Exception{
//        write();
        read();
    }

    private static void read() throws FileNotFoundException,IOException{
        DataInputStream dis = new DataInputStream(new FileInputStream("b3.txt"));
//        byte b = dis.readByte();
//        System.out.println(b);
//        short s =dis.readShort();
//        System.out.println(s);
//        int i = dis.readInt();
//        System.out.println(i);

        int i = dis.readInt();
        System.out.println(i);
        short s = dis.readShort();
        System.out.println(s);
        byte b = dis.readByte();
        System.out.println(b);

        long l = dis.readLong();
        System.out.println(l);
        float f = dis.readFloat();
        System.out.println(f);
        double d = dis.readDouble();
        System.out.println(d);
        char ch = dis.readChar();
        System.out.println(ch);
        boolean bb = dis.readBoolean();
        System.out.println(bb);
        dis.close();
    }

    private static void write() throws IOException{
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
        dos.writeByte(1);
        dos.writeShort(20);
        dos.writeInt(300);
        dos.writeLong(4000);
        dos.writeFloat(12.34f);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);
        dos.close();
    }
}

----------------------------------------------------------------------------------------------------------------------------

二十一、StringDemo

package com.shujia.lhw.day23;



/*
    String(byte[] bytes,Charset charset)
    构造一个新的String由指定用指定的字节的数组解码charset。解码

    byte[] getBytes(Chars charset)
    使用给定的charset将该String编码为字节序列，将结果存储到新的字符数组中。便阿门

    编码：把看得懂的变成看不懂的，类似于加密
      String--byte[]

    解码：把看不懂的变成看得懂的，类似于解密
      byte[] -- String
 */
public class StringDemo {
    public static void main(String[] args) throws Exception{
        String s = "你好";

        //String -- byte[]
//        byte[] bytes1 = s.getBytes("GBK");
//        System.out.println(bytes1);
//        printArray(bytes1);

        byte[] bytes2 = s.getBytes("Unicode");
        printArray(bytes2);

        System.out.println();

        //byte[]--String
        String s1 = new String(bytes2,"Unicode");
        System.out.println(s1);
    }

    private static void printArray(byte[] bytes2) {
        for(byte b:bytes2){
            System.out.print(b+",");
        }
    }
}

------------------------------------------------------------------------------------------------------------------------------

二十二、IOTest1

package com.shujia.lhw.day23;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
    把ArrayList集合中的字符串数据存储到文本文件

 */
public class IOTest1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //向集合中添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");

        BufferedWriter bw = null;
        //创建字符缓冲输出流对象
        try {
            bw = new BufferedWriter(new FileWriter("a4.txt"));
            for (String s:list){
                bw.write(s);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

-------------------------------------------------------------------------------------------------------------------------------

二十三、IOTest2

package com.shujia.lhw.day23;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Arrays;

/*
    已知s.txt文件中由这样的一个字符串："hcexfgijkamdnoqrzstuvwybpl"
      请编写程序读取数据内容，把数据排序后写入ss.txt中。
 */
public class IOTest2 {
    public static void main(String[] args) throws Exception{
        //创建字节缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("s.txt"));
        String s = br.readLine();
        br.close();

        //将字符串转成字符数组
        char[] chars = s.toCharArray();

        //Arrays工具类中的sort方法排序
        Arrays.sort(chars);

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
        bw.write(chars);
        bw.flush();
        bw.close();
    }
}