文件和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. 什么是输入输出流?
按照数据的流向:
输入流:数据从本程序之外的地方[文件]引入到本程序中时所形成的移动轨迹就是输入流。
【读取数据】
输出流:数据从本程序中流向本程序之外的地方[文件]所形成的移动轨迹就是输出流。
【写出数据】
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);
}
}
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();
}
}
##