(转载)java基础:关于java流与文件操作
原文摘自:
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与此类似,不过是分别指定Writer和Reader类型的参数罢了。
一个实例程序:
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流与文件操作的更多相关文章
- Java基础 使用转换流进行文件的复制 / RandomAccessFile 类进行文件的复制
笔记: **使用转换流进行文件的复制 文本文件---字节流FileInputStream--> [InputStreamReader] -----字符流BufferedReader------ ...
- java基础之IO流(二)之字符流
java基础之IO流(二)之字符流 字符流,顾名思义,它是以字符为数据处理单元的流对象,那么字符流和字节流之间的关系又是如何呢? 字符流可以理解为是字节流+字符编码集额一种封装与抽象,专门设计用来读写 ...
- Java基础之IO流整理
Java基础之IO流 Java IO流使用装饰器设计模式,因此如果不能理清其中的关系的话很容易把各种流搞混,此文将简单的几个流进行梳理,后序遇见新的流会继续更新(本文下方还附有xmind文件链接) 抽 ...
- JAVA通过I/O流复制文件
JAVA通过I/O流复制文件 本文是对字节流操作,可以多音频视频文件进行操作,亲测有效. 个人感觉这个东西就是靠记的, 没什么好解释的,,,, import java.io.File; import ...
- java基础之IO流(一)字节流
java基础之IO流(一)之字节流 IO流体系太大,涉及到的各种流对象,我觉得很有必要总结一下. 那什么是IO流,IO代表Input.Output,而流就是原始数据源与目标媒介的数据传输的一种抽象.典 ...
- Java基础复习笔记系列 七 IO操作
Java基础复习笔记系列之 IO操作 我们说的出入,都是站在程序的角度来说的.FileInputStream是读入数据.?????? 1.流是什么东西? 这章的理解的关键是:形象思维.一个管道插入了一 ...
- Java基础技术-Java其他主题【面试】
Java基础技术-Java其他主题[面试] Java基础技术IO与队列 Java BIO.NIO.AIO Java 中 BIO.NIO.AIO 的区别是什么? 含义不同: BIO(Blocking I ...
- 黑马程序员:Java基础总结----java注解
黑马程序员:Java基础总结 java注解 ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! java注解 lang包中的基本注解 @SuppressWarnings ...
- java基础-学java util类库总结
JAVA基础 Util包介绍 学Java基础的工具类库java.util包.在这个包中,Java提供了一些实用的方法和数据结构.本章介绍Java的实用工具类库java.util包.在这个包中,Java ...
- Java基础-使用JAVA代码剖析MD5算法实现过程
Java基础-使用JAVA代码剖析MD5算法实现过程 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.
随机推荐
- Android相机是如何获取到图像的
在研究zxing的过程中,脑袋中一直有个疑惑,那个相机并没有拍照,它是怎么获取图像的 带着这个疑惑查看Camera源码 Camera源码中有这样一个接口: public interface Previ ...
- C# 字典 Dictionary
原文地址http://www.cnblogs.com/txw1958/archive/2012/11/07/csharp-dictionary.html 侵删
- 在wamp下使用netbeans开启Xdbug
1.到http://www.xdebug.org 下载与PHP对应的xdebug版本,也可以把phpinfo源码粘贴到http://www.xdebug.org/find-binary.php,提交后 ...
- Spring 5.0.0.RC1 - CORS Support 【译文】
3 CORS支持 3.1 介绍 出于安全考虑,浏览器禁止对当前源之外的资源进行AJAX调用.例如,当你在一个标签页检查你的银行账户时,你可以在另一个标签页打开evil.com的网站.在evil.com ...
- MPP 一、Greenplum 集群安装
Installating and Initializing a Greenplum Database System... 1 安装说明 1.1 环境说明 名称 版本 下载地址 虚拟机 Oracle V ...
- 探讨SQL Server并发处理存在就更新七种解决方案
前言 本节我们来讲讲并发中最常见的情况存在即更新,在并发中若未存在行记录则插入,此时未处理好极容易出现插入重复键情况,本文我们来介绍对并发中存在就更新行记录的七种方案并且我们来综合分析最合适的解决方案 ...
- Linux网络服务01——Linux网络基础设置
Linux网络服务01--Linux网络基础设置 一.查看及测试网络 1.使用ifconfig命令查看网络接口 (1)查看活动的网络接口 ifconfig命令 [root@crushlinux ~]# ...
- iOS 手势
一.看这里 二.抽象类 UIGestureRecognizer 继承于该类的有7类:轻点,捏合,拖拽,滑动,长按,旋转,边缘滑动; 一个手势可以绑定多个事件 - (void)addTarget:( ...
- M41T11-RTC(实时时钟)
一.理论准备 1. 主要器件:STM8单片机.M41T11时钟IC.32.768kHz晶振等. 2. 外围设备:烧录工具ST-Link/v2.串口.5v供电SATA线. 3. 主要思想:通过单片机对时 ...
- java基础(十二章)
一.变量的作用域(有效的使用范围) 1.变量有2种 1.1成员变量(属性) 声明在类的里面,方法的外面 1.2 局部变量 声明在方法里面或for循环结构中 2.调用时的注意事项(初始值不同.作用域不同 ...