java基础11（IO流）-字符流

最新推荐文章于 2024-05-03 16:12:22 发布

weixin_34315189

最新推荐文章于 2024-05-03 16:12:22 发布

阅读量73

点赞数

文章标签： java 大数据 scala

原文链接：http://www.cnblogs.com/wujiadong2014/p/6159940.html

版权

转换流

由于字节流操作中文不是特别方便，所以java中提供了转换流

编码表：由现实世界的字符和对应的数值组成的一张表

编码：把看得懂的变成看不懂的(String-------byte[])

解码：把看不懂的变成看得懂的(byte[]-------String)

String-----bytes[]

import java.util.Arrays;
import java.io.UnsupportedEncodingException;
public class StringDemo{
    public static void main(String[] args)throws UnsupportedEncodingException{
        String s = "你好";
        
        //String-----bytes[]
/*
        byte[] bys = s.getBytes();//将字符串转换成字节数组
        System.out.println(Arrays.toString(bys));//输出结果：[-28, -67, -96, -27, -91, -67]
*/

/*
        byte[] bys = s.getBytes("GBK");//指定编码方式
        System.out.println(Arrays.toString(bys));//输出结果：[-60, -29, -70, -61]        
*/

        byte[] bys = s.getBytes("utf-8");
        System.out.println(Arrays.toString(bys));//输出结果：[-28, -67, -96, -27, -91, -67]


    
    }
}

bytes[]-----String

import java.io.UnsupportedEncodingException;
public class StringDemo{
    public static void main(String[] args)throws UnsupportedEncodingException{
        String s = "你好";
        
    //  byte[] bys = s.getBytes();//默认是utf-8编码
        byte[] bys = s.getBytes("utf-8");

        //byte[] ---Sttring
//      String ss = new String(bys);//utf-8编码的，utf-8解码的
//      System.out.println(ss);//转换成字符串;输出结果是你好
    
        String ss = new String(bys,"GBK");//utf-8编的,GBK解码的
        System.out.println(ss);//输出结果是：浣犲ソ
            
    }
}

OutputStreamWriter


OutputStreamWriter(OutputStream out) :使用默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out, String charseName)：根据指定编码把字节流数据转换成字符流

OutputStreamWriter(或FileWriter)写数据

public void write(int c):写一个字符
public void write(char[] cbuf):写一个字符数组
public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
public void write(String str):写一个字符串
public void write(String str,int off,int len):写一个字符串的一部分

代码练习

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

public class OutputStreamWriteDemo{
    public static void main(String[] args)throws IOException{
        //创建对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/home/hadoop/a.txt"));

/*
        //写数据
        //public void write(int c):写一个字符
        osw.write("\na\n");
        osw.write(87);

*/

        //public void write(char[] cbuf):写一个字符数组
        char[] chs = {'a','b','c','d'};//不能使用双引号？
//      osw.write(chs);

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


        //public void write(String str):
//      osw.write("自学java");
        
        //public void write(String str,int off, int len):写一个字符串的一部分
        osw.write("邬家栋自学java",3,6);
    
        osw.flush();
        osw.close();
        
    }
}

InputStreamReader

InputStreamReader(InputStream in) :用默认的编码读取数据
InputStreamReader(InputStream in, String charsetName) :用指定的编码读取数据

InputStreamReader(或FileReader)读取数据

int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组

代码练习

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

public class InputStreamReadDemo{
    public static void main(String[] args)throws IOException{
        //创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("/home/hadoop/javatest/IO/OutputStreamWriteDemo.java"));

/*
        int ch = 0;
        while((ch = isr.read())!= -1){
            System.out.print((char)ch);
        }

*/

        //一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while((len = isr.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }
    

        isr.close();
        
    }
}

字符流读写数据（复制文本文件）

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

public class CopyFileDemo{
    public static void main(String[] args)throws IOException{
        //封装数据源
        InputStreamReader isr = new InputStreamReader(new FileInputStream("/home/hadoop/a.txt"));
        //封装目的地
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/home/hadoop/b.txt"));
        
/*
        //方式一
        int ch = 0;
        while((ch = isr.read()) != -1){
            osw.write(ch);
        }
*/

        //方式二
        char[] chs = new char[1024];
        int len = 0;
        while((len = isr.read(chs)) != -1){
            osw.write(chs,0,len);
            osw.flush();
    
        }

        isr.close();
        osw.close();
        
    }
}

字符缓冲流BufferedWriter写数据

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

public class BufferedWriterDemo{
    public static void main(String[] args)throws IOException{
        
        //BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        
        bw.write("hello\n");
        bw.write("wujiadong\n");

        bw.close();

    }
}

字符缓冲流BufferedReader读数据

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo{
    public static void main(String[] args)throws IOException{
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

/*
        //方式1
        int ch = 0;
        while((ch = br.read()) != -1){
            System.out.print((char) ch);
        }
*/

        //方式2
        char[] chs = new char[1024];
        int len = 0;
        while((len = br.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }

        br.close();
    }
}

字符缓存流复制文件

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

public class CopyFileDemo{
    public static void main(String[] args)throws IOException{
        //
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        //方式1
        //方式2
        char[] chs = new char[1024];
        int len = 0;
        while((len = br.read(chs)) != -1){
            bw.write(chs,0,len);
            
        }

        br.close();
        bw.close();
    }
}

特殊功能（一次读一行）

readLine(): 无换行符
newline(): 换行

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

public class BufferedDemo{
    public static void main(String[] args)throws IOException{
    //  write();
        read();
    }

    public static void read()throws IOException{
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
        
        String line = null;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }
        
        br.close();
        
    }
    
    public static void write() throws IOException{
        BufferedWriter bw = new BufferedWriter (new FileWriter("bw2.txt"));

        for(int i=0;i<10;i++){
            bw.write("wujiadong");
            bw.newLine(); //换行
            bw.flush();
        }

        bw.close();
    }

}

复制文件

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

public class CopyFileDemo1{
    public static void main(String[] args)throws IOException{
        //封装数据源
        BufferedReader br = new BufferedReader(new FileReader("CopyFileDemo.java"));

        //封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw3.txt"));

        String line = null;
        while((line = br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        br.close();
        bw.close();
    }
}

练习1：复制文本文件

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import java.io.BufferedReader;
import java.io.BufferedWriter;

public class CopyFileDemo{
    public static void main(String[] args)throws IOException{
        String srcString = "bw3.txt";
        String desString = "wu.txt";

//      method1(srcString,desString);
//      method2(srcString,desString);
//      method3(srcString,desString);
//      method4(srcString,desString);
        method5(srcString,desString);
        
    }

    //字符缓存流一次读写一个字符串
    private static void method5(String srcString,String desString)throws IOException{
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(desString));

        String line = null;
        while((line = br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        br.close();
        bw.close();
    }
    

    //字符缓存流一次读写一个字符数组
    private static void method4(String srcString,String desString)throws IOException{
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(desString));
    
        char[] ch = new char[1024];
        int len = 0;
        while((len = br.read(ch)) != -1){
            bw.write(ch);
        }

        br.close();
        bw.close();
    }

    //字符缓冲流一次读写一个字符
    private static void method3(String srcString,String desString)throws IOException{
        BufferedReader fr = new BufferedReader(new FileReader(srcString));
        BufferedWriter fw = new BufferedWriter(new FileWriter(desString));

        int ch = 0;
        while((ch = fr.read()) != -1){
            fw.write(ch);
        }       
        
        fr.close();
        fw.close();
            
    }

    //基本字符流一次读取一个字符数组
    private static void method2(String srcString,String desString)throws IOException{
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(desString);
        
        char[] ch = new char[1024];
        int len = 0;
        while((len = fr.read(ch)) != -1){
            fw.write(ch, 0 ,len);
        }
        
        fr.close();
        fw.close();
    }

    //基本字符流一次读写一个字符
    private static void method1(String srcString,String desString)throws IOException{
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(desString);

        int ch = 0;
        while((ch = fr.read()) != -1){
            fw.write(ch);
        }

        fr.close();
        fw.close();
    }
}

练习2：复制非文本文件的4种方法

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;

public class CopyImageDemo{
    public static void main(String[] args)throws IOException{
        //使用字符串作为路径
//      String srcFile = "1.jpg";
//      String desFile = "/home/hadoop/javatest/1.jpg";
        
        //使用File对象作为参数
        File srcFile = new File("/home/hadoop/1.jpg");
        File desFile = new File("/home/hadoop/javatest/1.jpg");

//      method1(srcFile,desFile);
//      method2(srcFile,desFile);
//      method3(srcFile,desFile);
        method4(srcFile,desFile);
    }

    //基本字节流一次读取一个字节
    public static void method1(File srcFile,File desFile)throws IOException{
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);

        int by = 0;
        while((by = fis.read()) != -1){
            fos.write(by);
        }

        fis.close();
        fos.close();
    }

    //基本字节流一次读写一个字节数组
    public static void method2(File srcFile,File desFile)throws IOException{
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);
        
        byte[] by = new byte[1024];
        int len = 0;
        while((len = fis.read(by)) != -1){
            fos.write(len);
            fos.flush();
        }

        fis.close();
        fos.close();

    }   

    public static void method3(File srcFile,File desFile)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));

        int by = 0;
        while((by = bis.read()) != -1){
            bos.write(by);
        }

        bis.close();
        bos.close();
    }

    //字节缓冲流一次读取一个字节数组
    public static void method4(File srcFile,File desFile)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));

        byte[] by = new byte[1024];
        int len = 0;
        while((len = bis.read()) != -1){
            bos.write(by);
            bos.flush();
        }
    
        bis.close();
        bos.close();

    }
    
}

练习3：将集合中的数据存储到文本文件

/*
 * 需求：将ArrayList集合中的字符串数据存储到文本文件
 *
 */
import java.util.ArrayList;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.FileWriter;

public class ArrayListToFileDemo{
    public static void main(String[] args)throws IOException{
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        array.add("java");
        array.add("python");
        array.add("scala");

        //封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("/home/hadoop/wu.txt"));  

        //遍历集合
        for(String s:array){
            bw.write(s);
            bw.newLine();
        }

        bw.close();
    }
}

练习4：把文本文件的数据存储到集合

/*
 * 需求：从文本文件中读取数据（一行为一个字符串数据）到集合中,并遍历集合
 *
 *
 */
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileToArrayListDemo{
    public static void main(String[] args)throws IOException{
        //封装数据源
        BufferedReader br = new BufferedReader(new FileReader("/home/hadoop/wu.txt"));

        //封装目的地
        ArrayList<String> array = new ArrayList<String>();

        //读取数据存储到集合中
        String line = null;
        while((line = br.readLine()) != null){
            array.add(line);
        }

        br.close();

        //遍历集合
        for(String s:array){
            System.out.println(s);
        }
    }
}

练习5：

/*
 * 需求：有一个文本文件存储了几个名称，写一个程序实现随机获取一个人的名字
 *
 */
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

public class GetName{
    public static void main(String[] args)throws IOException{
        //把文本文件的数据存储到集合中
        BufferedReader br = new BufferedReader(new FileReader("/home/hadoop/wu.txt"));
        ArrayList<String> array = new ArrayList<String>();
        
        String line = null;
        while((line = br.readLine()) != null){
            array.add(line);
        }

        br.close();
    
        //产生一个随机索引
        Random r = new Random();
        int index = r.nextInt(array.size());
        
        //根据该索引获取一个值
        String name = array.get(index);
        System.out.println("幸运者是："+name);

    }
}

练习6：复制单级文件夹


import java.io.File;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class CopyFolderDemo{
    public static void main(String[] args)throws IOException{
        //封装目录
        File srcFolder = new File("/home/hadoop/javatest/IO");
        File desFolder = new File("/home/hadoop/wu_test");

        //如果目的地文件夹不存在就创建
        if(!desFolder.exists()){
            desFolder.mkdir();
        }

        //获取该目录下的所有文本的File数组
        File[] fileArray = srcFolder.listFiles();

        //遍历该File数组，得到么一个File对象
        for(File file:fileArray){
            //System.out.println(file);
            //数据源：/home/hadoop/javatest
            //目的地：/home/hadoop/wu_test

            String name = file.getName();
            File newFile = new File(desFolder,name);

            copyFile(file,newFile);
        }
    }

    private static void copyFile(File file,File newFile)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));

        byte[] by = new byte[1024];
        int len = 0;
        while((len = bis.read(by)) != -1){
            bos.write(by,0,len);
        }

        bos.close();
        bis.close();
        
    }
}

转载于:https://www.cnblogs.com/wujiadong2014/p/6159940.html

weixin_34315189

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础11（IO流）-字符流

转换流由于字节流操作中文不是特别方便，所以java中提供了转换流编码表：由现实世界的字符和对应的数值组成的一张表编码：把看得懂的变成看不懂的(String-------byte[])解码：把看不懂的变成看得懂的(byte[]-------String)String-----bytes[]import java.util.Arrays;import java.io.Unsuppor...
复制链接

扫一扫