JAVA学习-File

File

文件和目录可以通过File封装成对象
File封装的只是一个路径名字

File(String pathname);//通过给定的路径名字字符串创新对象
File f1=new File("E:\\java\\java.txt");
sout(f1);
File(String parent,String child);//从父路径名字和子路径名字字符串创建File实例
File f2=new File("E:\\java","java.txt");
File(File parent,String child);//从父抽象路径名和子路径名字符串创建file实例
File f3=new File("E:\\java");
Filef4=new File(f3,"java.txt");

创建文件

//在e盘下创建java/java.txt文件用createNewFile();
//如果文件不存在就创建文件，并返回true,如果不存在就返回false
File f1=new File("E:\\java\\java.txt");
sout(f1.createNewFile());

//创建目录
sout(f2.mkdir());

//创建多级目录
sout(f3.mkdirs());

//删除。如果目录下有内容删除不了
sout(f4.delete());

字节流写数据

InputStream;//抽象类是所有字节输入流的超类
OutputStream;//抽象类是所有字节输出流的超类

//创建系统功能创建了对象，创建了字节输出流对象，让字节输出流以指定的名称写入文件
FileOutputStream fos=new FileOutputStream("mydir\\fos.txt");

//如果第二个参数为true,则字节将写入文件的末尾
FileOutputStream fos=new FileOutputStream("mydir\\fos.txt",true);

fos.write(97);//写入的是97编码的字符"a";
//释放资源
fos.close();

fos.write(int b);//一次写入一字节
fos.write(byte[] b);//一次写入一个字节数组（"abcde".getBytes()）;
fos.write(b,0,2);//从0开始写2个

//字节流实现换行
//window实现换行"\r\n",linux是"\n",mac是"\r"
fos.write("\r\n".getBytes());

字节流读数据

FileInputStream:从文件系统中的文件读数据
FileInputStream fis=new FileInputStream("mydir\\java.txt");

int by=fis.read();//从该输出流读取一个字节的数据,如果到文件末尾，返回-1
int b=fis.read();
while(b!=-1){sout(b)}

//一次读入一个字符数组
byte[] by=new byte[1024];
int len;
while((len=fis.read(by))!=-1){
	sout(len);
}

fis.close();

复制文本文件

FileInputStream fis=new FileInputStream("E:\\mydir\\java.txt");
FileOutputStream fos=new FileOutputStream("E:\\mydir1\\java.txt");

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

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

字节缓冲流

BufferOutputStream(OutputStream out):该类实现缓冲输出流。
BufferInputStream(InputStream in):创建一个内部缓冲区数组。

//写数据
FileOutputStream fos=new FileOutputStream("mydir\\java.txt");
BufferOutputStream bos=new BufferOutputStream(fos);
bos.write("hello\r\n".getBytes());
bos.write("world\r\n".getBytes());

//读数据
FileInputStream fis=new FileOutputStream("mydir\\java.txt");
BufferOutputStream bis=new BufferOutputStream(fis);
int by;
while((by=bis.read())!=-1){
	sout(by);
}

byte[] bys=new byte[1024];
int len;
while((len=bis.read(bys))!=-1){
	sout(new String(bys,0,len));
}

字符流

为什么出现字符流？方便编码中文。
InputStreamReader:读取字节(是从字节流到字符流的桥梁)
OutputStreamWriter:写字节

//使用平台默认的字符集输出到文件
FileOutputStram fos=new FileOutputStream("mydir\\java.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);
osw.write("中国");
osw.close();

//使用指定的编码输出到文件
FileOutputStram fos=new FileOutputStream("mydir\\java.txt","GBK");
OutputStreamWriter osw=new OutputStreamWriter(fos);
osw.write("中国");
osw.close();


//使用平台默认的编码创建读文件
FileInputStream fis=new FileInputStream("mydir\\java.txt");
InputStreamReader isr=new InputStreamReader(fis);
int by;
while((by=isr.read())!=-1){
	sout(by)
}
isr.close();

//使用指定编码格式创建读文件
FileInputStream fis=new FileInputStream("mydir\\java.txt","GBK");
InputStreamReader isr=new InputStreamReader(fis);
int by;
while((by=isr.read())!=-1){
	sout((char)by)
}
isr.close();

字符流写数据的方式

FileOutputStram fos=new FileOutputStream("mydir\\java.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);

//一次写入一个字符。只使用write会将字符存在缓冲区，需要进行刷新
osw.write(97);
osw.flush();
osw.write(98);
osw.flush();

//一次写入一个字符数组
char[] chs={'a','b','c'};
osw.write(chs);//可指定写入字符数组的一部分
//一次写入一个字符串
osw.write("abc");

//关闭流，先刷新
osw.close();

字符流读数据

FileInputStream fis=new FileInputStream("mydir\\java.txt");
InputStreamReader isr=new InputStreamReader(fis);

//一次读一个字符
int by;
while((by=isr.read())!=-1){
	sout((char)by);
}
//一次读一个字符数组
char[] chs=new char[1024];
int len;

//read函数，读取单个字节时，返回该字节的整数，读取字符数组时，返回读取的字节数。
while((len=isr.read(chs))!=-1){
	sout(new String(chs,0,len));
}

isr.close();

字符流复制Java文件

字符流直接子类，可以替代InputSteamReader和OutputSteamReader，不过要以指定编码写或者读文件，则只能使用OutputSteamReader等流。

FileReader fr=new FileReader(“mydir\java.txt”);
FileWriter fw=new FileWriter(“mydir\java.txt”);

InputSteamReader isr=new InputStreamReader(new FileInputStream("mydir\\c.java"));
OutputSteamReader osr=new OutputStreamReader(new FileOutputStream("mydir\\c1.java"));
//一次复制一个字符数据
int by;
while((by=isr.read())!=-1){
	osr.write(by);
}
//一次复制一个字符数组数据
char[] chs=new char[1024];
while((chs=isr.read(chs))!=-1){
	osr.write(chs,0,len);
}

isr.close();
osr.close();

字符缓冲流

BufferedWriter（Writer Out）:将文本写入字符输出流，缓冲字符。
BufferedReader(Reader In):从字符输入流读取文本，缓冲字符

FileWriter fw=new FileWriter("mydir\\java.txt");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("hello");
bw.write("world");
bw.close();

FileReader fr=new FileReader("mydir\\java.txt");
BufferedReader br=new BufferedReader(fr);
char[] chs=new char[1024];
int len;
while((len=br.read(chs))!=-1){
	sout(new String(chs,0,len));
}

字符缓冲流复制文件

FileReader fr=new FileReader("mydir\\java.txt");
BufferedReader br=new BufferedReader(fr);
FileWriter fw=new FileWriter("mydir\\java1.txt");
BufferedWriter bw=new BufferedWriter(fw);
char[] chs=new char[1024];
int len;
while((len=br.read(chs))!=-1){
	bw.write(chs,0,len);
}
br.close();
bw.close();

字符缓冲流的特有功能

BufferWriter
void new Line();写一行行分隔符，行分隔符字符串由系统属性定义
BufferedReader
String ReadLine();读一行文字，结果包含行的内容的字符串，不包括任何终止字符。如果文件已达末尾，则为null。

//newLine()
FileWriter fw=new FileWriter("mydir\\java1.txt");
BufferedWriter bw=new BufferedWriter(fw);
for(int i=0;i<10;i++){
	bw.write("hello");
	bw.newLine();
	bw.flush();
}
bw.close();

//ReadLine()只读内容，不读换行符号
FileReader fr=new FileReader("mydir\\java.txt");
BufferedReader br=new BufferedReader(fr);
String line=br.newLine();
sout(line);

String line;
while((line=br.readLine())!=null){
	sout(line);
}

//使用字符缓冲流复制文件
FileReader fr=new FileReader("mydir\\java.txt");
BufferedReader br=new BufferedReader(fr);
FileWriter fw=new FileWriter("mydir\\java1.txt");
BufferedWriter bw=new BufferedWriter(fw);

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

总结

File.getName()函数，返回的是参数中最后一个文件的名称，不受构造函数影响。