9.文件和IO流
1.File类的对象创建和常用方法？
输入输出流是对计算机文件进行操作的java类库。【读写文件数据】
1.计算机中的文件是由几部分组成？
文件的基本属性。【文件的名称，后缀名，修改日期，类型…】【java.io.File类】
2.文件中的数据。【输入输出流】
对文件的基本属性进行操作
在java中我们通过java.io.File类实现对文件的基本属性进行操作。
3.java.io.File类
定义：
public class File
extends Object
implements Serializable, Comparable
既然是一个类，那么在使用的时候就需要创建对象。
构造方法摘要
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);
//创建出文件对象，并不会得到实际文件。
}
}
上面的实例中指定文件路径的时候
1.路径分割符【\】,window系统下的路径分隔符需要转义
2.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;
import 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.什么是输入输出流？
按照数据的流向：
输入流：数据从本程序之外的地方[文件]引入到本程序中时所形成的移动轨迹就是输入流。
【读取数据】
输出流：数据从本程序中流向本程序之外的地方[文件]所形成的移动轨迹就是输出流。
【写出数据】
4.流的另一个分类
按照每一次读写数据的量：
1.字节流：每一次可以读/写，一个字节，8位2进制数据的量，由于所有的数据都可以转换成字节，因此字节流可以处理任何类型的数据【文本,图片，视频，音频…】
2.字符流：每一次可以读/写，一个字符，16位2进制数据的量，只能处理文本型数据【word文档，记事本文件】，不能处理图片，视频，音频这些类型的文件。
3.字节输入与字节输出流的类
5.字节流：
按照数据的流向：
字节输出流【写出数据】
在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盘。
package 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();
}
}
4.字符输入与字符输出流的类
字符输出流
在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(String str)
写入字符串。
void write(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;
import 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;
import 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);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
