原文摘自:

http://www.blogjava.net/haizhige/archive/2008/08/03/219668.html

1、描述:流是字节数据或字符数据序列。

  Java采用输入流对象和输出流对象来支持程序对数据的输入和输出。输入流对象提供了数据从源点流向程序的管道,程序可以从输入流对象读取数据;输出流对象提供了数据从程序流向终点的管道,程序通过该管道把数据写到终点。所有的关于输入/输出的类都包含在java.io的包中。
2、File类:它主要关心的是文件的具体属性,而非内容,定义了许多方法,实现对文件的创建、删除等操作。

import java.io.*;

public class Test {
public static void main(String[] args) throws Exception {
File file1 = new File("w1.txt"); //在当前目录下
file1.createNewFile(); //得到文件w1.txt
file1.mkdir(); //得到目录w1.txt File file2 = new File("D:\\javaprogram\\text\\w2.txt"); //指定目录
file2.createNewFile(); //得到文件w2.txt
//用静态字段separator获得系统分隔符,保证程序通用性 File fDir = new File(File.separator); //作为字符是'\',作为File对象为当前根目录
String fStr = "javaprogram" + File.separator + "text" + File.separator +
"w3.txt";
File file3 = new File(fDir, fStr);
file3.createNewFile(); //得到文件w3.txt
file1.delete();
file2.delete();
file3.delete(); //delete()方法删除文件,调用即删除,而deleteOnExit()是在JVM终止时才删除
//这样就得以建立临时文件以存储临时数据,临时文件保存在临时文件夹
//要找临时文件夹,请查看环境变量temp的设置
for (int i = 0; i < 5; i++) {
File file = File.createTempFile("wang", ".temp");
file.deleteOnExit();
} Thread.sleep(3000); //下面的一段程序将实现,打印指定目录下的.java文件的信息
File f = new File("d:\\javaprogram"); if (f.exists()) //判断文件是否存在
{
if (f.isDirectory()) //判断文件是目录还是标准文件
{
//调用带参数的listFiles()方法返回满足特定过虑器的
//此抽象路径名所表示目录中的文件和目录的抽象路径名数组
File[] fname = f.listFiles(new FilenameFilter() {
//匿名类实现接口FilenameFileter的唯一方法
public boolean accept(File dir, String name) {
return name.indexOf(".java") != -1;
}
}); for (int i = 0; i < fname.length; i++) {
System.out.println(fname[i]);
}
}
} else {
System.out.println("文件夹不存在.");
}
}
}

3、字节流:
  程序运行中常的I/O操作包括向标准设备输入输出数据和文件输入输出。对于前者,java定义了三个直接使用的流对象:System.err(标准错误输出)、System.out(标准输出)和System.in(标准输入);对于后者,可以使用FileOutputStream和FileInputStream。

import java.io.*;

public class Test {
static final String file1 = "D:\\javaprogram\\w1.txt";
static final String file2 = "E:\\database\\w2.txt";
static final String file3 = "E:\\wmpub\\w3.txt"; public static void main(String[] args) throws IOException {
/*//关于System.in
int data;
while ((data=System.in.read())!=-1)//Ctrl+c结束输入
{
System.out.write(data);
}*/ //下面的程序段用以向file1文件写入,把其内容的一部分复制到file2
//再把file2文件完整地复制到file3,并打印出来
FileOutputStream fos1 = new FileOutputStream(file1);
FileOutputStream fos2 = new FileOutputStream(file2);
FileOutputStream fos3 = new FileOutputStream(file3);
fos1.write("今天是2008年8月3号,离北京奥运会还有5天,心里非常激动啊.".getBytes());
fos1.close(); FileInputStream fis1 = new FileInputStream(file1);
fis1.skip(19); //跳过19个字节 byte[] buf = new byte[fis1.available()];
fis1.read(buf);
fis1.close();
System.out.println(new String(buf));
fos2.write(buf);
fos2.close(); FileInputStream fis2 = new FileInputStream(file2); while (fis2.available() > 0) {
byte[] b = new byte[fis2.available()];
int let = fis2.read(b); if (let == -1) {
break;
} fos3.write(b, 0, let);
} System.out.println("复制成功!");
fis2.close();
fos3.close(); //以下程序段实现了一个图像文件的复制
FileInputStream a = new FileInputStream("4.jpg");
FileOutputStream b = new FileOutputStream("3.jpg");
byte[] c = new byte[a.available()];
a.read(c);
b.write(c);
a.close();
b.close();
}
}

4、字符流(FileWriter and FileReader)

import java.io.*;

public class Test {
public static void main(String[] args) {
//本程序完成从控制台读入文件名,并实现复制
int length;
char[] buf = new char[100]; try {
FileReader in = new FileReader(args[0]);
FileWriter out = new FileWriter(args[1]);
length = in.read(buf); while (length != -1) {
out.write(buf, 0, length);
//字符流读取通过read()的返回值判断是否读到文件末尾
//我刚才忘记加这条语句,文件被一直写,都死机了,重启后一看,写了2.6G
length = in.read(buf);
} in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

5、过滤流之一
  Java利用过滤流可以在读写数据的同时对数据进行处理,以达到性能的改善,提高程序执行效率。将过滤流和某个输入流或输出流(节点流)连接。连接是通过在过滤流的构造方法中指定入口参数——节点流来实现的。

     §BufferedInputStream:
FileInputStream fis=new FileInputStream("w1.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
byte[] buf=new byte[100];
int len=bis.read(buf,0,len);
System.out.println(new String(buf,0,len));
bis.close();
§BufferedOutputStream:
FileOutStream fos=new FileOutputStream("w2.txt");
BufferedOutputStream bos=new BufferedOutputStream(bos);
bos.write("好好学习,天天向上".getBytes());
bos.flush();
bos.close();

  也可以是匿名创建:如:BufferedOutputStream bos=new BufferedOutputStream(new FileInputStream("w2.txt")); 
  BufferedReader和BufferedWirter与此类似,不过是分别指定WriterReader类型的参数罢了。

  一个实例程序:

import java.io.*;

public class Test {
public static void main(String[] args) {
try {
FileInputStream in = new FileInputStream(args[0]);
BufferedInputStream bufIn = new BufferedInputStream(in);
int limit;
bufIn.mark(limit = bufIn.available()); //在当前位置打上标记 for (int i = 0; i < limit; i++)
System.out.print((char) (bufIn.read())); System.out.println();
bufIn.reset(); //reset缓冲区标志 int c; while ((c = bufIn.read()) >= 0)
System.out.print((char) c); bufIn.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

5、过滤流之二基本类型数据传输:DataInputStream和DataOutputStream

import java.io.*;

public class Test {
public static void main(String[] args) {
try {
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(
new FileOutputStream("d://javaprogram//w.txt")));
dos.writeInt(5);
dos.writeUTF("你好");
dos.writeBoolean(true);
dos.writeDouble(3.1415926);
dos.writeBytes("ok!");
dos.writeChars("bye bye");
dos.close(); DataInputStream dis = new DataInputStream(new BufferedInputStream(
new FileInputStream("d://javaprogram//w.txt")));
//读出的顺序应与写入的顺序一致
System.out.println(dis.readInt());
System.out.println(dis.readUTF());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble()); byte[] b = new byte[3];
dis.readFully(b); for (int j = 0; j < 3; j++)
System.out.print((char) b[j]); System.out.println(); StringBuffer st3 = new StringBuffer(); for (int j = 0; j < 7; j++)
st3.append(dis.readChar()); System.out.println(st3.toString());
dis.close();
} catch (IOException e) {
System.err.println(e.toString());
}
}
}

6、过滤流之三:I/O流的链接图:

7、字节和Unicode字符的桥梁:InputStreamReader、OutputStreamWriter

import java.io.*;

public class Test {
public static void main(String[] args) throws IOException {
//文件读写
FileOutputStream fos = new FileOutputStream("w.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
BufferedWriter bw = new BufferedWriter(osw);
bw.write("今天是2008年8月3日,离北京奥运还有5天!");
bw.close(); FileInputStream fis = new FileInputStream("w.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
System.out.println(br.readLine());
br.close(); //控制台读写
BufferedReader br1 = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw1 = new BufferedWriter(new OutputStreamWriter(
System.out));
String strLine;
String str = ""; while ((strLine = br1.readLine()) != null) //Ctrl+c结束输入
{
str += strLine;
System.out.println(strLine);
} br1.close();
bw1.write(str, 0, str.length());
bw1.write((int) ('\n')); //将回车符输入bw1
bw1.flush();
bw1.close();
}
}

8、管道流:PipedInputStream、PipedOutputStream

  作用:用于线程间的通信,一个线程的pipedInputStream对象从另一个线程的PipedOutputStream对象读取输入,要使管道流有用,必须同时构造管道输入流和管道输出流。
  例子(孙鑫老师的例子):

import java.io.*;

class Producer extends Thread {
private PipedOutputStream pos; public Producer(PipedOutputStream pos) {
this.pos = pos;
} public void run() {
try {
pos.write("Hello,welcome you!".getBytes());
} catch (Exception e) {
e.printStackTrace();
}
}
} class Consumer extends Thread {
private PipedInputStream pis; public Consumer(PipedInputStream pis) {
this.pis = pis;
} public void run() {
try {
byte[] buf = new byte[100];
int len = pis.read(buf);
System.out.println(new String(buf, 0, len));
pis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
} public class Test {
public static void main(String[] args) {
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream(); try {
pos.connect(pis);
new Producer(pos).start();
new Consumer(pis).start();
} catch (Exception e) {
e.printStackTrace();
}
}
}

9、PrintWriter类:创建的输出流可以使用print和println方法,按Unicode字符形式输出,输出的数据可读性较好。

        §打印流建立文本文件:
PrintWriter out=new PrintWriter(new FileWriter(1.dat));
String str="天呢,我告诉你吧:";
char[] z={'北','京','奥','运','会','在'};double g=2008;
out.println(st);out.print(z);out.print(g);out.println("年08月08日08时08分08秒");
out.close();
§打印流在屏幕上显示文本
PrintWriter out=new PrintWriter(System.out);
其余同上,此处略

10、文件的随机读写:RandomAccessFile

import java.io.*;

public class Test {
public static void main(String[] args) throws Exception {
int lineNo; //读到的行号
long fp; //文件指针
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
RandomAccessFile raf = new RandomAccessFile("w.txt", "rw");
System.out.println("请输入6个字符串"); int[] len = new int[12];
String[] str = new String[12]; for (int i = 0; i < 6; i++) {
System.out.println("行号" + (i + 1) + ":");
str[i] = br.readLine();
len[i] = str[i].length();
raf.write((str[i] + "\n").getBytes());
} while (true) {
fp = 0;
raf.seek(0);
System.out.println("你要显示第几行?" + "(1--6)");
lineNo = Integer.parseInt(br.readLine()); for (int i = 1; i < lineNo; i++)
fp = fp + (long) len[i - 1] + 1; raf.seek(fp);
System.out.println("第" + lineNo + "行" + ":" + raf.readLine());
System.out.println("继续吗?" + "(y/n)"); if ((br.readLine().equals("n"))) {
break;
}
} raf.seek(raf.length());
System.out.println("继续写入6行数据:"); for (int i = 6; i < 12; i++) {
System.out.println("行号" + (i + 1) + ":");
str[i] = br.readLine();
len[i] = str[i].length();
raf.write((str[i] + "\n").getBytes());
} System.out.println("打印12行数据:");
raf.seek(0); for (long i = 0; i < raf.length(); i = raf.getFilePointer()) {
System.out.println(raf.readLine());
} raf.close();
}
}

11、文件的压缩处理

  实例:

import java.io.*;

import java.util.*;

//ZipInputStream和ZipOutputStream在包java.util.zip中
import java.util.zip.*; public class Test {
public static void main(String[] args) throws Exception {
//输入若干文件名,将所有文件压缩为w.zip
ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(
new FileOutputStream("w.zip"))); for (int i = 0; i < args.length; i++) {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
args[i]));
//将每个要压缩的文件称为一个压缩入口,使用ZipEntry生成压缩入口对象
//使用putNextEntry(ZipEntry entry)将压缩入口加入到压缩文件
zos.putNextEntry(new ZipEntry(args[i])); int b; while ((b = bis.read()) != -1)
zos.write(b); bis.close();
} zos.close(); //解压缩文件并显示
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(
new FileInputStream("w.zip")));
ZipEntry z; while ((z = zis.getNextEntry()) != null) //获得入口
{
System.out.println(z.getName()); //显示文件初始名 int x; while ((x = zis.read()) != -1)
System.out.write(x); System.out.println();
} zis.close();
}
}

12、编码与解码

import java.nio.charset.*;

import java.util.*;

public class Test {
public static void main(String[] args) throws Exception {
//以下程序段打印当前计算机所能处理的标准 charset
//Charset类位于java.nio.charset包中,此类定义了用于创建解码器和编码器
//以及检索与 charset 关联的各种名称的方法。此类的实例是不可变的。
//Charset.availableCharsets()返回一个映射
//Map是java.util包中的一个接口
Map m = Charset.availableCharsets(); //keySet()方法返回此映射中包含的键的 set 视图
Set names = m.keySet(); //构造迭代器访问诸元素
Iterator it = names.iterator(); while (it.hasNext()) {
System.out.println(it.next());
} //Properties 类位于java.util包中,表示了一个持久的属性集
//System.getProperties()确定当前的系统属性。
Properties pps = System.getProperties();
pps.list(System.out); //打印属性
//将系统文件的标准字符集改为:ISO-8859-1
//设置的字符集,只是当前JVM上的字符集 pps.put("file.encoding", "ISO-8859-1"); int data;
byte[] buf = new byte[100];
int i = 0; while ((data = System.in.read()) != 'q') {
buf[i] = (byte) data;
i++;
} String str = new String(buf, 0, 1);
System.out.println(str); //ISO-8859-1字符解码为Unicode字符(java使用)
//Unicode字符编码为GBK字符
//但并不是所有字符都能反编码回来,比如汉字将丢失高字节
String strGBK = new String(str.getBytes("ISO-8859-1"), "GBK");
System.out.println(strGBK);
}
}

13、对象序列化

  对象的寿命常随着对象的程序的终止而终止,倘若需要对对象的状态进行保存,需要时再恢复。我们把对象的这种能够记录自己状态以便将来再生的能力,叫做对象的持续性(persistence)。对象通过写出描述自己状态的值——对象转化为字节流,来记录自己的这个过程叫对象的序列化(serialization)。  一个对象要能够实现序列化,必须实现Serializable接口,或者Externalizable接口。 
  一个对象被序列化时,只保存对象的非静态成员变量,如果一个对象的成员变量是一个对象,那么这个对象的数据成员也会被保存。如果一个可序列化的对象包含对某个不可序列化的对象的引用,那么整个序列化操作将会失败,并且会抛出一个NotSerializableException。但如果把这个引用标记为transient,那么对象仍然可以序列化。
  另外,对象序列化建立了一张对象网,将当前要序列化的对象中所持有的引用指向的对象都包含起来一起写入到文件,如果一次序列化几个对象,它们中的相同内容会被共享。

import java.io.*;

public class Test {
public static void main(String[] args) throws Exception {
Employee e1 = new Employee("zhangsan", 25, 3000.50);
Employee e2 = new Employee("lisi", 24, 3200.40);
Employee e3 = new Employee("wangwu", 27, 3800.55);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"w.dat"));
oos.writeObject(e1);
oos.writeObject(e2);
oos.writeObject(e3);
oos.close(); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"w.dat"));
Employee e;
String strSal; for (int i = 0; i < 3; i++) {
e = (Employee) ois.readObject();
//设置自已需要的输出方式
//strSal=(e.salary==0)?"不告诉你":String.valueOf(e.salary);
//System.out.println(e.name+":"+e.age+":"+strSal);
System.out.println(e.name + ":" + e.age + ":" + e.salary);
} ois.close();
}
} class Employee implements Serializable {
String name;
int age;
transient double salary;
transient Thread t = new Thread(); public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
} //重写方法,完成需要的操作,如果不重写,要想不写入某些数据可以标记为transient
//本程序的数据salary就被标记为transient,打印时输出为0.0,如果是String将为null
/*private void writeObject(java.io.ObjectOutputStream oos)throws IOException
{
oos.writeUTF(name);
oos.writeInt(age);
//System.out.println("Write Object");
}
private void readObject(java.io.ObjectInputStream ois)throws IOException
{
name=ois.readUTF();
age=ois.readInt();
//System.out.println("Read Object");
}*/
}

(转载)java基础:关于java流与文件操作的更多相关文章

  1. Java基础 使用转换流进行文件的复制 / RandomAccessFile 类进行文件的复制

    笔记:  **使用转换流进行文件的复制 文本文件---字节流FileInputStream--> [InputStreamReader] -----字符流BufferedReader------ ...

  2. java基础之IO流(二)之字符流

    java基础之IO流(二)之字符流 字符流,顾名思义,它是以字符为数据处理单元的流对象,那么字符流和字节流之间的关系又是如何呢? 字符流可以理解为是字节流+字符编码集额一种封装与抽象,专门设计用来读写 ...

  3. Java基础之IO流整理

    Java基础之IO流 Java IO流使用装饰器设计模式,因此如果不能理清其中的关系的话很容易把各种流搞混,此文将简单的几个流进行梳理,后序遇见新的流会继续更新(本文下方还附有xmind文件链接) 抽 ...

  4. JAVA通过I/O流复制文件

    JAVA通过I/O流复制文件 本文是对字节流操作,可以多音频视频文件进行操作,亲测有效. 个人感觉这个东西就是靠记的, 没什么好解释的,,,, import java.io.File; import ...

  5. java基础之IO流(一)字节流

    java基础之IO流(一)之字节流 IO流体系太大,涉及到的各种流对象,我觉得很有必要总结一下. 那什么是IO流,IO代表Input.Output,而流就是原始数据源与目标媒介的数据传输的一种抽象.典 ...

  6. Java基础复习笔记系列 七 IO操作

    Java基础复习笔记系列之 IO操作 我们说的出入,都是站在程序的角度来说的.FileInputStream是读入数据.?????? 1.流是什么东西? 这章的理解的关键是:形象思维.一个管道插入了一 ...

  7. Java基础技术-Java其他主题【面试】

    Java基础技术-Java其他主题[面试] Java基础技术IO与队列 Java BIO.NIO.AIO Java 中 BIO.NIO.AIO 的区别是什么? 含义不同: BIO(Blocking I ...

  8. 黑马程序员:Java基础总结----java注解

    黑马程序员:Java基础总结 java注解   ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! java注解 lang包中的基本注解 @SuppressWarnings ...

  9. java基础-学java util类库总结

    JAVA基础 Util包介绍 学Java基础的工具类库java.util包.在这个包中,Java提供了一些实用的方法和数据结构.本章介绍Java的实用工具类库java.util包.在这个包中,Java ...

  10. Java基础-使用JAVA代码剖析MD5算法实现过程

    Java基础-使用JAVA代码剖析MD5算法实现过程 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.

随机推荐

  1. 017 多对多关联映射 双向(many-to-many)

    多对多关联映射 双向 两方都持有对象引用,修改对象模型,但数据的存储没有变化. 再修改映射文件: public class Role { private int id; private String ...

  2. 为女票写的计算工作时间的SQL

    排除非工作时间.非工作日后,计算工作时间,代码如下: -- 删除函数 DROP FUNCTION IF EXISTS calculateWorkingTime; set @workStartTime= ...

  3. 细说Linux权限

    目录: 归属权与访问权 chmod:访问权限设置 chown:所属权限设置 umask:权限掩码 隐藏属性 chattr:写保护.误删保护 单独限权 setfacl 一.归属和访问权限简介 1.归属( ...

  4. RedHat7上安装MySQL5.7.16

    1.查看系统中是否已将安装MySQL,如果安装了,需要卸载. [root@chenguo etc]# rpm -qa|grep -i mysql 2.创建用户和组 [root@chenguo ~]# ...

  5. LCA——求解最近公共祖先

    LCA 在有根树中,两个节点 u 和 v 的公共祖先中距离最近的那个被称为最近公共祖先(LCA,Lowest Common Ancestor). 有多种算法解决 LCA 或相关的问题. 基于二分搜索的 ...

  6. 一位菜鸟的java 最基础笔记

    java的特性 简单性(Simple). 结构体系中立(Architecture Neutral). 面向对象(Object Oriented). 易于移植(Portable). 分布式(Distri ...

  7. 【JAVAWEB学习笔记】29_文件的上传------commons-fileupload

    今天内容: 文件的上传------commons-fileupload 文件上传和下载的实质:文件的拷贝 文件上传:从本地拷贝到服务器磁盘上   客户端需要编写文件上传表单---->服务端需要编 ...

  8. mysql之 MySQL 主从复制概述

    1 .主从复制简介MySQL 主从复制就是将一个 MySQL 实例(Master)中的数据实时复制到另一个 MySQL 实例(slave)中,而且这个复制是一个异步复制的过程.实现整个复制操作主要由三 ...

  9. unity3D:游戏分解之角色移动和相机跟随

          游戏中,我们经常会有这样的操作,点击场景中某个位置,角色自动移动到那个位置,同时角色一直是朝向那个位置移动的,而且相机也会一直跟着角色移动.有些游戏,鼠标滑动屏幕,相机就会围绕角色旋转. ...

  10. 搭建rtmp直播流服务之2:使用java实现ffmpeg命令接口化调用(用java执行ffmpeg命令)

    欢迎大家积极开心的加入讨论群 群号:371249677 (点击这里进群) 一.环境搭建 1.安装ffmpeg 下载对应系统的ffmpeg安装包,个人采用windows平台进行开发,所以安装了windo ...