Java的IO操作

最新推荐文章于 2024-04-27 17:30:34 发布

qidiantianxia

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量132

点赞数

文章标签： java IO

1.IO简介

IO I/O,即输入与输出

作用：读写设备上的数据

根据数据的走向，可分为：输入流和输出流

根据处理的数据类型，可分为：字节流和字符流

字节流：可以读取任意类型的数据，如视频、图片，读取时，读到一个字符就返回一个字符；在Java中对应的类以Stream结尾。

字符流：仅能处理纯文本数据，如txt文本，在读取时，读到一个或多个字节，先找到对应的编码表，然后将查到的字符返回；在Java中对应的类以Reader 和Writer为结尾。

2.字符、字节和编码

字节byte：是通过网络传输信息或在硬盘或内存中存储信息的单位，是计算机信息技术计算存储容量或传输容量的一种计量单位

1个字节等于8位二进制，即一个8位的二进制数，是一个具体的存储空间，如0xFA。

字符char：人们使用的记号，抽象意义上的符号，如 1，中，￥。

字符集Charset:字符集也称作编码，各个国家和地区所制定的不同的ANSI编码标准中，都只规定各自语言所需的字符，比如汉字标准（GB2312）；

ANSI编码所规定的内容包含两层含义：

使用那些字符，也就是说哪些汉字、字母、字符会收入标准中，所包含字符的集合位“字符集”；

规定每个字符用一个字节还是多个字节存储，用哪些字节存储，这个规定叫做“编码”。

ANSI:字符串在内存中，如果字符是以ANSI编码形式存在的，一个字符可以使用一个字节或多个字节来表示，称这种字符串位ANSI字符串或者多字节字符串，不同ANSI编码规定的标准是不同的，因此，在一个给定的字符串，我们必须先确定它采用的是哪种编码规则，我们才能知道它包含了哪些字符。

UNICODE：字符串如果在内存中，是以UNICODE的序号存在的，我们称这种字符串位UNICODE字符串或宽字符串，这种字符串，不管在什么环境下，它所代表的字符内容总是不变的，UNICODE的字符集编码的标准有很多种，如UTF-8

3.使用字节流读写数据

ReadByteStream.java字节流读取文件

package com.jike.iobybyte;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ReadByteStream {

public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("test1.txt");
byte bytes[] = new byte[20];
fis.read(bytes);

String inputString = new String(bytes);
System.out.println(inputString);

fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

}

WriteByteStream.java字节流写入文件

package com.jike.iobybyte;

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

public class WriteByteStream {

public static void main(String[] args) {

try {
FileOutputStream fos = new FileOutputStream("test2.txt");
String outString = "write by byte";
byte bytes[] = outString.getBytes("UTF-8");

fos.write(bytes);
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

}

CopyByStream.java 文件拷贝

package com.jike.iobybyte;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyByStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("test1.txt");
FileOutputStream fos = new FileOutputStream("test1_copy.txt");

byte bytes[] = new byte[50];
while (fis.read(bytes) != -1) {
fos.write(bytes);
}
fis.close();
fos.close();
System.out.println("done");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

4.使用带缓冲的字节流读写数据

package com.jike.iobybyte;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyByBufferStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("movie.mp4");
BufferedInputStream bis = new BufferedInputStream(fis,100000);
FileOutputStream fos = new FileOutputStream("movie_copy.mp4");
BufferedOutputStream bos = new BufferedOutputStream(fos,100000);

int count = 0;
long before = System.currentTimeMillis();
//大型文件对应的数组可以大一些，小文件对应的数组小一些
byte bytes[] = new byte[10000];
while (bis.read(bytes) != -1) {
bos.write(bytes);
count++;
}
bos.close();
fos.close();
bis.close();
fis.close();
System.out.println("耗时" + (System.currentTimeMillis() - before) + "ms");
System.out.println("读取了" + count + "次");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

5.使用字符流读写数据

package com.jike.iobychar;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class ReadCharStream {
public static void main(String[] args) {
try {
// File file = new File("test1.txt");
FileInputStream fis = new FileInputStream("test1.txt");
InputStreamReader isr = new InputStreamReader(fis);
FileOutputStream fos = new FileOutputStream("test1_copy.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);

int l = 0;// 避免冗余
char chars[] = new char[100];
while ((l = isr.read(chars)) != -1) {
// System.out.println(new String(chars, 0, l));
osw.write(chars, 0, l);
}

isr.close();
fis.close();
osw.close();
fos.close();

System.out.println("done");

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

6.使用带缓冲的字符流读写数据

package com.jike.iobychar;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

public class CopyByBufferedCharStream {
public static void main(String[] args) {
try {
// File file = new File("test1.txt");
FileInputStream fis = new FileInputStream("test1.txt");
InputStreamReader isr = new InputStreamReader(fis);
FileOutputStream fos = new FileOutputStream("test1_copy.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);

BufferedReader br = new BufferedReader(isr);
// BufferedRead虽然读取的是一行数据，但是返回数据中并不包含换行符,在写入的时候，只能写入真是内容，换行符会被丢掉
// BufferedWriter bw = new BufferedWriter(osw);
/*写出的数据还没有填满缓冲区，PrintWriter里面的内容是不会写出文件里面去的，这种情况，会造成写出文件的内容的丢失或者文件内容的不完整，
在clone之前需要调用flush方法，将之前的缓冲区的内容强制输出,保证缓冲区文件的文件的完整性*/
PrintWriter pw = new PrintWriter(osw, true);

String str = null;
while ((str = br.readLine()) != null) {
// bw.write(str);
pw.println(str);
}

/*
* bw.flush(); bw.close();
*/
pw.close();
br.close();
isr.close();
fis.close();
osw.close();
fos.close();

System.out.println("done");

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

7.FileReader与FileWriter

package com.jike.iobyfile;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyByFileReaderWriter {
public static void main(String[] args) {
try {
FileReader fr = new FileReader("test1.txt");
BufferedReader br = new BufferedReader(fr);

FileWriter fw = new FileWriter("test1_copy.txt");
BufferedWriter bw = new BufferedWriter(fw);

String line = null;
while ((line = br.readLine()) != null) {
bw.write(line + "\n");
}

bw.flush();
bw.close();
fw.close();
br.close();
fr.close();
System.out.println("done");

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

8.RandomAccessFile随机文件读写，可以读写文件的任意位置，一般用于多线程读写操作

MultiWriterFile.java

package com.jike.randomaccessfile;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class MultiWriterFile {

static File file = new File("testRand.txt");

public static void main(String[] args) {
/*
* if (file.exists()) { file.delete(); }
*
* new WriterFile(file, 1).start(); new WriterFile(file, 2).start(); new
* WriterFile(file, 3).start(); new WriterFile(file, 4).start(); new
* WriterFile(file, 5).start();
*
* System.out.println("done");
*/

try {
RandomAccessFile raf = new RandomAccessFile(file, "r");
raf.seek(300);
byte bytes[] = new byte[100];
raf.read(bytes);
String str = new String(bytes);
System.out.println(str);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

WriterFile.java

package com.jike.randomaccessfile;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class WriterFile extends Thread {

File file;
int block;
int len = 100;

public WriterFile(File file, int block) {
this.file = file;
this.block = block;
}

@Override
public void run() {

try {
RandomAccessFile raf = new RandomAccessFile(file, "rw");
raf.seek((block - 1) * len);
raf.writeBytes("this is block " + block + "\n");

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

9.使用Apache IO库操作IO与文件

pom.xml

<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.6</version>

</dependency>

ApacheIOUtils.java

package com.jike.apacheio;

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

import org.apache.commons.io.FileUtils;

public class ApacheIOUtils {
public static void main(String[] args) {
try {
File file = new File("test1.txt");
File file2 = new File("test1_copy.txt");

FileUtils.copyFile(file, file2);

/*
* String str = FileUtils.readFileToString(file);
* System.out.println(str);
*/

System.out.println("done");
} catch (IOException e) {
e.printStackTrace();
}
}
}

qidiantianxia

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java的IO操作

1.IO简介IO I/O,即输入与输出作用：读写设备上的数据根据数据的走向，可分为：输入流和输出流根据处理的数据类型，可分为：字节流和字符流字节流：可以读取任意类型的数据，如视频、图片，读取时，读到一个字符就返回一个字符；在Java中对应的类以Stream结尾。字符流：仅能处理纯文本数据，如txt文本，在读取时，读到一个或多个字节，先找到对应的编码表，然后将查到的字符返回；在Java中对应的类以R...
复制链接

扫一扫