文件和IO流

最新推荐文章于 2022-12-19 18:05:32 发布

小方f

最新推荐文章于 2022-12-19 18:05:32 发布

阅读量162

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_43511745/article/details/107572227

版权

文件和IO流

1. File类的对象创建和常用方法？

计算机中的文件是由几部分组成？

文件的基本属性。【文件的名称，后缀名，修改日期，类型…】【java.io.File类】
文件中的数据。【输入输出流】

**2.**对文件的基本属性进行操作

在java中我们通过java.io.File类实现对文件的基本属性进行操作。

3. java.io.File类

定义：

public class File
extends Object
implements Serializable, ComparableFile

既然是一个类，那么在使用的时候就需要创建对象。

构造方法摘要
File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

package com.click369.test1;
import java.io.File;
public class TestMain {
	public static void main(String[] args) {
		//java.io.File类
		//构造方法
		//File(String pathname) 通过String类型的文件的路径和名称创建一个文件对象
		//pathname---需要创建的文件的路径和名称
		String  pathname="F:\\20191015\\test\\mytest.txt";
		String  path="F:/20191015/test/mytest.txt";
		File  file1=new File(pathname);
		File  file2=new File(path);
		//File(String parent, String child) 通过String类型的文件的路径和String类型名称创建一个文件对象
		//String parent---需要创建的文件的路径
		//String child----需要创建的文件的名称
		String parent="F:\\20191015\\test";
		String child="mytest.txt";
		File  file3=new File(parent,child);
		//File(File parent, String child) 通过File类型的文件的路径和String类型名称创建一个文件对象。	
		//File parent---需要创建的文件的路径
		//String child----需要创建的文件的名称
		String stringpath="F:\\20191015\\test";
		File filepath=new File(stringpath);
		String child1="mytest.txt";
		File  file4=new File(filepath,child1);
		//创建出文件对象，并不会得到实际文件。
	}
}

上面的实例中指定文件路径的时候

路径分割符【\】,window系统下的路径分隔符需要转义
windows系统的路径分隔符【\】与Unix系统的路径分隔符【/】不一样.

我们需要一个文件的路径分隔符，既可以兼容windows系统，也可以在Unix系统中使用。

字段摘要
static String	pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
static String	separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

例如：

package com.click369.test2;
import java.io.File;
public class TestMain {
     public static void main(String[] args) {
         //java.io.File类
         /*
         字段摘要 
         static String separator 
              与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
         */
         //在不同的计算机操作系统中，路径分割符号是不同的。
         //windows系统的路径分隔符【\】与Unix系统的路径分隔符【/】不一样.
         //如果我们的程序采用了windows系统的路径分隔符【\】,
         //那么我们的程序能否在Unix系统中正常运行吗？
         //不能正常运行，因为Unix系统不会识别windows系统的路径分隔符【\】
         //结果是你的程序只能在windows系统运行，不能在Unix系统运行。
         //我们要想让自己的程序既能在windows系统运行，也可以在Unix系统运行
         //这时就需要一个通配的路径分隔符。
         //System.out.println("pathSeparator=="+File.pathSeparator);
         //System.out.println("separator=="+File.separator);
         String path="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"mytest.txt";
         System.out.println(path);    
     }
}

实例方法

boolean	createNewFile() 创建新文件
boolean	exists() 判断文件或文件夹是否存在
boolean	delete() 删除文件或文件夹。删除文件夹的时候一定要保证文件夹为空，非空文件夹是无法删除的
boolean	canRead() 判断文件是否可读。
boolean	canWrite() 判断文件是否可写。
boolean	isHidden() 判断文件是否是一个隐藏文件。
boolean	isFile() 判断该对像是否为一个文件。【文件必须存在】
String	getAbsolutePath() 返回绝对路径名字符串。
String	getName() 返回文件或文件夹的名称。
String	getParent()得到文件的保存目录。
String	getPath() 将此抽象路径名转换为一个路径名字符串。
long	lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间【毫秒数】。
long	length() 返回文件的长度【字节】。1kb=1024字节 1mb=1024kb 1gb=1024mb
boolean	mkdirs() 创建一个文件夹
boolean	isDirectory() 判断该对像是否为一个文件夹。【文件夹必须存在】
String[]	list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录的名称。
File[]	listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

例如：

package com.click369.test1;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
public class FileTest2 {
     public static void main(String[] args)throws Exception {
         //判断文件是否存在如果存在就删除，不存在就新建
         //创建文件对象
         String path="F:"+File.separator+"20190801"+File.separator+"javaSE"+File.separator+"20190916JavaSE(23)";
         String filename="testfile.txt";
         File file=new File(path,filename);
         File file2=new File(path);
        /*
         //判断文件是否存在
         //boolean    exists() 判断文件或文件夹是否存在
         boolean flag=file.exists();
         if(flag){
             //文件存在就要删除文件
             //boolean    delete() 删除文件或文件夹
             file.delete();
         }else{
             //文件不存在就要新建文件
             //boolean    createNewFile() 创建新文件
             file.createNewFile();
         }
         */
         //boolean    canRead() 判断文件是否可读。
         System.out.println("canRead=="+file.canRead());
         //boolean    canWrite() 判断文件是否可写。
         System.out.println("canWrite=="+file.canWrite());
         //boolean    isHidden() 判断文件是否是一个隐藏文件。
         System.out.println("isHidden=="+file.isHidden());
         //判断该对像是否为一个文件。
         System.out.println("isFile=="+file.isFile());
         System.out.println("isFile=="+file2.isFile());
         //String  getAbsolutePath() 返回绝对路径名字符串。
         System.out.println("绝对路径=="+file.getAbsolutePath());
         //String  getName() 返回文件或文件夹的名称。
         System.out.println("文件名称=="+file.getName());
         //String  getParent()得到文件的保存目录。
         System.out.println("文件的保存目录=="+file.getParent());
         // String  getPath() 将此抽象路径名转换为一个路径名字符串。
         System.out.println("getPath=="+file.getPath());
         // long   lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间【毫秒数】。
         long time=file.lastModified();
         Date date=new Date(time);
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd E HH:mm");
         String newtime=sdf.format(date);
         System.out.println("最后一次被修改的时间=="+newtime);
         //long    length() 返回文件的长度。
         System.out.println("length=="+file.length());
         
         //创建文件对象
         String path1="F:"+File.separator+"20190801"+File.separator+"javaSE"+File.separator+"20190916JavaSE(23)";
         File file3=new File(path1,"code");
         //boolean    exists() 判断文件或文件夹是否存在
         boolean  exists=file3.exists();
         if(exists){
              //存在就删除
              //boolean   delete() 删除文件或文件夹
             file3.delete();
         }else{
             //不存在就创建
             //boolean    mkdirs() 创建一个文件夹
             file3.mkdirs();
         }
         //boolean    isDirectory() 判断该对像是否为一个文件夹。【文件夹必须存在】
         boolean isd=file3.isDirectory();
         System.out.println("isd=="+isd);
     }
}

例如：得到指定目录下的文件以及文件夹

package com.click369.test1;
import java.io.File;
mport java.text.SimpleDateFormat;
import java.util.Date;
public class FileTest3 {
     public static void main(String[] args)throws Exception {
         //得到指定目录下的文件以及文件夹
         //String[] list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录的名称。
         //得到F:\20190801\javaSE\20190916JavaSE(23)目录下的文件及文件夹
         /*
         File file= new File("F:"+File.separator+"20190801"+File.separator+"javaSE"+File.separator+"20190916JavaSE(23)");
         String names[]=file.list();
         for(String name:names){
             System.out.println(name);
         }
        */        
         File file= new File("F:"+File.separator+"20190801"+File.separator+"javaSE"+File.separator+"20190916JavaSE(23)");
         //File[]   listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
         File files[]=file.listFiles();
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd E HH:mm");
         for(File f:files){
             String filename=f.getName();
             long time=f.lastModified();
             String lasttime=sdf.format(new Date(time));
             String filetype="";
             String len="";
             if(f.isDirectory()){
                  filetype="文件夹";
             }
             if(f.isFile()){
                  filetype=getFiletype(f);
                  len=f.length()+"字节";
             }
             StringBuilder builder=new StringBuilder();
             builder.append(filename);
             builder.append("\t\t\t");
             builder.append(lasttime);
             builder.append("\t\t\t");
             builder.append(filetype);
             builder.append("\t\t\t");
             builder.append(len);
            System.out.println(builder.toString());
        }
        
     }
 /**
  \* 得到文件类型
  \* @param f
 \* @return
  */
     private static String getFiletype(File f) {
         String type="";
         String houzhui=f.getName().substring(f.getName().lastIndexOf("."));
         if(".doc".equals(houzhui)|| ".docx".equals(houzhui)){
             type="DOCX文档";
         }
         if(".CHM".equals(houzhui)|| ".chm".equals(houzhui)){
             type="编译的html文件";
         }
         if(".txt".equals(houzhui)|| ".TXT".equals(houzhui)){
              type="文本文档";
         }
         if(".java".equals(houzhui)|| ".JAVA".equals(houzhui)){
             type="JAVA源文件";
         }
         return type;
     }
}

2. Io的划分与区别【字节流与字符流】？

1. 如何处理文件中的内容？

通过java提供输入输出流；来处理文件中的内容数据。

2. 什么是流？

电流：负电荷的正向移动轨迹
水流：水的移动轨迹。
Java中的流：数据的移动轨迹。

3. 什么是输入输出流？

按照数据的流向：

输入流：数据从本程序之外的地方[文件]引入到本程序中时所形成的移动轨迹就是输入流。

【读取数据】

输出流：数据从本程序中流向本程序之外的地方[文件]所形成的移动轨迹就是输出流。

【写出数据】

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oXeBntkZ-1595608469463)(C:\Users\18373\Desktop\Java基础\java基础第九节文件和IO流\img\io流.png)]$

1. 流的另一个分类

按照每一次读写数据的量：

1. 字节流：每一次可以读/写，一个字节，8位2进制数据的量，由于所有的数据都可以转换成字节，因此字节流可以处理任何类型的数据【文本,图片，视频，音频…】

字符流：每一次可以读/写，一个字符，16位2进制数据的量，只能处理文本型数据【word文档，记事本文件】，不能处理图片，视频，音频这些类型的文件。

2. 字节流：

按照数据的流向：

字节输出流【写出数据】

在java中表示字节输出流使用OutputStream类

OutputStream类是一个抽象类，不能通过new的方式创建对象，需要借助子类来创建对象。
OutputStream抽象类是字节输出流的顶级父类。
FileOutputStream类是OutputStream抽象类的子类。
FileOutputStream类能通过new的方式创建对象。
java.io. FileOutputStream

public class FileOutputStream extends OutputStream

构造方法摘要
FileOutputStream(File file)通过File对象创建一个字节输出流。参数：File file–指定数据输出位置
FileOutputStream(File file, boolean append) 通过File对象创建一个可以追加内容的字节输出流。参数1：File file–指定数据输出位置参数2：boolean append–指定是否追加
FileOutputStream(String name) 通过String对象创建一个字节输出流。参数：String name–指定数据输出位置
FileOutputStream(String name, boolean append) 通过String对象创建一个可以追加内容的字节输出流。参数1：String name–指定数据输出位置参数2：boolean append–指定是否追加

例如：

package com.click369.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //FileOutputStream的构造方法
         //FileOutputStream(File file)通过File对象创建一个字节输出流。
         //参数：File file--指定数据输出位置  
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileOutputStream out1=new FileOutputStream(file1);
         OutputStream out2=new FileOutputStream(file1);
         //FileOutputStream(File file, boolean append) 通过File对象创建一个可以追加内容的字节输出流。
         //参数1：File file--指定数据输出位置
         //参数2：boolean append--指定是否追加
         File file2=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileOutputStream out3=new FileOutputStream(file2,true);
         OutputStream out4=new FileOutputStream(file2,true);
         //FileOutputStream(String name) 通过String对象创建一个字节输出流。
         //参数：String name--指定数据输出位置  
         String path1="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt";
         FileOutputStream out5=new FileOutputStream(path1);
         OutputStream out6=new FileOutputStream(path1);
         //FileOutputStream(String name, boolean append) 通过String对象创建一个可以追加内容的字节输出流。
         //参数1：String name--指定数据输出位置
         //参数2：boolean append--指定是否追加 
         String path2="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt";
         FileOutputStream out7=new FileOutputStream(path2,true);
         OutputStream out8=new FileOutputStream(path2,true);
         //只要创建出输出流对象，那么输出流就会自动去创建这个不存在的文件
     }
}

通过输出流对象写出数据：

void	write(byte[] b)将字节数组中的所有数据全部写出到字节输出流中。
void	write(byte[] b, int off, int len) 将字节数组中的从off开始len个数据写出到字节输出流中。。
void	write(int b) 将一个字节的数据写出到字节输出流中。
void	close() 关闭字节输出流

例如：

package com.click369.test2;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         // void   write(byte[] b)将字节数组中的所有数据全部写出到字节输出流中。
         //定义一个需要被写出的数据
         String info="world";
         //创建字节输出流对象
         //FileOutputStream(File file, boolean append) 通过File对象创建一个可以追加内容的字节输出流。
         //参数1：File file--指定数据输出位置
         //参数2：boolean append--指定是否追加
         File file2=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileOutputStream out3=new FileOutputStream(file2,true);
         //OutputStream out4=new FileOutputStream(file2,true);
         //将String转换成byte[]
         byte bytearray[]=info.getBytes();
         //调用写方法，写出数据
         out3.write(bytearray);
         //关闭字节输出流
        out3.close();
     }
}


package com.click369.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //void    write(byte[] b, int off, int len)将字节数组中的从off开始len个数据写出到字节输出流中。。
         //定义一个需要被写出的数据
         String info="worldhello";
         //创建字节输出流对象
         //FileOutputStream(File file, boolean append) 通过File对象创建一个可以追加内容的字节输出流。
         //参数1：File file--指定数据输出位置
         //参数2：boolean append--指定是否追加
         File file2=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileOutputStream out3=new FileOutputStream(file2,true);
         //OutputStream out4=new FileOutputStream(file2,true);
         //将String转换成byte[]
         byte bytearray[]=info.getBytes();
         //调用写方法，写出数据
         out3.write(bytearray,5,5);
         //关闭字节输出流
         out3.close();
     }
}

package com.click369.test4;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         // void   write(int b) 将一个字节的数据写出到字节输出流中。
         //定义一个需要被写出的数据
         String info="-world";
         //创建字节输出流对象
         //FileOutputStream(File file, boolean append) 通过File对象创建一个可以追加内容的字节输出流。
         //参数1：File file--指定数据输出位置
         //参数2：boolean append--指定是否追加
         File file2=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileOutputStream out3=new FileOutputStream(file2,true);
         //OutputStream out4=new FileOutputStream(file2,true);
         //将String转换成byte[]
         byte bytearray[]=info.getBytes();
         for(byte by:bytearray){
         //调用写方法，写出数据
         out3.write(by);
         }
         //关闭字节输出流
         out3.close();
     }
}

字节输入流【读取数据】

在java我们使用InputStream类表示一个字节输入流。

InputStream类是一个抽象类，不能通过new的方式创建对象，需要借助子类来创建对象。
InputStream抽象类是字节输入流的顶级父类。
FileInputStream类是InputStream抽象类的子类。
FileInputStream类能通过new的方式创建对象。
java.io FileInputStream

public class FileInputStream extends InputStream

构造方法摘要
FileInputStream(File file) 通过File对象创建一个字节输入流对象。 File file—指定输入位置
FileInputStream(String name) 通过String对象创建一个字节输入流对象。 String name—指定输入位置

例如：

package com.click369.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //FileInputStream 构造方法
         //FileInputStream(File file) 通过File对象创建一个字节输入流对象。
         //File file---指定输入位置   
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         FileInputStream in1=new FileInputStream(file1);
         InputStream in2=new FileInputStream(file1);
         //FileInputStream(String name) 通过String对象创建一个字节输入流对象。
         //String name---指定输入位置   
         String path1="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt";
         FileInputStream in3=new FileInputStream(path1);
         InputStream in4=new FileInputStream(file1);
     }
}

通过字节输入流读取数据：

int	read()从此输入流中读取一个数据字节。返回值下一个数据字节，如果已到达文件末尾，则返回 -1。
int	read(byte[] b) 将数据读取到字节数组中。返回值是读取的字节总数，如果到达文件末尾返回-1。
int	read(byte[] b, int off, int len)将数据读取到的数据保存在字节组的off位置和len个数据返回值是读取的字节总数，如果到达文件末尾返回-1。
void	close() 关闭字节输入流

例如：

package com.click369.test2;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestMain {
    public static void main(String[] args) throws Exception{
         //int read(byte[] b) 将数据读取到字节数组中。
         //返回值是读取的字节总数，如果到达文件末尾返回-1。
         //创建输入流对象
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         //FileInputStream in1=new FileInputStream(file1);
         InputStream in2=new FileInputStream(file1);
         //创建保存数据的字节数组
         byte bytearray[]=new byte[(int)file1.length()];
         //开始读取数据
         int len=in2.read(bytearray);
         //关闭流
         in2.close();
         //将保存有数据的字节数组转换成String
         //String info=new String(bytearray);
         String info=new String(bytearray,0,len);
         System.out.println(info);
    }
}

package com.click369.test3;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestMain {
    public static void main(String[] args) throws Exception{
         // int    read(byte[] b, int off, int len)将数据读取到的数据保存在字节组的off位置和len个数据
         //返回值是读取的字节总数，如果到达文件末尾返回-1。
         //创建输入流对象
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         //FileInputStream in1=new FileInputStream(file1);
         InputStream in2=new FileInputStream(file1);
         //创建保存数据的字节数组
         byte bytearray[]=new byte[(int)file1.length()];
         //开始读取数据
         int len=in2.read(bytearray,5,10);
         //关闭流
        in2.close();
        //将保存有数据的字节数组转换成String
         String info=new String(bytearray);
         System.out.println(info);
     }
}

package com.click369.test4;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //int read()从此输入流中读取一个数据字节。
         //返回值下一个数据字节，如果已到达文件末尾，则返回 -1。 
         //创建输入流对象
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"file1.txt");
         //FileInputStream in1=new FileInputStream(file1);
         InputStream in2=new FileInputStream(file1);
         //创建保存数据的字节数组
         byte bytearray[]=new byte[(int)file1.length()];
         int temp=0; //保存被读取的字节数据
         int index=0; //数组下标
         while((temp=in2.read())!= -1){
             bytearray[index]=(byte)temp;
             index++;
        }
         //关闭流
         in2.close();
         //将保存有数据的字节数组转换成String
         String info=new String(bytearray);
        System.out.println(info);
     }

将D盘中的一个图片复制到E盘。
ackage com.click369.test1;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class CopyDemo {
     public static void main(String[] args) throws Exception{
         File filrsrc=new File("D:"+File.separator+"test11.jpg");
         File filrdesc=new File("E:"+File.separator+"test11.jpg");
         //创建字节输入流
         FileInputStream in=new FileInputStream(filrsrc);
         //创建字节输出流
         FileOutputStream out=new FileOutputStream(filrdesc);
         //创建保存图片信息的字节数组
         byte bytearray[]=new byte[(int)filrsrc.length()];
         //开始读取
         int len=in.read(bytearray);
         //写出数据
         out.write(bytearray);
         //关闭流
         in.close();
         out.close();
     }
}

字符输出流

在java中通过Writer类表示字符输出流。

Writer类是一个抽象类，不能通过new的方式构造对象，需要借助子类完成对象创建。

Writer这个抽象类是字符输出流的顶级父类

FileWriter类是Writer抽象类的子类。

java.io FileWriter

public class FileWriter extends OutputStreamWriter

OutputStreamWriter 继承了 Writer

FileWriter 简介继承 Writer

构造方法摘要
FileWriter(File file) 通过File对象创建一个字符输出流对象。 File file—指定输出位置
FileWriter(File file, boolean append)通过File对象创建一个可以追加的字符输出流对象。 File file—指定输出位置 boolean append—指定是否追加
FileWriter(String fileName) 通过String对象创建一个字符输出流对象。 String fileName—指定输出位置。
FileWriter(String fileName, boolean append)通过String对象创建一个可以追加的字符输出流对象。 String fileName—指定输出位置 boolean append—指定是否追加

package com.click369.test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //FileWriter构造方法
         //FileWriter(File file) 通过File对象创建一个字符输出流对象。
         //File file---指定输出位置   
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1);
         Writer writer2=new FileWriter(file1);
         //FileWriter(File file, boolean append)通过File对象创建一个可以追加的字符输出流对象。
         //File file---指定输出位置
         //boolean append---指定是否追加    
         File file2=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer3=new FileWriter(file2,true);
         Writer writer4=new FileWriter(file2,true);
         //FileWriter(String fileName) 通过String对象创建一个字符输出流对象。
         //String fileName---指定输出位置。  
         String path1="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt";
         FileWriter writer5=new FileWriter(path1);
         Writer writer6=new FileWriter(path1);
         //FileWriter(String fileName, boolean append)通过String对象创建一个可以追加的字符输出流对象。
         //String fileName---指定输出位置
         //boolean append---指定是否追加    
         String path2="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt";
         FileWriter writer7=new FileWriter(path2,true);
         Writer writer8=new FileWriter(path2,true);
     }
}

通过字符输出流写出数据需要【写方法】

来自Writer

`void`	write(java.lang.String)) (String str)` 写入字符串。
`void`	write(char[]))(char[] cbuf)` 写入字符数组。

来自OutputStreamWriter

void	write(char[] cbuf, int off, int len) 将字符数组中的从off开始的len个数据写出到字符输出流。
void	write(int c) 一次写出一个字符数据字符输出流。
void	write(String str, int off, int len) 将字符串中的从off开始的len个数据写出到字符输出流。
void	close()关闭此流

例如：

package com.click369.test2;
import java.io.File;
mport java.io.FileWriter;
import java.io.Writer;
public class TestMain {
    public static void main(String[] args) throws Exception{
         //void    write(char[] cbuf) 写入字符数组。
         String info="world";
         //创建一个字符输出流对象。
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1,true);
         //Writer writer2=new FileWriter(file1);
         //将字符串转换成字符数组
         char chararray[]=info.toCharArray();
         writer1.write(chararray);
         //关闭流
         writer1.close();
     }
}
package com.click369.test3;
import java.io.File;
mport java.io.FileWriter;
import java.io.Writer;
public class TestMain {
     public static void main(String[] args) throws Exception{
         // void   write(char[] cbuf, int off, int len) 将字符数组中的从off开始的len个数据写出到字符输出流。
         String info="worldhello";
         //创建一个字符输出流对象。
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1,true);
         //Writer writer2=new FileWriter(file1);
         //将字符串转换成字符数组
         char chararray[]=info.toCharArray();
         writer1.write(chararray,5,5);
         //关闭流
         writer1.close();
     }
}
package com.click369.test4;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestMain {
     public static void main(String[] args) throws Exception{
         // void   write(int c) 一次写出一个字符数据字符输出流
         String info="-world";
         //创建一个字符输出流对象。
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1,true);
         //Writer writer2=new FileWriter(file1);
         //将字符串转换成字符数组
         char chararray[]=info.toCharArray();
         for(char ch:chararray){
         writer1.write(ch);
         }
         //关闭流
         writer1.close();
     }

package com.click369.test5;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestMain {
     public static void main(String[] args) throws Exception{
         /*
         //void    write(String str)写入字符串。
         String info="hello";
         //创建一个字符输出流对象。
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1,true);
         //Writer writer2=new FileWriter(file1);
         writer1.write(info);
         //关闭流
         writer1.close();
         */
       
         //void    write(String str, int off, int len) 将字符串中的从off开始的len个数据写出到字符输出流。
         String info="worldhello";
         //创建一个字符输出流对象。
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileWriter writer1=new FileWriter(file1,true);
         //Writer writer2=new FileWriter(file1);
         writer1.write(info,0,5);
         //关闭流
         writer1.close();
     }
}

字符输入流

在java中通过Reader类表示字符输入流。
Reader这个类是一个抽象类，不能new,需要子类。
Reader这个类是一个抽象类字符输入流的顶级父类。
FileReader类就是Reader类的子类。
java.io FileReader
public class FileReader extends InputStreamReader
InputStreamReader继承Reader类
FileReader间接继承Reader类

构造方法摘要
FileReader(File file) 通过File对象创建一个字符输入流对象
FileReader(String fileName) 通过String对象创建一个字符输入流对象

例如：

package com.click369.test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //FileReader 构造方法
         //FileReader(File file) 通过File对象创建一个字符输入流对象
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         FileReader reader1=new FileReader(file1);
         Reader reader2=new FileReader(file1);
         //FileReader(String fileName) 通过String对象创建一个字符输入流对象
         String path1="F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt";
         FileReader reader3=new FileReader(path1);
         Reader reader4=new FileReader(path1);
     }
}

读取数据

int	read()读取单个字符。返回值作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1
int	read(char[] cbuf, int offset, int length) 将字符读入数组中的某一部分。返回值读取的字符数，如果已到达流的末尾，则返回 -1
int	read(char[] cbuf) 将字符读入数组。返回值读取的字符数，如果已到达流的末尾，则返回 -1
void	close() 关闭该流并释放与之关联的所有资源。

例如：

package com.click369.test2;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         // int    read(char[] cbuf) 将字符读入数组。
         //返回值读取的字符数，如果已到达流的末尾，则返回 -1 
         //创建字符输入流
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         //FileReader reader1=new FileReader(file1);
         Reader reader2=new FileReader(file1);
         char chararray[]=new char[(int)file1.length()];
         int len=reader2.read(chararray);
         reader2.close();
         String info=new String(chararray,0,len);
         System.out.println(info);
     }
}

package com.click369.test3;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //int read(char[] cbuf, int offset, int length) 将字符读入数组中的某一部分。
         //返回值读取的字符数，如果已到达流的末尾，则返回 -1 
         //创建字符输入流
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
         //FileReader reader1=new FileReader(file1);
         Reader reader2=new FileReader(file1);
         char chararray[]=new char[(int)file1.length()];
         int len=reader2.read(chararray,5,5);
         reader2.close();
         String info=new String(chararray);
         System.out.println(info);
     }
}
package com.click369.test4;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //int read()读取单个字符。
         //返回值作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 
         //创建字符输入流
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"test"+File.separator+"myfile.txt");
        //FileReader reader1=new FileReader(file1);
         Reader reader2=new FileReader(file1);
         char chararray[]=new char[(int)file1.length()];
         int temp=0;
         int index=0;
         while((temp=reader2.read())!=-1){
             chararray[index]=(char)temp;
             index++;
         }
         reader2.close();
         String info=new String(chararray);
         System.out.println(info);
     }
}

3.字节输入与字节输出流的类

字节流

DataOutputStream
java.io 
 类 DataOutputStream
public class DataOutputStream extends  FilterOutputStream implements DataOutput
FilterOutputStream继承OutputStream,FilterOutputStream是一个OutputStream的子类。
DataOutputStream是FilterOutputStream的子类。
DataOutputStream是OutputStream的子类。

构造方法摘要
DataOutputStream(OutputStream out) 通过一个指定的字节输出流创建出一个DataOutputStream对象。

例如：

package com.click369.test1;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //DataOutputStream的构造方法
         //DataOutputStream(OutputStream out) 创建一个新的数据输出流，将数据写入指定基础输出流。
         //参数OutputStream【抽象类】 out
         //1.子类对象  2.上转型对象 3.匿名内部类
         //都需要OutputStream【抽象类】的子类【FileOutputStream】
         /*
         File file=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt");
         FileOutputStream out=new FileOutputStream(file,true);
         DataOutputStream dataout=new DataOutputStream(out);
         */         
         /*
         String path="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt";
         OutputStream out=new FileOutputStream(path,true);
         DataOutputStream dataout=new DataOutputStream(out);
         */        
         DataOutputStream dataout=new DataOutputStream(new FileOutputStream(new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt"),true));
     }
}

实例方法：

void	write(byte[] b) 将 b.length 个字节写入此输出流。
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void	write(int b)将指定 byte 写入此输出流。
void	writeByte(int v) 将一个 byte 值以 1-byte 值形式写出到基础输出流中。
void	writeShort(int v) 将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
void	writeInt(int v) 将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
void	writeLong(long v) 将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
void	writeFloat(float v) 使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
void	writeDouble(double v) 使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
void	writeChar(int v) 将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
void	writeBoolean(boolean v) 将一个 boolean 值以 1-byte 值形式写入基础输出流。
void	writeBytes(String s) 将字符串按字节顺序写出到基础输出流中。
void	writeChars(String s) 将字符串按字符顺序写入基础输出流。
void	writeUTF(String str) 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。

例如：

package com.click369.test2;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //DataOutputStream的实例方法
         File file=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt");
         FileOutputStream out=new FileOutputStream(file,true);
         DataOutputStream dataout=new DataOutputStream(out);
         //写出一个int值
         dataout.writeInt(1001);
         //写出一个char
         dataout.writeChar('\t');
         //写出一个double值
         dataout.writeDouble(12.5);
         //写出一个char
         dataout.writeChar('\t');
         //写出一个boolean
         dataout.writeBoolean(true);
         //写出一个char
         dataout.writeChar('\t');
         //写出UTF-8
         dataout.writeUTF("你好");
         //dataout.writeBytes("你好");
         //dataout.writeChars("你好");
         //关闭流
         dataout.close();
         out.close();
         //1001   12.5 true 你好
         // ?    @)            浣犲ソ
     }
}

DataInputStream

java.io
类 DataInputStream

public class DataInputStream extends FilterInputStream implements DataInput
FilterInputStream继承InputStream,FilterInputStream是一个InputStream的子类。
DataInputStream是FilterInputStream的子类。
DataInputStream是InputStream的子类。

构造方法摘要
DataInputStream(InputStream in) 通过一个指定的字节输入流创建出一个DataInputStream对象。

例如：

package com.click369.test1;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //DataInputStream 构造方法
         //DataInputStream(InputStream in) 通过一个指定的字节输入流创建出一个DataInputStream对象
         //参数InputStream【抽象类】
         //1.子类对象，2.上转型对象，3.匿名内部类
         //都需要InputStream的子类--FileInputStream
         /*
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt");
         FileInputStream in=new FileInputStream(file1);
         DataInputStream datain=new DataInputStream(in);
        */
         
         /*
         String path1="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt";
         InputStream in=new FileInputStream(path1);
         DataInputStream datain=new DataInputStream(in);
         */         
         DataInputStream datain=new DataInputStream(new FileInputStream(new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt")));
     }
}

实例方法:

int	read() 从此输入流中读取下一个数据字节。
int	read(byte[] b) 从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中。
int	read(byte[] b, int off, int len) 从此输入流中将 len 个字节的数据读入一个 byte 数组中。
byte	readByte() 读取并返回一个输入字节。
short	readShort() 读取两个输入字节并返回一个 short 值。
int	readInt() 读取四个输入字节并返回一个 int 值。
long	readLong() 读取八个输入字节并返回一个 long 值。
float	readFloat() 读取四个输入字节并返回一个 float 值。
double	readDouble() 读取八个输入字节并返回一个 double 值。
char	readChar() 读取两个输入字节并返回一个 char 值。
boolean	readBoolean() 读取一个输入字节，如果该字节不是零，则返回 true，如果是零，则返回 false。
String	readUTF() 读入一个已使用 UTF-8 修改版格式编码的字符串。

例如：

package com.click369.test2;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
public class TestMain {
    public static void main(String[] args) throws Exception{
         //DataInputStream的实例方法
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test1.txt");
         FileInputStream in=new FileInputStream(file1);
         DataInputStream datain=new DataInputStream(in);
         //读取一个int
         int i=datain.readInt();
         //读取一个字符
         char c=datain.readChar();
         //读取一个double
         double d=datain.readDouble();
         //读取一个字符
         char h=datain.readChar();
         //读取一个boolean
         boolean b=datain.readBoolean();
         //读取一个字符
         char a=datain.readChar();
         //读取一个UTF
         String s=datain.readUTF();
         //关闭流
         datain.close();
         in.close();
         System.out.println(i+":"+c+":"+d+":"+h+":"+b+":"+a+":"+s);
     }
}

字符输出流【BufferedWriter**】**

java.io
类 BufferedWriter

public class BufferedWriter extends Writer

构造方法摘要
BufferedWriter(Writer out) 通过一个字符输出流创建缓冲字符输出流。
BufferedWriter(Writer out, int sz) 通过一个字符输出流创建一个指定缓冲区的大小的缓冲字符输出流。

例如：

package com.click369.test1;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //BufferedWriter构造方法
         //BufferedWriter(Writer out) 通过一个字符输出流创建缓冲字符输出流。
         //参数Writer[抽象类]--FileWriter
         /*
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileWriter wri=new FileWriter(file1,true);
         BufferedWriter buf=new BufferedWriter(wri);
         */
         /*
         String path1="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt";
         Writer wri=new FileWriter(path1,true);
         BufferedWriter buf=new BufferedWriter(wri);
         */
         //BufferedWriter buf=new BufferedWriter(new FileWriter(new File(new String("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt")),true));
        
         //BufferedWriter(Writer out, int sz) 通过一个字符输出流创建一个指定缓冲区的大小的缓冲字符输出流。
         /*
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileWriter wri=new FileWriter(file1,true);
         BufferedWriter buf=new BufferedWriter(wri,300);
         */
         /*
         String path1="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt";
         Writer wri=new FileWriter(path1,true);
         BufferedWriter buf=new BufferedWriter(wri,200);
         */
         BufferedWriter buf=new BufferedWriter(new FileWriter(new File(new String("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt")),true),100);
     }
}

void	write(String str) 写入字符串。
void	write(char[] cbuf) 写入字符数组。
void	write(char[] cbuf, int off, int len) 将字符数组中的从off开始的len个数据写出到字符输出流。
void	write(int c) 一次写出一个字符数据字符输出流。
void	write(String str, int off, int len) 将字符串中的从off开始的len个数据写出到字符输出流。
void	close()关闭此流
void	newLine() 写入一个行分隔符。[\r\n]

例如：

package com.click369.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //BufferedWriter实例方法
         /*
         void write(String str) 写入字符串。
         void write(char[] cbuf) 写入字符数组。
         void write(char[] cbuf, int off, int len) 将字符数组中的从off开始的len个数据写出到字符输出流。
         void write(int c) 一次写出一个字符数据字符输出流。
         void write(String str, int off, int len) 将字符串中的从off开始的len个数据写出到字符输出流。
         */
         //上面的这5个实例方法的用法与FileWriter中的一样
         //void    newLine() 写入一个行分隔符。[\r\n]
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileWriter wri=new FileWriter(file1,true);
         BufferedWriter buf=new BufferedWriter(wri);
         buf.write("hello");
         //写入一个行分隔符
         buf.newLine();
         buf.write("world");
         buf.close();
         wri.close();
     }
}

字符输入流【BufferedReader】

java.io.BufferedReader

public class BufferedReader extends Reader

构造方法摘要
BufferedReader(Reader in) 通过字符输入流创建一个缓冲字符输入流。
BufferedReader(Reader in, int sz) 通过字符输入流创建一个指定缓冲区大小的缓冲字符输入流

例如：

package com.click369.test1;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestMain {
   public static void main(String[] args) throws Exception{
         //BufferedReader 构造方法
         //BufferedReader(Reader in) 通过字符输入流创建一个缓冲字符输入流。  
         //参数Reader【抽象类】---FileReader
         /*
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileReader red=new FileReader(file1);
         BufferedReader buf=new BufferedReader(red);
         */
         /*
         String path1="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt";
         Reader red=new FileReader(path1);
         BufferedReader buf=new BufferedReader(red);
         */
         //BufferedReader buf=new BufferedReader(new FileReader(new File(new String("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt"))));
         //BufferedReader(Reader in, int sz) 通过字符输入流创建一个指定缓冲区大小的缓冲字符输入流  
         /*
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileReader red=new FileReader(file1);
         BufferedReader buf=new BufferedReader(red,300);
         */
         /*
        String path1="F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt";
         Reader red=new FileReader(path1);
         BufferedReader buf=new BufferedReader(red,200);
         */
         BufferedReader buf=new BufferedReader(new FileReader(new File(new String("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt"))),100);
     }
}

读取数据

int	read()读取单个字符。返回值作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1
int	read(char[] cbuf, int offset, int length) 将字符读入数组中的某一部分。返回值读取的字符数，如果已到达流的末尾，则返回 -1
int	read(char[] cbuf) 将字符读入数组。返回值读取的字符数，如果已到达流的末尾，则返回 -1
void	close() 关闭该流并释放与之关联的所有资源。
String	readLine() 读取一个文本行。返回值包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

例如：

package com.click369.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //BufferedRaeder实例方法
         /*
          \*  int  read()读取单个字符。
             返回值作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 
             int  read(char[] cbuf, int offset, int length) 将字符读入数组中的某一部分。
            返回值读取的字符数，如果已到达流的末尾，则返回 -1 
             int  read(char[] cbuf) 将字符读入数组。
             返回值读取的字符数，如果已到达流的末尾，则返回 -1 
          */
         //上面的3个方法与FileReader中的方法一样
         //String  readLine() 读取一个文本行。
         //返回值包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null 
         File file1=new File("F:"+File.separator+"20191015"+File.separator+"mytest"+File.separator+"test2.txt");
         FileReader red=new FileReader(file1);
         BufferedReader buf=new BufferedReader(red);
         String lineinfo=null;
         while((lineinfo=buf.readLine())!=null){
             System.out.println(lineinfo);
         }
         buf.close();
         red.close();
     }
}

用BufferedReader完成命令行输入—readLine()

在没有BufferedReader之前使用Scanner完成命令行输入

Scanner完成命令行输入，输入字符串的时候【next】，字符串数据中间不能有空格

package com.click369.test3;
import java.util.Scanner;
public class TestMain {
   public static void main(String[] args) throws Exception{
         //Scanner完成命令行输入，输入字符串的时候【next】，字符串数据中间不能有空格
         //如果有空格值读取空格前面的数据值
         Scanner in=new Scanner(System.in);
         System.out.println("请输入一个字符串数据：");
         String info=in.next();
         System.out.println("得到的命令行数据:"+info);
     }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qoorLwqt-1595608469466)(C:\Users\18373\Desktop\Java基础\java基础第九节文件和IO流\img\字符串数据.png)]$

4.字符输入与字符输出流的类

字符流处理文本型数据，字节流也可以处理文本型数据，字符流处理文本型数据比字节流处理文本型数据方便。

往往我们有的时候会将字节流转换成字符流，为了处理文本型数据方便。

InputStreamReader类将字节输入流转换成字符输入流

java.io
类 InputStreamReader

public class InputStreamReader extends Reader

构造方法摘要
InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。

例如：

package com.click369.test3;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestMain {
     public static void main(String[] args) throws Exception{
         //使用BufferedReader代替Scanner完成 命令行输入字符串
         //Scanner之所以能够命令行输入数据是因为有System.in
         //System.in
         //System---java.lang.System
         //in -- 是System中的一个静态成员变量【InputStream--字节输入流】
         //使用InputStreamReader类【字符流】
         //将字节流转换成字符流
         BufferedReader read=new BufferedReader(new InputStreamReader(System.in));
         System.out.println("请输入一个字符串数据：");
         String info=read.readLine();
         System.out.println("得到的命令行数据:"+info);
         read.close();
     }
}

OutputStreamWriter****类将字节输出流转换成字符输出流

java.io
类 OutputStreamWriter

public class OutputStreamWriter extends Writer

构造方法摘要
OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。

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

例如：

package com.click369.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriterTest1 {
     public static void main(String[] args)throws Exception {
         String info="hello,你好";
         String path="F:"+File.separator+"20190801"+File.separator+"javaSE"+File.separator+"20190919JavaSE(26)"+File.separator+"test.txt";
         File file=new File(path);
         OutputStream out=new FileOutputStream(file);
         OutputStreamWriter outwriter=new OutputStreamWriter(out);
         outwriter.write(info);
         outwriter.close();
         out.close();
     }
}

intln(“得到的命令行数据:”+info);
read.close();
}
}


**OutputStreamWriter****类将字节输出流转换成字符输出流**

java.io 
 类 OutputStreamWriter

public class OutputStreamWriter  extends Writer

| 构造方法摘要                                                 |      |
| ------------------------------------------------------------ | ---- |
| **OutputStreamWriter**(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。 |      |

| void | **write**(char[] cbuf,  int off, int len) 写入字符数组的某一部分。 |
| ---- | ------------------------------------------------------------ |
| void | **write**(int c) 写入单个字符。                              |
| void | **write**(String str, int off,  int len) 写入字符串的某一部分。 |

例如：

package com.click369.test1;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriterTest1 {
public static void main(String[] args)throws Exception {
String info=“hello,你好”;
String path=“F:”+File.separator+“20190801”+File.separator+“javaSE”+File.separator+“20190919JavaSE(26)”+File.separator+“test.txt”;
File file=new File(path);
OutputStream out=new FileOutputStream(file);
OutputStreamWriter outwriter=new OutputStreamWriter(out);
outwriter.write(info);
outwriter.close();
out.close();
}
}