标签：mes 否则 bis 文本格式 param 原来 otf 转换 bytearray
关键步骤：
1.使用File类操作文件或目录属性
java.io包提供了一些接口和类，对文件进行基本操作，包括对文件和目录属性的操作、对文件读写的操作等。
File即可以表示文件，也可以表示目录，在程序中一个File对象可以代表一个文件或目录。
| 方法名 | 说明 |
| 创建： | |
| createNewFile() | 在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。 |
| mkdir() | 在指定位置创建一个单级文件夹。它的路径名有当前File对象指定 |
| mkdirs() | 在指定位置创建一个多级文件夹，即包括父目录的目录 |
| renameTo(File dest) | 如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。 |
| 删除： | |
| delete() | 删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。 |
| deleteOnExit() | jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。 |
| 判断： | |
| exists() | 文件或文件夹是否存在。 |
| isFile() | 是否是一个文件，如果不存在，则始终为false。 |
| isDirectory() | 是否是一个目录，如果不存在，则始终为false。 |
| isHidden() | 是否是一个隐藏的文件或是否是隐藏的目录。 |
| isAbsolute() | 测试此抽象路径名是否为绝对路径名。 |
| 获取： | |
| getName() | 获取文件或文件夹的名称，不包含上级路径。 |
| getAbsolutePath() | 获取文件的绝对路径，与文件是否存在没关系 |
| length() | 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。 |
| getParent() | 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null |
| lastModified() | 获取最后一次被修改的时间。 |
| 文件夹相关： | |
| static File[] listRoots() | 列出所有的根目录（Window中就是所有系统的盘符） |
| list() | 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。 |
| listFiles() | 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。 |
| list(FilenameFilter filter) | 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。 |
| listFiles(FilenameFilter filter) | 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。 |
package cn.IO;
import java.io.*;
public class FileMethods {
public static void main(String[] args) {
FileMethods fm=new FileMethods();
File file=new File("D:\\javaWork\\IoTest.txt");
fm.create(file);
fm.showFileInfo(file);
//fm.delete(file);
}
/**
* 创建文件的方法
* @param file 文件对象
*/
public void create(File file){
if(!file.exists()){
try {
file.createNewFile();
System.out.println("文件已创建！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 删除文件
* @param file 文件对象
*/
public void delete(File file){
if(file.exists()){
file.delete();
System.out.println("文件已删除！");
}
}
/**
* 显示文件信息
* @param file 文件对象
*/
public void showFileInfo(File file){
if(file.exists()){ //判断文件是否存在
if(file.isFile()){ //如果是文件
System.out.println("名称:" + file .getName());
System.out.println("相对路径: " + file.getPath());
System.out.println("绝对路径: " + file.getAbsolutePath());
System.out.println("文件大小:" + file.length()+ " 字节");
System.out.println("最后修改日期："+file.lastModified());
}
if(file.isDirectory()){
System.out.println("此文件是目录");
}
}else
System.out.println("文件不存在");
}
}
2.Java的流
读文件是把文件中的数据读取到内存中，写文件是把呢村中的数据写到文件中，他们都是通过流来读写的。
流是指一连串流动的字符，是以先进先出的方式发送和接受数据的通道，如图：
流分为输入输出流，是相对于计算机内存来说的，输出流主要由OutInputStream和Writer作为基类，而输入流则主要由InputStream和Reader作为基类。
分类：表中带下划线的是抽象类，不能创建对象。粗体部分是节点流，其他就是常用的处理流。
3.用InputStream类和OutputStream类（字节流）读写文本文件
字节流类是从抽象类InputStream和OutputStream派生出来的一系列类．这类流以字节为基本处理单位．InputStream 和 OutputStream类除了可以用来处理二进制文件的数据之外，也可以用来处理文本文件。
| 方法名 | 说明 |
| InputStream类的常用方法： | |
| public abstract int read() thows IOException | 方法返回一个0至255之间的整数或-1, -1代表遇到了流的结束，其它对应读入的字节 |
| public int read(byte[]b) thows IOException | 方法将字节读入参数给定的缓冲区字节数组，返回值是实际读入的字节数或-1（遇到了流结束） |
| public int read(byte[]b, int i, int b) thows IOException | 方法的后两个参数分别给出读入的起始位置和读入的最大字节数 |
| public int available() | 返回当前流对象中还没有被读取的字节数量．也就是获得流中数据的长度 |
| public long skip(long n) | 跳过当前流对象中的n个字节，而实际跳过的字节数量则以返回值的方式返回 |
| public boolean markSupported() | 判断流是否支持标记（mark），标记可以方便的回到原来读过的位置 |
| public void close() | 关闭当前流对象，并释放该流对象占用的资源 |
| public void mark(int i) | 为流中当前的位置设置标志，使得以后可以从该位置继续读取 |
| public void reset() | 使流读取的位置回到设定标记的位置 |
| OutputStream类的常用方法： | |
| public void write(int b) throws IOException | 向流的末尾写入一个字节的数据 |
| public void write(byte[] b) throws IOException | 将数组b中的数据依次写入当前的流对象中 |
| public void wirte(byte[]b, int i, int n) | 将数组中从开始下标（包含），后续长度的数据依次写入到流对象中 |
| public void close() | 关闭当前流对象，并释放该流对象占用的资源 |
| public void flush() | 将当前流对象中的缓冲数据强制输出出去．使用该方法可以实现立即输出 |
(1) FileInputStream(File f)
以指定名字的文件对象f为数据源建立文件输入流．如果f存在的话但是它应是一个文件路径，如果是目录则会抛出IOException，但是如果是这个目录不存在的时候则会抛出：FileNotFoundException
(2) FileInputStream(String name)
以名为name的文件为数据源建立文件输入流．
(3) FileInputStream(FileDescriptor f)
根据文件描述符对象f为输入端建立一个文件输入流．
package cn.IO;
import java.io.*;
public class FileInputStreamTest {
public static void main(String[] args){
FileInputStream fis=null;
//创建流对象
try {
//IoTest.txt可先先手动写入一些数据
fis=new FileInputStream("d:\\javaWork\\IoTest.txt");
int data;
System.out.println("可读取的字节数："+fis.available());
System.out.print("文件内容为：");
//循环读数据 read()方法是从输入流读取1个8位的字节，把它转化为0-255之间的整数返回。将返回的整数转换为字符
while((data=fis.read())!=-1){
System.out.print((char)data);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭流对象
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
1）FileOutputStream(File f)
2）FileOutputStream(File f, boolean b)
3）FileOutputStream(String f)
package cn.IO;
import java.io.*;
public class FileOutputStreamTest {
public static void main(String[] args){
FileOutputStream fos=null;
try {
fos=new FileOutputStream("d:\\javaWork\\IoTest.txt",false);
String str="好好学习Java";
byte[] words=str.getBytes("UTF-8");
fos.write(words,0,words.length);
System.out.println("hello文件已更新");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
System.out.println("文件更新时出错！");
e.printStackTrace();
}finally{
try {
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
使用FileOutputStream要注意:
1) 在创建FileOutputStream实例时，如果相应文件不存在，则会自动创建一个空文件；
2）如果参数file或name表示的文件路径尽管存在，但是代表一个文件目录，则此时会抛出FileNotFoundException异常；
3）默认情况下，像文件写数据时将覆盖原有的内容
4. 使用字符流BufferedReader、FileReader和BufferedWriter、FileWriter读写文本文件
1）BufferedReader(Reader in)
2）BufferedReader(Reader in, int bufSize)
★FileReader构造方法：1）FileReader(File file);
2）FileReader(FileDescriptor e );
3）FileReader(String filename);
BufferedReader、FileReader两个类都是Reader抽象类的子类，使用了缓冲区，提高了读文本文件的效率。| 方法名 | 说明 |
| Reader类是个抽象类，该类的所有方法在错误条件下都会抛出IOException异常： | |
| abstract void close() | 关闭输入源 |
| void mark(int numChars) | 放置一个标记到输入源的当前点 |
| boolean markSupported() | 如果这个流支持mark/reset方法，将返回true |
| int read() | 读取单个字符 |
| int read(char[] buf) | 读字符读入到字符数组 |
| abstract int read(char[] buf, int offset, int numChars) | 将字符读入数组的某一部分 |
| boolean ready() | 如果下一个输入请求不必等待，返回true，否则返回false |
| void reset() | 重置输入指针到前面设置的标记 |
| long skip(long numChars) | 跳过n个字符输入，返回实际跳过的字符数 |
| Writer类也是个抽象类： | |
| abstract void close() | 关闭输出流 |
| abstract void flush() | 确定输出状态以便清空任何缓存 |
| void write(int ch) | 写入单个字符 |
| void write(char[] buf) | 写入字符数组 |
| abstract void write(char[] buf, int offset, int numChars) | 写入字符数组的一部分 |
| void write(String str) | 写入字符串 |
| void write(String str, int offset, int numChars) | 写入字符串的一部分 |
package cn.IO;
import java.io.*;
public class BufferedReaderTest {
/**
* @param args
*/
public static void main(String[] args) {
FileReader fr=null;
BufferedReader br=null;
try {
//创建一个FileReader对象
fr=new FileReader("d:\\javaWork\\hello.txt");
//创建一个BufferedReader 对象
br=new BufferedReader(fr);
//读取一行数据
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
}catch(IOException e){
System.out.println("文件不存在!");
}finally{
try {
//关闭 流
if(br!=null)
br.close();
if(fr!=null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
注意：读取文件时，出现中文乱码，由于文件是txt格式，编码格式默认为ANSI格式，即GBK，所以需要转为utf-8：
InputStreamReader reader = new InputStreamReader(new FileInputStream(new File("文件路径")), "utf-8");
package cn.IO;
import java.io.*;
/*
* 当hello.txt编码格式是ANSI时，程序可以正常读取数据，（InputStreamReader fr=new InputStreamReader(fis,"gbk"); ）；
* 当hello.txt编码格式改为UTF-8时，代码改为InputStreamReader fr=new InputStreamReader(fis,"UTF-8"); 时才可以正常读取数据。
* */
public class BufferedReaderTest {
public static void main(String[] args) {
InputStreamReader fr = null;
BufferedReader br = null;
try {
FileInputStream fis = new FileInputStream("d:\\javaWork\\hello.txt");
// 指定编码格式
fr = new InputStreamReader(fis, "utf-8");
br = new BufferedReader(fr);
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
try {
br.close();
fr.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
System.out.println(e.getMessage());
}
}
}
但是对于一些特殊符号如空格等以及输出中文时出现乱码，这里引用一个转码类，将源文件解析后转成utf-8，再读取数据:
package cn.IO; import java.io.*;
//转码类 public class getCharset { public static String get_charset(File file) { String charset = "GBK"; byte[] first3Bytes = new byte[3];//首先3个字节 try { boolean checked = false; BufferedInputStream bis = new BufferedInputStream( new FileInputStream(file)); bis.mark(0); int read = bis.read(first3Bytes, 0, 3); if (read == -1) return charset; if (first3Bytes[0] == (byte) 0xFF && first3Bytes[1] == (byte) 0xFE) { charset = "UTF-16LE"; checked = true; } else if (first3Bytes[0] == (byte) 0xFE && first3Bytes[1] == (byte) 0xFF) { charset = "UTF-16BE"; checked = true; } else if (first3Bytes[0] == (byte) 0xEF && first3Bytes[1] == (byte) 0xBB && first3Bytes[2] == (byte) 0xBF) { charset = "UTF-8"; checked = true; } bis.reset(); if (!checked) { // int len = 0; int loc = 0; while ((read = bis.read()) != -1) { loc++; if (read >= 0xF0) break; if (0x80 <= read && read <= 0xBF) // 单独出现BF以下的，也算是GBK break; if (0xC0 <= read && read <= 0xDF) { read = bis.read(); if (0x80 <= read && read <= 0xBF) // 双字节 (0xC0 - 0xDF) // (0x80 // - 0xBF),也可能在GB编码内 continue; else break; } else if (0xE0 <= read && read <= 0xEF) {// 也有可能出错，但是几率较小 read = bis.read(); if (0x80 <= read && read <= 0xBF) { read = bis.read(); if (0x80 <= read && read <= 0xBF) { charset = "UTF-8"; break; } else break; } else break; } } } bis.close(); } catch (Exception e) { e.printStackTrace(); } return charset; } }
package cn.IO;
import java.io.*; //1、导入相关包
public class BufferedReaderTest {
/**
* @param args
*/
public static void main(String[] args) {
//FileReader fr=null;
BufferedReader br=null;
try {
//获取文件编码格式
File dir = new File("d:\\javaWork\\hello.txt");//指定路径
String charset=getCharset.get_charset(dir);
if (charset == "GBK") {
//2、InputStreamReader是转换流
InputStreamReader reader_GBK = new InputStreamReader(
new FileInputStream(dir), "gb2312");
//3、创建一个BufferedReader流对象
br = new BufferedReader(reader_GBK);
}
if (charset == "UTF-8") {
InputStreamReader reader_UTF = new InputStreamReader(
new FileInputStream(dir), "UTF-8");
//3、创建一个BufferedReader流对象
br = new BufferedReader(reader_UTF);
}
//4、使用readLine()读取一行数据
String line=null;
while((line = br.readLine()) != null) {
System.out.println(line);
}
//System.out.println(new String(s.getBytes("utf-8"),"utf-8"));*/
}catch(IOException e){
System.out.println("文件不存在!");
}finally{
try {
//5、关闭 流
if(br!=null)
br.close();
//if(fr!=null)
//fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
BufferedWriter和FileWriter类继承自Writer类，他们是用来将数据写入到缓冲区里。使用过程与使用BufferedReader、FileReader类过程相似。不同的是，缓冲区内的数据最后必须要用flush()方法将缓冲区清空，也就是将缓冲区中的数据全部写到文件内。
★BufferedWriter构造方法有：
1）BufferedWriter(Writer out)
2）BufferedWriter(Writer out, int bufSize)
★FileWriter构造方法有：
1）FileWrite(File filePath)
2）FileWrite(File f, boolean append)
3）FileWrite(FileDescriptor e)
4）FileWrite(String filename)
5）FileWrite(String filename,boolean append)
package cn.IO;
//1、引入相关的类
import java.io.*;
public class BufferedWriterTest {
public static void main(String[] args) {
FileWriter fw=null;
BufferedWriter bw=null;
FileReader fr=null;
BufferedReader br=null;
try {
//2、创建一个FileWriter 对象
fw=new FileWriter("d:\\javaWork\\hello.txt");
//3、创建一个BufferedWriter 对象
bw=new BufferedWriter(fw);
//4、用write()方法写文本文件
bw.write("大家好！");
bw.write("我正在学习BufferedWriter。");
bw.newLine();
bw.write("请多多指教！");
bw.newLine();
//5、调用flush()方法刷新缓冲区
bw.flush();
//6、读取文件内容
//获取文件编码格式
File dir = new File("d:\\javaWork\\hello.txt");//指定路径
String charset=getCharset.get_charset(dir);
if (charset.equals("GBK")) {
//InputStreamReader是转换流
InputStreamReader reader_GBK = new InputStreamReader(
new FileInputStream(dir), "gb2312");
//创建一个BufferedReader流对象
br = new BufferedReader(reader_GBK);
}
if (charset.equals("UTF-8")) {
InputStreamReader reader_UTF = new InputStreamReader(
new FileInputStream(dir), "UTF-8");
//创建一个BufferedReader流对象
br = new BufferedReader(reader_UTF);
}
//使用readLine()读取一行数据
String line=null;
while((line = br.readLine()) != null) {
System.out.println(line);
}
}catch(IOException e){
System.out.println("文件不存在!");
}finally{
try{
if(fw!=null)
fw.close();
if(br!=null)
br.close();
if(fr!=null)
fr.close();
}catch(IOException ex){
ex.printStackTrace();
}
}
}
}
5. 读写二进制文件
1.使用DtaInputStream、DataOutputStream字节流读写二进制文件
这两个流属于过滤流，常以其它流如InputStream或OutputStream作为它们的输入或输出，例如：
FileInputStream fis = new FileInputStream("d:\\a.txt");
DataInputStream dis = new DataInputStream(fis);
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
DataOutputStream dos = new DataOutputStream(fos);
DateInputStream和DataOutputStream的输入和输出几乎是对应的，每种基本数据类型的读写方法可以从其后缀名字识别．例如：
package cn.IO;
import java.io.*;
//二进制文件的读写
public class ReadAndWriteBinaryFile {
public static void main(String[] args){
DataInputStream dis=null;
DataOutputStream dos=null;
FileInputStream fis=null;
FileOutputStream fos=null;
try {
//创建输入流对象
fis=new FileInputStream("d:\\javaWork\\star.jpg");
dis=new DataInputStream(fis);
//创建输出流对象
fos=new FileOutputStream("d:\\javaWork\\new.jpg");
dos=new DataOutputStream(fos);
//读取文件并写入文件
int temp;
while((temp=dis.read())!=-1){
dos.write(temp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(dis!=null){
dis.close();
}
if(dos!=null){
dos.close();
}
if(fis!=null){
fis.close();
}
if(fos!=null){
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
6. 重定向标准I/O
前面介绍的十几个常用的流对象，用于对文件进行操作。还有2个流：System.in和System.out，它是Java提供的两个标准输入/输出流，主要用于键盘接受数据以及向屏幕输出数据。
有些时候使用标准I/O读写文件会很方便，如何实现呢？首先需要重定向标准I/O，就是讲标准I/O重新定向到其他的I/O设备，例如将输出设备定位到文件。
System类提供了3个重定向标准I/O的方法，如下表：
| 方法名 | 说明 |
| static void setErr(PrintStream err) | 重定向标准错误输出流 |
| static void setIn(InputStream in) | 重定向标准输r入流 |
| static void setOut(OutputStream out) | 重定向标准输出流 |
实例：
package cn.IO;
import java.io.*;
/*
* 重定向输入输出流
*/
public class PrintStreamTest {
public static void main(String[] args) {
File file = new File("d:\\javaWork\\print.txt");
FileOutputStream fileOutputStream = null;
PrintStream printStream = null;
try{
fileOutputStream = new FileOutputStream(file);
//创建PrintStream输出流
printStream = new PrintStream(fileOutputStream);
//将标准输出流重定向到文件
System.setOut(printStream);
//向文件中输出内容
System.out.println("我的测试，重定向到print文件！");
}catch(FileNotFoundException fi){
fi.printStackTrace();
}finally {
if(printStream!=null){
printStream.close();
}
try{
if(fileOutputStream!=null){
fileOutputStream.close();
}
}catch (IOException ioe){
ioe.printStackTrace();
}
}
}
}
7.IO 的一般使用原则：
1）按数据来源（去向）分：
1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )
2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )
3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )
4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )
5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )
2）按是否格式化输出分：
1 、要格式化输出： PrintStream, PrintWriter
3）按是否要缓冲分：
1 、要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )
4）按数据格式分：
1 、二进制格式（只要不能确定是纯文本的，比如图片、音频、视频） : InputStream, OutputStream 及其所有带 Stream 结尾的子类
2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类
5）按输入输出分：
1 、输入： Reader, InputStream 类型的子类
2 、输出： Writer, OutputStream 类型的子类
6）特殊需要：
1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter
2 、对象输入输出： ObjectInputStream, ObjectOutputStream
3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4 、合并输入： SequenceInputStream
5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
标签：mes 否则 bis 文本格式 param 原来 otf 转换 bytearray
原文地址：https://www.cnblogs.com/yutianbao/p/10612259.html
