Android（java）学习笔记167：Java中操作文件的类介绍（File + IO流）

import java.io.File;
/*
* 我们要想实现IO的操作，就必须知道硬盘上文件的表现形式。
* 而Java就提供了一个类File供我们使用。
*
* File:文件和目录(文件夹)路径名的抽象表示形式
* 构造方法：
*         File(String pathname)：根据一个路径得到File对象
*         File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
*         File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
*/

public class FileDemo01 {
public static void main(String[] args) {
//File(String pathname)：根据一个路径得到File对象
//file:文件和目录(文件夹)路径名的抽象表示形式,表示file指向这个f:\\text.txt下的文件，至于是否存在是今后的操作
File file = new File("f:\\files\\text.txt");

//File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
File file2 = new File("f:\\files","text.txt");

//File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
File file3 = new File("f:\\files");
File file4 = new File(file3,"text.txt");
}

}

import java.io.File;
import java.io.IOException;

public class FileDemo {

public static void main(String[] args) throws IOException {
//需求在f盘下temp文件夹下 创建files文件夹,指引出创建的目的路径
File file = new File("f:\\temp\\files");
System.out.println("创建文件夹："+file.mkdir());

//在刚刚创建的files文件夹下创建文件text.txt，指引出创建的目的路径
File file2 = new File("f:\\temp\\files\\text.txt");
System.out.println("创建文件："+file2.createNewFile());
}

}

import java.io.File;
import java.io.IOException;

/*
*创建功能：
*public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
*public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
*public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
*
*/
public class FileDemo {
public static void main(String[] args) throws IOException {
// 需求：我要在e盘目录下创建一个文件夹demo
File file = new File("e:\\demo");
System.out.println("mkdir:" + file.mkdir());

// 需求:我要在e盘目录demo下创建一个文件a.txt
File file2 = new File("e:\\demo\\a.txt");
System.out.println("createNewFile:" + file2.createNewFile());

// 需求：我要在e盘目录test下创建一个文件b.txt
// Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
// 注意：要想在某个目录下创建内容，该目录首先必须存在。
// File file3 = new File("e:\\test\\b.txt");
// System.out.println("createNewFile:" + file3.createNewFile());

// 需求:我要在e盘目录test下创建aaa目录，这是错误的
// File file4 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file4.mkdir());

//这里是可以实现的，但是往往多层目录这样创建是很繁琐的，往往使用下一种方法mkdirs()
// File file5 = new File("e:\\test");
// File file6 = new File("e:\\test\\aaa");
// System.out.println("mkdir:" + file5.mkdir());
// System.out.println("mkdir:" + file6.mkdir());

// 其实我们有更简单的方法
File file7 = new File("e:\\aaa\\bbb\\ccc\\ddd");
System.out.println("mkdirs:" + file7.mkdirs());

// 看下面的这个东西：
File file8 = new File("e:\\liuyi\\a.txt");
System.out.println("mkdirs:" + file8.mkdirs());
}
}

package com.himi.itcast_02;

import java.io.FileInputStream;

public class FileDemo1 {

public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("f:\\temp\\files\\text.txt");//打开指定的字节文件输出流
byte[] b = new byte[fis.available()];//新建一个字节数组，大小为fis输出流的字节数
fis.read(b);//读取fis字节流中文件到字节数组b之中
fis.close();//及时fis关闭字节流，释放资源
String str = new String(b);
System.out.println(str);//读取文件内容

}

}

package com.himi.itcast_02;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileDemo2 {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("f:\\temp\\files\\feeling.txt");
byte[] data = "我爱朱茵".getBytes("GB2312");
fos.write(data);
fos.close();

}

}

BufferedInputStream(InputStream in)

BufferedInputStream

InputStream

in

BufferedInputStream(InputStream in,
int size)

BufferedInputStream

InputStream

in

package com.himi.itcast_02;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class FileDemo3 {
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"f:\\temp\\files\\text.txt"));

// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}

// 释放资源
bis.close();
}

}

package com.himi.itcast_02;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
* 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
* 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
* 这种类被称为：缓冲区类(高效类)
* 写数据：BufferedOutputStream
* 读数据：BufferedInputStream
*
* 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
* 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
*/

public class FileDemo5 {
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("f:\\temp\\files\\helloworld.txt"));

// 写数据
bos.write("朱茵5201314".getBytes());

// 释放资源
bos.close();
}

}

[b][b]

package com.vincent.example;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataStream {
public static void main(String[] args) {
// 使用DataInputStream,DataOutputStream写入文件且从文件中读取数据。
try {
// Data Stream写到输入流中
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"datasteam.txt"));
dos.writeBytes("世界"); //按2字节写入，都是写入的低位
dos.writeChars("世界"); // 按照Unicode写入
// 按照UTF-8写入(UTF8变长，开头2字节是由writeUTF函数写入的长度信息，方便readUTF函数读取)
dos.writeUTF("世界");
dos.flush();
dos.close();

// Data Stream 读取
DataInputStream dis = new DataInputStream(new FileInputStream(
"datasteam.txt"));
// 读取字节
byte[] b = new byte[2];
dis.read(b);
System.out.println(new String(b, 0, 2));

// 读取字符
char[] c = new char[2];
for (int i = 0; i < 2; i++) {
c[i] = dis.readChar();
}
System.out.println(new String(c, 0, 2));

// 读取UTF
System.out.println(dis.readUTF());

dis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
// 创建对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt")); // 默认GBK   此时在工程目录下，也可以自己指定目录
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt"), "GBK"); // 指定GBK
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw.txt"), "UTF-8"); // 指定UTF-8
// 写数据
osw.write("中国");

// 释放资源
osw.close();
}
}

[b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b]

[b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b][b]

[b]

public class FileDemo7 {

public static void main(String[] args) throws Exception {
// 创建对象
// InputStreamReader isr = new InputStreamReader(new FileInputStream(
// "osw.txt"));

// InputStreamReader isr = new InputStreamReader(new FileInputStream(
// "osw.txt"), "GBK");

InputStreamReader isr = new InputStreamReader(new FileInputStream(
"osw.txt"), "GBK");

// 读取数据
// 一次读取一个字符
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}

// 释放资源
isr.close();

}

}

[b]

package filewriter;

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

public class Filewriter {

private static final String LINE_SEPARATOR = System.getProperty("line.separator");//行与行之间的分隔符

/**
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
/**
* 创建一个可以往文件中写入字符数据的字符流输出流对象
* 创建时必须明确文件的目的地
* 如果文件不存在，这回自动创建。如果文件存在，则会覆盖。
* 当路径错误时会抛异常
*
* 当在创建时加入true参数，回实现对文件的续写。
*/
FileWriter fw = new FileWriter("demo1.txt",false);
/**
* 调用该对象的write方法，向文件写入字符。
*
* 其实写入到了临时存储缓冲区中
*/
//        fw.write("hello \r\nworld!");//windows中的换行为\r\n    unix下为\r。
fw.write("aello"+LINE_SEPARATOR+"world!");
fw.write("hahaha");
/**
* 进行刷新，将字符写到目的地中。
*/
//        fw.flush();
/**
* 关闭流，关闭资源。在关闭前会调用flush方法 刷新缓冲区。关闭后在写的话，会抛IOException
*/
fw.close();

}

}

package com.himi.itcast_02;

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

public class FileReaderDemo {
public static void main(String[] args) throws IOException {
/**
* 创建读取字符数据的流对象。 读取路径不正确时会抛 IOException 用以个读取流对象关联一个已存在文件。
*/
FileReader fr = new FileReader("demo1.txt");
/**
* 用Reader中的read方法读取字符。
*/
/*
* int ch = fr.read(); System.out.print((char)ch); int ch1 = fr.read();
* System.out.print((char)ch1); int ch2 = fr.read();
* System.out.print((char)ch2);
*/
int ch = 0;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
fr.close();
}

}

package com.himi.itcast_02;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderWriterDemo {
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader("F:\\my.txt");//倘若F盘根目录下没有my.txt，会抛出java.io.FileNotFoundException
fw = new FileWriter("E:\\you.txt");//倘若E盘根目录下没有you.txt,就会自动创建you.txt.

char []buf = new char[1024];
int len = 0;
//读一个数组大小，写一个数组大小方法。
while((len = fr.read(buf)) != -1){
fw.write(buf, 0, len);
}

} catch (Exception e) {
System.out.println(e.toString());
} finally {
if (fr != null)
try {
fr.close();
} catch (Exception e2) {
throw new RuntimeException("关闭失败！");
}
if (fw != null)
try {
fw.close();
} catch (IOException e) {
throw new RuntimeException("关闭失败！");
}
}
}
}

package com.himi.itcast_02;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;

public class BufferedReaderDemo {

public static void main(String[] args) throws java.io.IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一段文字，可包含空白：");
String text = br.readLine();
System.out.println("您输入的文字：" + text);
}

}

package com.himi.itcast_02;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
public static void main(String[] args) {
try {

String content = "This is the content to write into file";

File file = new File("F:\\temp\\files\\bufferedwriter.txt");

// if file doesnt exists, then create it
if (!file.exists()) {
file.createNewFile();
}

FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close();

System.out.println("Done");

} catch (IOException e) {
e.printStackTrace();
}
}
}