关于Java的File.separator

⼀、File类

在Windows下的路径分隔符（\\）和在Linux下的路径分隔符（/）是不⼀样的，当直接使⽤绝对路径时，跨平台会报No Such file or diretory异常。

File中还有⼏个与separator类似的静态常量，与系统有关，在编程中应尽量使⽤。ps：File file = new File(\"G:\"+ File.separator +\"demo.txt\");

File类是java.io包中唯⼀⼀个与⽂件本⾝操作有关的类，⽂件本⾝操作是指⽂件的创建、删除、重命名等　　.构造⽅法：public File(String pathName)，传⼊完整的路径，WEB开发此⽅式⽐较好⽤。　　.构造⽅法：public File(File parent,String child)，传⼊⽗路径和⼦路经。基本的⽂件操作：

　　.创建新⽂件：public boolean createNewFile() throws IOException;　　.删除⽂件：public boolean delete();　　.判断⽂件是否存在：public boolean exists();

import java.io.File;

import java.io.IOException;

public class TestFile {

public static void main(String [] args) throws IOException{ File file = new File(\"G:\\\\demo.txt\"); System.out.println(\"file:\"+file); if(file.exists()){ file.delete();

System.out.println(\"执⾏了删除⽂件！\"); }else{

file.createNewFile();

System.out.println(\"执⾏了创建⽂件\"); } }}

如果进⾏⽂件创建时有⽬录，则需要先创建⽬录之后才可以创建⽂件。　　.找到⽗路径：public File getParentFile();

　　.创建⽬录：(1)public boolean mkdirs();既可以在不存在的⽬录中创建⽂件夹⼜可以创建多级⽬录（个⼈推荐使⽤此⽅法）　　　　　　　 (2)public boolean mkdir();只能在已近存在的⽬录中创建⽂件夹

import java.io.File;

import java.io.IOException;

public class TestFile {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\"+ File.separator +\"Test\"+ File.separator +\"TestFile\"+ File.separator +\"demo.txt\"); if(!file.getParentFile().exists()){//⽂件不存在 file.getParentFile().mkdirs();

System.out.println(\"执⾏了创建多级⽬录\"); }

if(file.exists()){//⽂件存在 file.delete();

System.out.println(\"执⾏了删除⽂件！\"); }else{

file.createNewFile();

System.out.println(\"执⾏了创建⽂件\"); } }}

　　除了上述基本的⽂件和⽂件夹的操作之外，还提供了⼀些取得⽂件信息的⽅法：　　　　.判断路径是否是⽂件：public boolean isFile();　　　　.判断路径是否是⽂件夹：public boolean isDirectory();

　　　　.最后⼀次修改时间：public long lastModified();　　　　.取得⽂件⼤⼩：public long length();

　　　　.修改⽂件名称：public boolean renameTo(File dest);

import java.io.File;

import java.math.BigDecimal;

import java.text.SimpleDateFormat;

public class TestFileOne {

public static void main(String [] args){

File file = new File(\"G:\"+ File.separator +\"Test\"+ File.separator +\"TestFile\"+ File.separator +\"1.jpg\"); if(file.exists()){

System.out.println(file.isDirectory()? \"是⽂件夹\" : \"不是⽂件夹\"); System.out.println(file.isFile() ? \"是⽂件\" : \"不是⽂件\");

System.out.println(\"最后修改时间：\"+new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\").format(file.lastModified())); System.out.println(\"⽂件⼤⼩：\"

+ new BigDecimal((file.length() / (double) 1024 / 1024))

.divide(new BigDecimal(1), 2,BigDecimal.ROUND_HALF_UP) + \"M\");

if(file.renameTo(new File(\"G:\"+ File.separator +\"Test\"+ File.separator +\"TestFile\"+ File.separator +\"hello.jpg\"))){ System.out.println(\"重命名成功\"); }else{

System.out.println(\"重命名失败\"); } } }}

　　列出指定⽂件夹中的所有内容：　　　　public File [] listFiles();

import java.io.File;

public class TestFileTwo {

public static void main(String [] args){

File file = new File(\"G:\" + File.separator + \"Test\"); if(file.exists() && file.isDirectory()){ File [] list = file.listFiles();

for(int i = 0; i < list.length; i ++){

System.out.println(\"files：\"+list[i]); } } }}

　　列出指定⽬录中的所有⽂件（包含所有⼦⽬录中的⽂件），递归调⽤

import java.io.File;

public class TestFileThree {

public static void main(String [] args){

File file = new File(\"G:\" + File.separator + \"Test\"); print(file); }

public static void print(File file){

if(file.exists() && file.isDirectory()){ File [] files = file.listFiles();

if(files.length > 0 && files != null){ for(int i = 0; i < files.length; i++){ print(files[i]);//递归调⽤ } } }

System.out.println(file); }}

⼆、字节流与字符流

使⽤File类只能进⾏⽂件本⾝的操作，但是与内容的操作⽆关。如果想进⾏⽂件内容操作可以使⽤⼀下两组流：　　.字节流InputStream OutputStream　　.字符流reader writer

不管使⽤哪种流，基本的操作流程是⼀样的，以⽂件操作为例：　　.确定操作⽂件的路径

　　.通过字节流或字符流的⼦类为字节流和字符流类对象实例化　　.进⾏流⼊、流出操作

　　.关闭流，流属于资源操作，资源操作完成⼀定要关闭1、字节输⼊流：OutputStream

　　java.io.OutputStream是可以进⾏字节数据（byte）的输出　　OutputStream类中存在三个write()⽅法：　　　　·输出单个字节：public void write(int b);　　　　·输出全部字节：public void write(byte [] b);

　　　　·输出部分字节：public void write(byte [] b,int off,int len);

　　OutputStream是⼀个抽象类，所以可以使⽤⼦类对其进⾏实例化。对⽂件操作，可以使⽤FileOutputStream，这个类有两个常⽤的构造⽅法：

　　　　public FileOutputStream(File file) throws FileNotFoundException,覆盖;

　　　　public FileOutputStream(File file, boolean append) throws FileNotFoundException,追加;对⽂件进⾏覆盖的输出操作：

package com.java.io;import java.io.File;

import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;

public class TestFile {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\" + File.separator + \"Test\" + File.separator + \"demo.txt\"); if(!file.getParentFile().exists()){ file.getParentFile().mkdirs(); }

//通过OutputStream的⼦类对象为⽗类对象实例化 OutputStream output = new FileOutputStream(file); //要输出的数据

String msg = \"Hello world.\"; //将字符串转换为字节数组 byte [] data = msg.getBytes(); //输出字节数组 output.write(data); output.flush(); //关闭

output.close(); }}

　　不管执⾏⼏次，都是对当前⽂件的覆盖。如果不想覆盖，可以使⽤追加的⽅式创建FileOutputStream类对象　　　　.追加内容：OutputStream output = new FileOutputStream(file, true);　　单个字节：

package com.java.io;import java.io.File;

import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;

public class TestFile {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\" + File.separator + \"Test\" + File.separator + \"demo.txt\"); if(!file.getParentFile().exists()){ file.getParentFile().mkdirs(); }

//通过OutputStream的⼦类对象为⽗类对象实例化 OutputStream output = new FileOutputStream(file); //要输出的数据

String msg = \"Hello world.\\r\\n\"; //将字符串转换为字节数组 byte [] data = msg.getBytes(); //输出字节数组

for(int i = 0; i < data.length; i++){ output.write(data[i]); }

//关闭

output.close(); }}

2、字节输⼊流：InputStream

　　在InputStream类中定义有三个read()⽅法：

　　　　·读取单个字节：public int read() throws IOException;

　　　　　　每次使⽤read()操作将读取⼀个字节数据，此时返回的是数据，如果数据已读完，则int返回-1　　　　.读取内容到字节数组：public int read(byte [] b) throws IOException();　　　　　　将内容读取到字节数组中，返回读取的个数，如果读取完毕，则返回-1

　　　　.读取内容到部分字节数组：public int read(byte [] b,int off,int len) throws IOException();　　　　　　将指定长度的内容读取到字节数组中，返回读取个数，如果读取完毕，则返回-1

　　InputStream是抽象类，所以可以使⽤它的⼦类对其进⾏实例化。使⽤FileInputStream⼦类完成，其构造⽅法：　　　　public FileInputStream(File file) throws FileNotFoundException;　　使⽤InputStream读取数据

package com.java.io;import java.io.File;

import java.io.FileInputStream;import java.io.InputStream;public class TestFileOne {

public static void main(String[] args) throws Exception {

File file = new File(\"G:\"+File.separator+\"Test\"+File.separator+\"demo.txt\"); if(file.exists()){//⽂件存在

InputStream input = new FileInputStream(file);

byte [] data = new byte[1024];//此数组⽤于接受全部输⼊数据 int len = input.read(data);//将数据保存到数组中 System.out.println(\"\"+new String(data, 0, len)); input.close(); } }}

　　实际开发中使⽤while循环读取

package com.java.io;import java.io.File;

import java.io.FileInputStream;import java.io.InputStream;public class TestFileOne {

public static void main(String[] args) throws Exception {

File file = new File(\"G:\"+File.separator+\"Test\"+File.separator+\"demo.txt\"); if(file.exists()){//⽂件存在

InputStream input = new FileInputStream(file);

byte [] data = new byte[1024];//此数组⽤于接受全部输⼊数据 int temp = 0;//定义每次读取进来的数据 int foot = 0;//定义数组⾓标

//(temp = input.read()) != -1 判断temp是否等于-1，如果不是则继续读 while((temp = input.read()) != -1){ data[foot++] = (byte) temp; }

input.close(); //打印

System.out.println(new String(data, 0, foot)); } }}

3、字符输出流：Writer

　　字节输出流和字符输出流的区别：字节输出流是以byte类型为主，⽽字符输出流是以char为主，并且⽀持String的直接操作　　Writer类中的操作⽅法：

　　　　·输出字符串：public void write(String str) throws IOException;

　　　　·输出字节数组：public void write(char [] cbuf) throws IOException;　　但Writer是⼀个抽象类，如果使⽤它进⾏⽂件操作必须使⽤FileWriter⼦类

package com.java.io;import java.io.File;

import java.io.FileWriter;import java.io.IOException;import java.io.Writer;

public class TestFileWriter {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\"+File.separator+\"Test\"+File.separator+\"fileWrite.txt\"); if(!file.getParentFile().exists()){ file.getParentFile().mkdirs(); }

Writer out = new FileWriter(file); String msg = \"Hello world.\"; out.write(msg); out.close(); }}

4、字符输⼊流

　　Reader是负责字符数据读取的，使⽤read()⽅法实现读取，但没有直接返回String类型的读取操作　　　　·读取数据：public int read(char [] cbuf) throws IOException;

package com.java.io;import java.io.File;

import java.io.FileReader;import java.io.IOException;import java.io.Reader;

public class TestFileWriterOne {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\"+File.separator+\"Test\"+File.separator+\"fileWrite.txt\"); if(file.exists()){

Reader in = new FileReader(file); char [] data = new char[1024]; int len = in.read(data); in.close();

System.out.println(new String(data,0,len)); } }}

　　两种读取操作本质上区别不打，只是字符操作的是String/char，⽽字节操作的是byte;5、字节流和字符流的区别

　　·字符流：当程序进⾏中⽂处理时，字符流是最⽅便;

　　·字节流：当程序处理⼆进制数据（图⽚、⾳乐、电影）或⽹络数据传输，或者保存到磁盘数据⼀定是字节;

　　除以上区别之外，字节流在操作时直接与操作终端进⾏交互，⽽字符流需要经过缓冲区的处理后才可以进⾏操作，以OutputStream和Writer两个类输出⽂件为例，如果OutputStream输出的最后可以不关闭输出流，但是如果是Writer类输出的如果没有关闭，那么保存在缓冲区之中的数据将⽆法输出，或者强制刷新缓冲区。

package com.java.io;import java.io.File;

import java.io.FileWriter;import java.io.IOException;import java.io.Writer;

public class TestWriter {

public static void main(String [] args) throws IOException{

File file = new File(\"G:\"+File.separator+\"Test\"+File.separator+\"fileWrites.txt\"); if(!file.getParentFile().exists()){ file.getParentFile().mkdirs(); }

Writer out = new FileWriter(file);

String msg = \"Hello world,I am a programer.\"; out.write(msg); out.flush(); //out.close(); }}

　　所谓缓冲区就是⼀块内存，当数据读取进来之后会先进⼊内存区域之中进⾏处理，所以才可以更好的处理中⽂

三、转换流

既然存在字节和字符两种操作流，那么两种操作流之间是可以进⾏相互转换的，主要使⽤两个类： InputStreamReader、OutputStreamWriter

　　InputStreamReader是Reader的⼦类，所以InputStreamReader类对象可以⾃动转型为Reader类实例。　　OutputStreamWriter是Writer的⼦类，所以OutputStreamWriter类对象可以⾃动转型为Writer类实例。