文档
Java IO流
基本
进制转化
十进制转其它进制
Integer.toBinaryString(112)
Integer.toOctalString(112)
Integer.toHexString(112)
其它进制转十进制
Integer.parseInt("1110000", 2)
Integer.parseInt("27", 8)
Integer.parseInt("A0", 16)
字节
数据类型转字节
例如int类型转字节
字符串转为字节数组
int类型转为字节数组
public static byte[] int2Bytes(int id){
byte[] arr = new byte[4];
for (int i = 0; i < arr.length; i++) {
arr[i] = (byte)((id >> i*8) & 0xff);
}
return arr;
}
public static int bytes2Int(byte[] arr){
int result = 0;
for (int i = 0; i < arr.length; i++) {
result += (int)((arr[i] & 0xff) << i*8);
}
return result;
}
文件编码
utf-8,中文占用3个字节,英文占用1个字节
gbk编码中文占用2个字节,英文占用1个字节
utf-16be,中文占用2个字节,英文占用2个字节
String s = "慕课ABC";
byte[] bytes1 = s.getBytes("utf-8");
for (byte b : bytes1) {
System.out.print(Integer.toHexString(b & 0xff) + " ");
}
File
java.io.File
类用于表示文件(目录)
File类只用于表示文件(目录)的信息(名称、大小等),不能用于文件内容的访问。
mkdir()
创建文件夹
mkdirs()
创建多级目录
delete()
删除文件/文件夹
File.separator
设置分隔符
file.isDirectory()
是否是一个目录
file.isFile()
是否是一个文件
创建一个文件
//File file2 = new File("/Users/Miller/Movies/img/imooc/日记.txt");
File file2 = new File("/Users/Miller/Movies/img/imooc", "日记.txt");
if (!file2.exists()) {
try {
file2.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}else{
file2.delete();
}
遍历目录
list()
方法用于列出当前目录下的子目录和文件,返回的是字符串数组。
listFiles()
返回的是直接目录和文件的抽象。
/**
* 列出指定目录下(包括子目录)的所有文件
* @param dir
* @throws IOException
*/
public static void listDirectory(File dir) throws IOException
{
if(!dir.exists()){
throw new IllegalArgumentException("目录:"+dir+"不存在");
}
if (!dir.isDirectory()) {
throw new IllegalArgumentException(dir+"不是目录");
}
/*
//list()方法用于列出当前目录下的子目录和文件
String[] filenames = dir.list();
for (String filename : filenames) {
System.out.println(dir+File.separator+filename);
}
*/
File[] files = dir.listFiles();
if (files != null && files.length > 0) {
for (File file : files) {
if (file.isDirectory()) {
//递归
listDirectory(file);
}else{
System.out.println(file);
}
}
}
}
RandomAccessFile
java提供的对文件内容的访问,既可以读文件,也可以写文件。RandomAccessFile支持随机访问文件,可以访问文件的任意位置。
java文件模型
在硬盘上的文件是byte byte byte存储的,是数据的集合。
打开文件
有两种模式,”rw”读写,”r”只读
RandomAccessFile raf = new RandomAccessFile(file, "rw");
它内部还包括一个文件指针,打开文件时 pointer=0;
写方法
raf.write(int)–>只写一个字节(后8位),同时指针指向下一个位置。
读方法
int b = raf.read()–>读一个字节
文件读写完成以后一定要关闭。
例子
写文件
用write方法只能写一个字节,如果需要把i写进去就得写4次
int i = 0x7fffffff;
//用write方法只能写一个字节,如果需要把i写进去就得写4次
raf.write(i >>> 24);//高8位
raf.write(i >>> 16);
raf.write(i >>> 8);
raf.write(i);
System.out.println(raf.getFilePointer());
也可以直接写一个int
raf.writeInt(i);
直接写入字节数组
String s = "中";
byte[] gbk = s.getBytes("gbk");
raf.write(gbk);
System.out.println(raf.getFilePointer());
读文件
读文件,必须把指针移到头部
String s = "中";
byte[] gbk = s.getBytes("gbk");
raf.write(gbk);
System.out.println(raf.getFilePointer());
raf.seek(0);
byte[] buf = new byte[(int)raf.length()];
raf.read(buf);
System.out.println(Arrays.toString(buf));
String s1 = new String(buf, "gbk");
System.out.println(s1);
raf.close();
字节流
InputStream
/OutputStream
InputStream
抽象了应用程序读取数据的方式
OutputStream
抽象了应用程序写出数据的方法
EOF= end
, 读到-1就读到结尾
输入流基本方法,主要是读。
int b = in.read();
读取一个字节无符号填充到int低八位。-1是EOF
in.read(byte[] buf)
读取数据填充到字节数组buf
in.read(byte[] buf, int start, int size)
读取数据到字节数组buf,从buf的start位置开始,存放size长度的数据
输出流基本方法,主要是写。
out.write(int b)
写一个byte到流,b的低8位
out.write(byte[] but)
将but字节数组都写入到流
out.write(byte[] but, int start, int size)
字节数组but从start位置开始写size长度的字节到流
文件输入流FileInputStream
FileInputStream
–>具体实现了在文件上读取数据
单字节读取不适合大文件,大文件效率很低
/**
* 对于指定文件内容,按照16进制输出到控制台
* 并且每输出10个byte换行
* @param fileName
*/
public static void printHex(String fileName) throws IOException {
//把文件作为字节流进行流操作
FileInputStream in = new FileInputStream(fileName);
int b;
int i = 1;
while((b=in.read()) != -1){
if(b < 0xf){
//单位数前面补0
System.out.print("0");
}
System.out.print(Integer.toHexString(b)+" ");
if(i++%10 ==0){
System.out.println();
}
}
in.close();
}
也可以通过byte来实现。批量字节读取,对大文件而言,效率高,也是最常用的。
public static void printHexByByteArray(String fileName) throws IOException
{
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[20*1024];
//从in中批量读取字节,放入buf字节数组中,从0开始放,最多放buf.length
//返回的是读到的字节的个数
//一次性读完,说明字节数组足够大
/*
int bytes = in.read(buf, 0, buf.length);
int j = 1;
for (int i = 0; i < bytes; i++) {
if ((buf[i] & 0xff) <= 0xf) {
System.out.print("0");
}
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if (j++ % 10 == 0) {
System.out.println();
}
}
*/
int bytes = 0;
int j = 0;
while((bytes = in.read(buf,0,buf.length)) != -1){
for(int i= 0; i < bytes; i++){
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if (j++ % 10 == 0) {
System.out.println();
}
}
}
in.close();
}
文件输出流FileOutputStream
FileOutputStream
实现了向文件中写出byte数据的方法。
//如果文件不存在,则直接创建,如果存在,删除后创建
FileOutputStream out = new FileOutputStream("demo/out.dat");
//如果文件不存在,则直接创建,如果存在,则在后面添加内容
//FileOutputStream out = new FileOutputStream("demo/out.dat", true);
out.write('A');//写出A字符的低八位
out.write('b');//写出b字符的低八位
int a = 10;//write只能写八位,那么些int需要写4次
out.write(a >>> 24);
out.write(a >>> 16);
out.write(a >>> 8);
out.write(a);
//写字节数组
byte[] gbk = "中国".getBytes("gbk");
out.write(gbk);
out.close();
文件的copy操作
public static void copyFile(File srcFile, File destFile) throws IOException
{
if (!srcFile.exists()) {
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
byte[] buf = new byte[8*1024];
int b;
while((b = in.read(buf,0, buf.length)) != -1){
out.write(buf, 0, b);
out.flush();
}
in.close();
out.close();
}
数据输入输出流DataOutputStream/DataInputStream
DataOutputStream/DataInputStream是对”流”功能的扩展,可以更加方便的读取int、long,字符等类型数据。
DataOutputStream
的一些方法:
writeInt()
写一个整型writeDouble()
writeUTF()
如下的DataOutputStream
例子:
String file = "demo/dos.txt";
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
dos.writeInt(10);
dos.writeLong(10l);
//采用utf-8编码输出
dos.writeUTF("中国");
//采用utf-16be编码写出
dos.writeChars("中国");
dos.close();
写入数据之后,就可以通过DataInputStream
来读取数据,如下:
String file = "demo/dos.txt";
DataInputStream dis = new DataInputStream(new FileInputStream(file));
int i = dis.readInt();
long l = dis.readLong();
String s = dis.readUTF();
System.out.println("i = " + i + ";l = "+l+";s = "+s);
控制台输出结果如下:
i = 10;l = 10;s = 中国
字节缓冲流BufferedInputStream&BufferedOutputStream
这两个”流”类为IO提供了带缓冲区的操作,一般打开文件进行写入或读取操作时,都会加上缓冲,这种流模式提高了IO的性能。
打个比方,从应用程序中把输入放入文件,相当于将一缸水倒入另一个缸中,如果使用FileInputStream
的write()
方法,相当于一滴一滴的把水转移过去。如果使用DataInputStream
中的writeXxx()
方法,相当于一瓢一瓢的把水转移过去。而BufferedInputStream
的write
方法会更方便,相当于一瓢一瓢先放入桶中,再从桶中倒入另一缸中
如下,使用BufferedInputStream
和BufferedOutputStream
创建一个copy文件的方法:
/**
* 进行文件的拷贝,利用带缓冲的字节流
* @param srcFile
* @param destFile
* @throws IOException
*/
public static void copyFileByBuffer(File srcFile, File destFile) throws IOException {
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if (!srcFile.isFile()) {
throw new IllegalArgumentException(srcFile+"不是文件");
}
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
int length;
byte[] b=new byte[1024]; //代表一次最多读取1KB的内容
while ((length = bis.read(b)) != -1) {
bos.write(b, 0, length );
}
bos.flush();//缓冲区的内容写入到文件
bis.close();
bos.close();
}
字符流
认识文本和文本文件
java的文本(char)是16位无符号整数,是字符的unicode编码(双字节编码),而文件是byte byte byte……的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果
在字符流中输出主要是使用Writer
类完成,输入流主要使用Reader
类完成
- 字符的处理,一次处理一个字符
- 字符的底层任然是基本的字节序列
- 操作的是文本文件
InputStreamReader&OutputStreamWriter
InputStreamReader
将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码,该解码过程将使用平台默认的字符编码。
OutputStreamWriter
是作用是字节输出流转换成字符输出流,继承于Writer
基本使用例子,读取一个txt文件,并输出到一个新的txt文件中
InputStreamReader isr = new InputStreamReader(new FileInputStream("demo/copydos.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("demo/copydos_output.txt"), "utf-8");
/*
int c;
while ((c = isr.read()) != -1) {
System.out.println((char)c);
}
*/
//一次读取一个数组
char[] buffer = new char[8*1024];
int c;
//批量读取,返回的是读取字符的个数
while ((c = isr.read(buffer, 0, buffer.length)) != -1) {
String s = new String(buffer,0,c);
System.out.println(s);
osw.write(buffer,0,c);
osw.flush();
}
isr.close();
osw.close();
字符流之文件读写流
内容来自Java IO: FileReader和FileWriter
FileReader
和FileWriter
,与FileInputStream
和FileOutputStream
类似,FileReader
与FileWriter
用于处理文件内容
FileReader
能够以字符流的形式读取文件内容。除了读取的单位不同之外(FileReader
读取字符,FileInputStream
读取字节),FileReader
与FileInputStream
并无太大差异,也就是说,FileReader
用于读取文本。根据不同的编码方案,一个字符可能会相当于一个或者多个字节
FileWriter
能够把数据以字符流的形式写入文件。同样是处理文件,FileWriter
处理字符,FileOutputStream
处理字节。根据不同的编码方案,一个字符可能会相当于一个或者多个字节
基本用法:
FileReader fr = new FileReader(new File("demo/copydos.txt"));
FileWriter fw = new FileWriter("demo/copydos_fw.txt");
char[] buffer = new char[2056];
int c;
while ((c = fr.read(buffer, 0, buffer.length)) != -1) {
fw.write(buffer,0,c);
fw.flush();
}
fr.close();
fw.close();
字符流的过滤器
BufferedReader
由Reader
类扩展而来,提供通用的缓冲方式文本读取,而且提供了很实用的readLine
,读取一个文本行,从字符输入流中读取文本,缓冲各个字符,从而提供字符、数组和行的高效读取。
对应的BufferedWriter
可以一次写一行数据
基本的用法,对文件进行读取写入:
public static void main(String[] args) throws IOException{
//对文件进行读写操作
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("demo/copydos.txt")));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo/copydos_bw.txt")));
String line;
while ((line = br.readLine()) != null) {//一次读一行
System.out.println(line);
//写入
bw.write(line);
bw.newLine();//换行操作
bw.flush();
}
br.close();
bw.close();
}
也可以使用PrintWriter
来代替BufferedWriter
,这样使用起来会简单很多
//对文件进行读写操作
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("demo/copydos.txt")));
//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo/copydos_bw.txt")));
PrintWriter pw = new PrintWriter("demo/copydos_pw.txt");
String line;
while ((line = br.readLine()) != null) {//一次读一行
System.out.println(line);
pw.println(line);
pw.flush();
}
br.close();
pw.close();
对象的序列化和反序列化
对象的序列化将object对象转换成byte序列,反之叫对象的反序列化
类 ObjectInputStream
和 ObjectOutputStream
是高层次的数据流,它们包含序列化和反序列化对象的方法。
其常用方法为writeObject(Object x)
和readObject()
对象必须实现Serializable
接口,才能进行序列化,否则将出现异常
基本用法如下:
Student stu = new Student("1001", "张三", 20);
String file = "demo/obj.dat";
// 对象的序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(stu);
oos.flush();
oos.close();
//对象的反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Student student = (Student)ois.readObject();
System.out.println(student);
transient
属性前添加关键字transient
,序列化对象的时候,这个属性就不会进行jvm默认的序列化,也可以自己完成这个元素的序列化
序列化中子父类构造函数问题
- 如果父类实现了序列化接口,子类就不需要实现序列化接口
- 创建对象的时候,递归调用了父类的构造函数
- 对子类对象进行反序列化操作时,如果其父类没有实现序列化接口,那么其父类的构造函数会被调用,否则不会被调用。
PrintStream
转载自:java io系列16之 PrintStream(打印输出流)详解
PrintStream 是打印输出流,它继承于FilterOutputStream。
PrintStream 是用来装饰其它输出流。它能为其他输出流添加了功能,使它们能够方便地打印各种数据值表示形式。
与其他输出流不同,PrintStream 永远不会抛出 IOException;它产生的IOException会被自身的函数所捕获并设置错误标记, 用户可以通过 checkError()
返回错误标记,从而查看PrintStream内部是否产生了IOException。
另外,PrintStream 提供了自动flush 和 字符集设置功能。所谓自动flush,就是往PrintStream写入的数据会立刻调用flush()函数。
示例代码
关于PrintStream中API的详细用法,参考示例代码(PrintStreamTest.java):
import java.io.PrintStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* PrintStream 的示例程序
*
* @author skywang
*/
public class PrintStreamTest {
public static void main(String[] args) {
// 下面3个函数的作用都是一样:都是将字母“abcde”写入到文件“file.txt”中。
// 任选一个执行即可!
testPrintStreamConstrutor1() ;
//testPrintStreamConstrutor2() ;
//testPrintStreamConstrutor3() ;
// 测试write(), print(), println(), printf()等接口。
testPrintStreamAPIS() ;
}
/**
* PrintStream(OutputStream out) 的测试函数
*
* 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
*/
private static void testPrintStreamConstrutor1() {
// 0x61对应ASCII码的字母'a',0x62对应ASCII码的字母'b', ...
final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 }; // abced
try {
// 创建文件“file.txt”的File对象
File file = new File("file.txt");
// 创建文件对应FileOutputStream
PrintStream out = new PrintStream(
new FileOutputStream(file));
// 将“字节数组arr”全部写入到输出流中
out.write(arr);
// 关闭输出流
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* PrintStream(File file) 的测试函数
*
* 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
*/
private static void testPrintStreamConstrutor2() {
final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 };
try {
File file = new File("file.txt");
PrintStream out = new PrintStream(file);
out.write(arr);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* PrintStream(String fileName) 的测试函数
*
* 函数的作用,就是将字母“abcde”写入到文件“file.txt”中
*/
private static void testPrintStreamConstrutor3() {
final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 };
try {
PrintStream out = new PrintStream("file.txt");
out.write(arr);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 测试write(), print(), println(), printf()等接口。
*/
private static void testPrintStreamAPIS() {
// 0x61对应ASCII码的字母'a',0x62对应ASCII码的字母'b', ...
final byte[] arr={0x61, 0x62, 0x63, 0x64, 0x65 }; // abced
try {
// 创建文件对应FileOutputStream
PrintStream out = new PrintStream("other.txt");
// 将字符串“hello PrintStream”+回车符,写入到输出流中
out.println("hello PrintStream");
// 将0x41写入到输出流中
// 0x41对应ASCII码的字母'A',也就是写入字符'A'
out.write(0x41);
// 将字符串"65"写入到输出流中。
// out.print(0x41); 等价于 out.write(String.valueOf(0x41));
out.print(0x41);
// 将字符'B'追加到输出流中
out.append('B');
// 将"CDE is 5" + 回车 写入到输出流中
String str = "CDE";
int num = 5;
out.printf("%s is %d\n", str, num);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行上面的代码,会在源码所在目录生成两个文件“file.txt”和“other.txt”。
file.txt的内容如下:
abcde
other.txt的内容如下:
hello PrintStream
A65BCDE is 5
补充
字符流与字节流
参考:
在java.io
包中操作文件内容的主要有两大类:字节流、字符流,两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream
完成,输入使用的是InputStream
,在字符流中输出主要是使用Writer
类完成,输入流主要使用Reader
类完成。(这四个都是抽象类)
字符流
在程序中一个字符等于两个字节,那么java提供了Reader
、Writer
两个专门操作字符流的类。
字符输出流:Writer
Writer
本身是一个字符流的输出类,此类的定义如下:
public abstract class Writer extends Object implements Appendable,Closeable,Flushable
此类本身也是一个抽象类,如果要使用此类,则肯定要使用其子类,此时如果是向文件中写入内容,所以应该使用FileWriter
的子类。
FileWriter
类的构造方法定义如下:
public FileWriter(File file)throws IOException
字符流的操作比字节流操作好在一点,就是可以直接输出字符串了,不用再像之前那样进行转换操作了。
写文件:
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Test16 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Writer out=new FileWriter(f);
String str="Hello World";
out.write(str);
out.close();
}
}
字符输入流:Reader
Reader
是使用字符的方式从文件中取出数据,Reader类的定义如下:
public abstract class Reader extends Objects implements Readable,Closeable
Reader
本身也是抽象类,如果现在要从文件中读取内容,则可以直接使用FileReader
子类。
FileReader
的构造方法定义如下:
public FileReader(File file)throws FileNotFoundException
以字符数组的形式读取出数据:
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Test18 {
public static void main(String[] args) throws IOException {
File f = new File("d:" + File.separator+"test.txt");
Reader input=new FileReader(f);
char[] c=new char[1024];
int len=input.read(c);
input.close();
System.out.println(new String(c,0,len));
}
}
字节流与字符流的区别
字节流和字符流使用是非常相似的,那么除了操作代码的不同之外,还有哪些不同呢?
字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的
字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不close的情况下输出内容