java IO

字节流的抽象基类：

•InputStream ，OutputStream。

字符流的抽象基类：

•Reader ，Writer。

注：由这四个类派生出来的子类名称都是 以其父类名作为子类名的后缀。

•如：InputStream的子类FileInputStream。

•如：Reader的子类FileReader。

1：导入IO包中的类

2：进行IO异常处理

3：在finally中对流进行关闭

创建流对象，建立数据存放文件

•FileWriter fw = new FileWriter(“Test.txt”);

调用流对象的写入方法，将数据写入流

•fw.write(“text”);

关闭流资源，并将流中的数据清空到文件中。

•fw.close();

FileWriter fw = null;
try{
fw = new FileWriter("Test.txt");
fw.write("text");
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
If(fw!=null)
try{
fw.close();
}
catch (IOException e){
System.out.println(e.toString());
}
}

5: 字符流——读取文件

建立一个流对象，将已存在的一个文件加载进 流。

•FileReader fr = new FileReader(“Test.txt”);

创建一个临时存放数据的数组。

•char[] ch = new char[1024];

调用流对象的读取方法将流中的数据读入到数组 中。

•fr.read(ch);

FileReader fr = null;
try{
fr = new FileReader("c:\test.txt");
char[] buf = new char[1024];
int len= 0;
while((len=fr.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
}
catch (IOException e){
System.out.println("read-Exception :"+e.toString());
}
finally{
if(fr!=null){
try{
fr.close();
}
catch (IOException e){
System.out.println("close-Exception :"+e.toString());
}

定义文件路径时，可以用“/”或者“\”。

在创建一个文件时，如果目录下有同名文 件将被覆盖。

在读取文件时，必须保证该文件已存在， 否则出异常。

缓冲区的出现提高了对数据的读写效率。

对应类

•BufferedWriter

•BufferedReader

缓冲区要结合流才可以使用。

在流的基础上对流的功能进行了增强

                     基本操作与字符流类相同

                    但它不仅可以操作字符，还可以操作其他 媒体文件

例程

•Copy一个Jpg文件

同样是提高了字节流的读写效率。

InputStreamReader,OutputStreamWriter

转换流的由来

•字符流与字节流之间的桥梁

•方便了字符流与字节流之间的操作

转换流的应用

•字节流中的数据都是字符时，转成字符流操作 更高效。

例程：标准输入输出。

System类中的字段：in，out。

它们各代表了系统标准的输入和输出设备。

默认输入设备是键盘，输出设备是显示器。

System.in的类型是InputStream.

System.out的类型是PrintStream是 OutputStream的子类FilterOutputStream 的子 类.


例:获取键盘录入数据，然后将数据流向显示器，那么显示器就是目 的地。

通过System类的setIn，setOut方法对默认设备进行改变。
•
System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。
•
System.setOut(new FileOutputStream(“2.txt”));//将目的改成文件2.txt

因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。

BfferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw =
new BufferedWriter(new OutputStreamWriter(System.out));

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作 。

File对象可以作为参数传递给流的构造函 数。

了解File类中的常用方法。


RandomAccessFile
随机访问文件，自身具备读写的方法。
通过skipBytes(int x),seek(int x)来达到随机访 问。
管道流
PipedInputStream和PipedOutputStream
输入输出可以直接进行连接，通过结合线程使用

打印流
PrintWriter与PrintStream
可以直接操作输入流和文件。
序列流
SequenceInputStream
对多个流进行合并。
操作对象
ObjectInputStream与ObjectOutputStream
被操作的对象需要实现Serializable （标记接口);

操作基本数据类型
DataInputStream与DataOutputStream
操作字节数组
ByteArrayInputStream与ByteArrayOutputStream
操作字符数组
CharArrayReader与CharArrayWrite
操作字符串
StringReader 与StringWriter

字符流的出现为了方便操作字符。
更重要是的加入了编码转换。
通过子类转换流来完成。
InputStreamReader
OutputStreamWriter
在两个对象进行构造的时候可以加入字符 集。

ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符 号。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符。

public class FileUtils {
// 删除文件夹下所有文件
public static void deleteFiles(File rootFile) {
if (rootFile.listFiles().length == 0) {// 如果用户给定的是空文件夹就退出方法
return;
} else {
File[] files = rootFile.listFiles();// 将非空文件夹转换成File数组
for (File file : files) {
if (file.isFile()) {
file.delete();// 删除指定文件夹下的所有文件
} else {
if (file.listFiles().length == 0) {
file.delete();// 删除指定文件夹下的所有空文件夹
} else {
deleteDirectories(file);// 删除指定文件夹下的所有非空文件夹
}
}
}
}
}
// 删除文件夹及文件夹下所有文件
public static void deleteDirectories(File rootFile) {
if (rootFile.isFile()) {
rootFile.delete();// 如果给定的File对象是文件就直接删除
} else {// 如果是一个文件夹就将其转换成File数组
File[] files = rootFile.listFiles();
for (File file : files) {
deleteDirectories(file);// 如果不是空文件夹则就迭代deleteDictionary()方法
}
rootFile.delete();// 如果是空文件夹就直接删除
}
}
// 获得指定目录下的所有文件的路径
public static List<String> getFilePath(List<String> list, File rootFile) {
File[] files = rootFile.listFiles();
for (File file : files) {
if (file.isDirectory()) {
getFilePath(list, file);
} else {
list.add(file.getAbsolutePath().replace("\", File.separator));
}
}
return list;
}
}

package com.cdd.util;
import java.io.*;
public class Employ {
public static void main(String args[]) {
File file = new File("Example8.txt");
try {
if (!file.exists())
// 如果文件不存在
file.createNewFile();
// 创建新文件
InputStreamReader isr = new InputStreamReader(System.in);
//定义输入流对象
BufferedReader br = new BufferedReader(isr);
System.out.println("请输入：");
String str = br.readLine();
//读取用户输入的信息
System.out.println("您输入的内容是：" + str);
FileWriter fos = new FileWriter(file, true);
// 创建文件输出流
BufferedWriter bw = new BufferedWriter(fos);
bw.write(str);
//向文件写入信息
br.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}

package com.cdd.util;
import java.io.*;
public class ReadFile {
public static void main(String args[]){
int bytes[]={1,2,3,4,5};
//定义写入文件的数组
try {
//创建RandomAccessFile类的对象
File file = new File("Example9.txt");
if(!file.exists()){
//判断该文件是否存在
file.createNewFile();
//新建文件
}
RandomAccessFile raf=new RandomAccessFile(file,"rw");
//定义RandomAccessFile对象
for(int i=0;i<bytes.length;i++){
//循环遍历数组
raf.writeInt(bytes[i]);
//将数组写入文件
}
System.out.println("逆序输出信息");
for(int i=bytes.length-1;i>=0;i--){
//反向遍历数组
raf.seek(i*4);
//int型数据占4个字节
System.out.println(+raf.readInt());
}
raf.close();
//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
}

import java.io.*;
import java.util.*;
public class UniteFile {
byte b1[];
FileInputStream fi1;
FileOutputStream fo;
public void writeFiles(List<File>
files, String fileName) {
try {
fo = new FileOutputStream(fileName, true);
//根据文件保存地址创建FileOutputStream对象
for (int i = 0; i < files.size(); i++) {
//循环遍历要复制的文件集合
File file =
files.get(i);
//获取集合中文件对象
fi1 = new FileInputStream(file);
//创建FileInputStream对象
b1 = new byte[fi1.available()];
//从流中获取字节数
fi1.read(b1);
//读取数据
fo.write(b1);
//向文件中写数据
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

package com.cdd.encrypt;
import java.io.*;
import java.nio.channels.FileLock;
class EncryptInput {
public static void fileLock(String file) {
FileOutputStream fous = null; // 创建FileOutputStream对象
FileLock lock = null; // 创建FileLock对象
try {
fous = new FileOutputStream(file); // 实例化FileOutputStream对象
lock = fous.getChannel().tryLock(); // 获取文件锁定
Thread.sleep(60 * 1000); // 线程锁定1分钟
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String file = "C://count.txt"; // 创建文件对象
fileLock(file); // 调用文件锁定方法
}
}

------------- android培训、java培训、java博客、java学习型技术博客、期待与您交流！ -------------

详情请查看：http://edu.csdn.net/heima/

最后

以上就是饱满盼望为你收集整理的java IO的全部内容，希望文章能够帮你解决java IO所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。