JAVA.IO使用笔记

原创 2007年09月20日 09:36:00

Java I/O系统的类实在是太多了,这里我们只学习一些基本的和常用的,相信能够掌握这些就可以解决我们以后的普通应用了
1.什么是数据流 ?
数据流是指所有的数据通信通道
有两类流,InputStream and OutputStream,Java中每一种流的基本功能依赖于它们
InputStream 用于read,OutputStream 用于write, 读和写都是相对与内存说的,读就是从其他地方把数据拿进内存,写就是把数据从内存推出去
这两个都是抽象类,不能直接使用
2.InputStream 的方法有:
read() 从流中读入数据 有3中方式:
int read() 一次读一个字节
int read(byte[]) 读多个字节到数组中
int read(byte[],int off,int len) 指定从数组的哪里开始,读多长
skip() 跳过流中若干字节
available() 返回流中可用字节数,但基于网络时无效,返回0
markSupported() 判断是否支持标记与复位操作
mark() 在流中标记一个位置,要与markSupported()连用
reset() 返回标记过的位置
close() 关闭流
3.OutputStream 的方法:
write(int) 写一个字节到流中
write(byte[]) 将数组中的内容写到流中
write(byte[],int off,int len) 将数组中从off指定的位置开始len长度的数据写到流中
close() 关闭流
flush() 将缓冲区中的数据强制输出
4.File 类
File 可以表示文件也可以表示目录,File 类控制所有硬盘操作
构造器:
File(File parent,String child) 用父类和文件名构造
File(String pathname) 用绝对路径构造
File(String parent,String child) 用父目录和文件名构造
File(URI uri) 用远程文件构造
常用方法:
boolean createNewFile();
boolean exists();
例子:
//建立 test.txt 文件对象,判断是否存在,不存在就创建
import java.io.*;
public class CreateNewFile{
public static void main(String args[]){
File f=new File("test.txt");
try{
if(!f.exists())
f.createNewFile();
else
System.out.println("exists");
}catch(Exception e){
e.printStackTrace();
}
}
}
boolean mkdir()/mkdirs()
boolean renameTo(File destination)
例子://看一下这 mkdir()/mkdirs() 的区别和 renameTo 的用法
import java.io.*;
public class CreateDir{
public static void main(String args[]){
File f=new File("test.txt");
File f1=new File("Dir");
File f2=new File("Top/Bottom");
File f3=new File("newTest.txt");
try{
f.renameTo(f3);
f1.mkdir();
f2.mkdirs();
}catch(Exception e){
e.printStackTrace();
}
}
}
String getPath()/getAbsolutePath()
String getParent()/getName()
例子://硬盘上并没有parent 目录和 test.txt 文件,但我们仍然可以操作,因为我们创建了他们的对象,是对对象进行操作
import java.io.*;
public class Test{
public static void main(String args[]){
File f=new File("parent/test.txt");
File f1=new File("newTest.txt");
try{
System.out.println(f.getParent());
System.out.println(f.getName());
System.out.println(f1.getPath());
System.out.println(f1.getAbsolutePath());
}catch(Exception e){
e.printStackTrace();
}
}
}
String list[] //显示目录下所有文件
long lastModified() //返回 1970.1.1 到最后修改时间的秒数
boolean isDirectory()
例子://列出目录下的所有文件和目录,最后修改时间,是目录的后面标出
,是文件的后面标出文件长度
import java.io.*;
import java.util.*;
public class Dir{
public static void main(String args[]){
File f=new File("Dir");
String[] listAll=null;
File temp=null;
try{
listAll=f.list();
for(int i=0;itemp=new File(listAll);
System.out.print(listAll+"/t");
if(temp.isDirectory())
System.out.print("/t
/t");
else
System.out.print(temp.length()+"/t");
System.out.println(new Date(temp.lastModified()));
}
}catch(Exception e){
e.printStackTrace();
}
}
}
 
5.文件流的建立
File f=new File("temp.txt");
FileInputStream in=new FileInputStream(f);
FileOutputStream out=new FileOutputStream(f);
例子:文件拷贝
import java.io.*;
public class Copy{
public static void main(String args[]){
FileInputStream fis=null;
FileOutputStream fos=null;
try{
fis=new FileInputStream("c2.gif");
fos=new FileOutputStream("c2_copy.gif");
int c;
while((c=fis.read()) != -1)
fos.write(c);
}catch(Exception e){
e.printStackTrace();
}finally{
if(fis != null) try{ fis.close(); }catch(Exception e){ e.printStackTrace(); }
if(fos!= null) try{ fos.close(); }catch(Exception e){ e.printStackTrace(); }
}
}
}

6.缓冲区流
BufferedInputStream
BufferedOutputStream
他们是在普通文件流上加了缓冲的功能,所以构造他们时要先构造普通流
例子:文件拷贝的缓冲改进
import java.io.*;
public class Copy{
public static void main(String args[]){
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
byte buf[]=new byte[100];
try{
bis=new BufferedInputStream(new FileInputStream("persia.mp3"));
bos=new BufferedOutputStream(new FileOutputStream("persia_copy.mp3"));
int len=0;
while( true ){
len=bis.read(buf);
if(len<=0) break;
bos.write(buf,0,len);
}
bos.flush();//缓冲区只有满时才会将数据输出到输出流,用flush()将未满的缓冲区中数据强制输出
}catch(Exception e){
e.printStackTrace();
}finally{
if(bis != null) try{ bis.close(); }catch(Exception e){ e.printStackTrace(); }
if(bos!= null) try{ bos.close(); }catch(Exception e){ e.printStackTrace(); }
}
}
}

7.原始型数据流
DataInputStream
DataOutputStream
他们是在普通流上加了读写原始型数据的功能,所以构造他们时要先构造普通流
方法:
readBoolean()/writeBoolean()
readByte()/writeByte()
readChar()/writeByte()
......
例子://这个流比较简单,要注意的就是读时的顺序要和写时的一样
import java.io.*;
public class DataOut{
public static void main(String args[]){
DataOutputStream dos=null;
try{
dos=new DataOutputStream(new FileOutputStream("dataout.txt"));
dos.writeInt(1);
dos.writeBoolean(true);
dos.writeLong(100L);
dos.writeChar('a');
}catch(Exception e){
e.printStackTrace();
}finally{
if(dos!=null)
try{
dos.close();
}catch(Exception e){
}
}
}
}
import java.io.*;
public class DataIn{
public static void main(String args[]){
DataInputStream dis=null;
try{
dis=new DataInputStream(new FileInputStream("dataout.txt"));
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
System.out.println(dis.readLong());
System.out.println(dis.readChar());
}catch(Exception e){
e.printStackTrace();
}finally{
if(dis!=null)
try{
dis.close();
}catch(Exception e){
}
}
}
}
8.对象流
串行化:对象通过写出描述自己状态的数值来记述自己的过程叫串行话
对象流:能够输入输出对象的流
将串行化的对象通过对象流写入文件或传送到其他地方
对象流是在普通流上加了传输对象的功能,所以构造对象流时要先构造普通文件流
注意:只有实现了Serializable接口的类才能被串行化
例子:
import java.io.*;
class Student implements Serializable{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void greeting(){
System.out.println("hello ,my name is "+name);
}
public String toString(){
return "Student["+name+","+age+"]";
}
}
public class ObjectOutTest{
public static void main(String args[]){
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(
new FileOutputStream("student.txt"));
Student s1=new Student("Jerry",24);
Student s2=new Student("Andy",33);
oos.writeObject(s1);
oos.writeObject(s2);
}catch(Exception e){
e.printStackTrace();
}finally{
if(oos!=null)
try{
oos.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
import java.io.*;
public class ObjectInTest{
public static void main(String args[]){
ObjectInputStream ois=null;
Student s=null;
try{
ois=new ObjectInputStream(
new FileInputStream("student.txt"));
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
}catch(Exception e){
e.printStackTrace();
}finally{
if(ois!=null)
try{
ois.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}

9.字符流 InputStreamReader/OutputStreamWriter
上面的几种流的单位是 byte,所以叫做字节流,写入文件的都是二进制字节,我们无法直接看,下面要学习的是字节流
Java采用 Unicode 字符集,每个字符和汉字都采用2个字节进行编码,ASCII 码是 Unicode 编码的自集
InputStreamReader 是 字节流 到 字符桥的桥梁 ( byte->char 读取字节然后用特定字符集编码成字符)
OutputStreamWriter是 字符流 到 字节流的桥梁 ( char->byte )
他们是在字节流的基础上加了桥梁作用,所以构造他们时要先构造普通文件流
我们常用的是:
BufferedReader 方法:readLine()
PrintWriter 方法:println()
例子:
import java.io.*;
public class PrintWriterTest{
public static void main(String args[]){
PrintWriter pw=null;
try{
pw=new PrintWriter(
new OutputStreamWriter(
new FileOutputStream("bufferedwriter.txt")));
pw.println("hello world");
}catch(Exception e){
e.printStackTrace();
}finally{
if(pw!=null)
try{
pw.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
 
import java.io.*;
public class BufferedReaderTest{
public static void main(String args[]){
BufferedReader br=null;
try{
br=new BufferedReader(
new InputStreamReader(
new FileInputStream("bufferedwriter.txt")));
System.out.println(br.readLine());
}catch(Exception e){
e.printStackTrace();
}finally{
if(br!=null)
try{
br.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
10.随机存取文件 RandomAccessFile
可同时完成读写操作
支持随机文件操作的方法:
readXXX()/writeXXX()
seek() 将指针调到所需位置
getFilePointer() 返回指针当前位置
length() 返回文件长度
例子:把若干个32位的整数写到一个名为 “temp.txt”的文件中,然后利用seek方法,以相反的顺序再读取这些数据
import java.io.*;
public class RandomFile{
public static void main(String args[]){
RandomAccessFile raf=null;
int data[]={12,31,56,23,27,1,43,65,4,99};
try{
raf=new RandomAccessFile("temp.txt","rw");
for(int i=0;iraf.writeInt(data);
for(int i=data.length-1;i>=0;i--){
raf.seek(i*4);
System.out.println(raf.readInt());
}
}catch(Exception e){
e.getMessage();
}finally{
if(raf!=null)
try{
raf.close();
}catch(Exception e){
e.getMessage();
}
}
}
}

11.小结
这部分的难点就是类比较复杂,尤其是每个类的构造方式,我认为记住下面这个图比记类的继承关系更好些
a. 字节流:
InputStream
|-- FileInputStream (基本文件流)
|-- BufferedInputStream
|-- DataInputStream
|-- ObjectInputStream
OutputStream 同上图
BufferedInputStream DataInputStream ObjectInputStream 只是在 FileInputStream 上增添了相应的功能,构造时先构造FileInputStream
b. 字符流:
Reader
|-- InputStreamReader (byte->char 桥梁)
|-- BufferedReader (常用)
Writer
|-- OutputStreamWriter (char->byte 桥梁)
|-- BufferedWriter
|-- PrintWriter (常用)
c. 随机存取文件 RandomAccessFile
 

java.io 与对象序列化 笔记

①序列化对象写入文件(Serializaiton):对象序列化之前,它的类要被声明为Serializable(实现 Serializable 的接口):public class aa implemen...
  • wangxiaojingo
  • wangxiaojingo
  • 2013年05月14日 18:47
  • 435

尚硅谷java学习笔记——NIO(New IO)

Java NIO(New IO或 Non Blocking IO)是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java IO API。NIO支持面向缓冲区的、基于通道的IO操...
  • zxm1306192988
  • zxm1306192988
  • 2017年03月08日 19:45
  • 937

java.io源码阅读笔记(1)

软件包介绍 通过数据流、序列化和文件系统提供系统输入和输出。 异常整理 异常名称 介绍 抛出场景 IOExcption 失败或中断的IO操作生成的异常的通用...
  • sivannnn
  • sivannnn
  • 2016年11月02日 17:34
  • 147

java--IO 使用带缓冲功能的字节流复制文件

思路  1、MyCopyFile类中copyFile方法接收由调用者传递的两个参数(要复制的文件完整路径file和要复制到哪里的目录path)  2、创建file和path的实例对象,并进...
  • dmuhan
  • dmuhan
  • 2015年07月09日 14:12
  • 662

Java知识——精华总结

Java知识——精华总结
  • qq_33885315
  • qq_33885315
  • 2017年03月05日 14:55
  • 2066

java.io之文件

第0章:简介 第1章:详解 文件工具类FileUtils.java如下: package com.lsl.util; import java.io.File; import java.io.File...
  • Tianxing10
  • Tianxing10
  • 2013年10月23日 09:51
  • 689

java.io.file的绝对路径和相对路径

/**  * 了解 File 类获取文件路径的 API 差别  *  * 当前操作系统为:XP SP2  *  * 当前类的位置:D:\workspace\java\code\jdker\src\...
  • u011523796
  • u011523796
  • 2013年11月17日 20:42
  • 844

Java.io之文件

java.io包也是Java内置的包,其中包含一系列对文件和目录的属性进行操作,对文件进行读写操作的类 文件即是具体的某个文件,如:某个ppt,某个doc;文件一般是存放在磁盘上的,例如:硬盘、光盘等...
  • taoshengyijiuzt
  • taoshengyijiuzt
  • 2015年02月04日 17:14
  • 400

java.io学习总结

java.io学习总结 博客分类:  java编程 java基础 jdk学习 javareaderoutputstreaminputstreamwriter  我将按照基类...
  • liweiahut
  • liweiahut
  • 2015年07月25日 11:13
  • 168

黑马程序员_JAVA.IO流学习笔记

一、java.io 的描述 通过数据流、序列化和文件系统提供系统输入和输出。 二、流 流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是...
  • zhishengyong
  • zhishengyong
  • 2014年05月29日 18:43
  • 153
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA.IO使用笔记
举报原因:
原因补充:

(最多只允许输入30个字)