简介
- 流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出
- 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
分类
- 根据处理数据类型的不同分为：字符流和字节流。
- 根据数据流向不同分为：输入流和输出流。
字节流
InputStream
java.io.InputStream类是所有Java IO输入流的基类,它是以字节为单位的输出流。
public abstract class InputStream extends Object implements Closeable
此抽象类是表示字节输入流的所有类的超类。需要定义 InputStream 子类的应用程序必须总是提供返回下一个输入字节的方法。
| 方法 | 描述 |
|---|---|
| available() | 返回输入流的字节数长度和大小 |
| read() | 读取数据流字节，存储到缓冲区数组 |
| close() | 关闭输入流并释放与该流关联的所有系统资源 |
| mark(int readlimit) | 标记输入流中当前的位置 |
| markSupported() | 测试此输入流是否支持mark 和reset 方法 |
| reset() | 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置 |
| skip(long n) | 跳过和丢弃此输入流中数据的 n 个字节 |
类图
例子
public class InputStreamDemo01{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
InputStream input = null ; // 准备好一个输入的对象
input = new FileInputStream(f) ; // 通过对象多态性，进行实例化
// 第3步、进行读操作
byte b[] = new byte[1024] ; // 所有的内容都读到此数组之中
input.read(b) ; // 读取内容 网络编程中 read 方法会阻塞
// 第4步、关闭输出流
input.close() ; // 关闭输出流
System.out.println("内容为：" + new String(b)) ; // 把byte数组变为字符串输出
}
};
OutputStream
| 方法 | 描述 |
|---|---|
| write() | 将数据写入输出流,准备输出到各种介质 |
| close() | 关闭并释放输出流资源 |
| flush() | 清空输出流 |
类图
例子
public static void main(String args[]) throws Exception
{
// 第1步、使用File类找到一个文件
File f = new File("d:\\51gjie.txt"); // 声明File对象
// 第2步、通过子类实例化父类对象
OutputStream out = null; // 准备好一个输出的对象
try
{
out = new FileOutputStream(f); // 通过对象多态性，进行实例化
// 第3步、进行写操作
String str = "欢迎来到www.51gjie.com"; // 准备一个字符串
byte b[] = str.getBytes(); // 只能输出byte数组，所以将字符串变为byte数组
out.write(b); // 将内容输出，保存文件
}
catch(IOException e)
{}
finally
{
out.close(); // 关闭输出流
}
}
字符流
Reader
Reader是一个抽象类，它是以字符为单位的输入流的公共父类。
protected Reader() //创建一个新的字符流 reader，其重要部分将同步其自身的 reader。
protected Reader(Object lock) //创建一个新的字符流 reader，其重要部分将同步给定的对象。
| 方法 | 描述 |
|---|---|
| abstract void close() | 关闭该流并释放与之关联的所有资源。 |
| void mark(int readAheadLimit) | 标记流中的当前位置。 |
| boolean markSupported() | 判断此流是否支持 mark() 操作。 |
| int read() | 读取单个字符。 |
| int read(char[] cbuf) | 将字符读入数组。 |
| abstract int read(char[] cbuf, int off, int len) | 将字符读入数组的某一部分。 |
| int read(CharBuffer target) | 试图将字符读入指定的字符缓冲区。 |
| boolean ready() | 判断是否准备读取此流。 |
| void reset() | 重置该流。 |
| long skip(long n) | 跳过字符。 |
Reader类图
例子
使用read()读取单个字符并输出
import java.io.*;
class FileReaderDemo
{
public static void sop(Object obj)
{
System.out.print(obj);
}
public static void main(String[] args)throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联起来。
//要保证该文件是已经存在的。如果不存在，会发生异常，即FileNotFoundException
FileReader fr = new FileReader("F:\\myfile\\test.txt");
//调用读取流对象的read方法。
//read方法：一次读取一次字符，而且会自动往后面读取字符。
int ch = 0;
while((ch=fr.read())!=-1)
{
sop((char)ch);
}
/*
while(true)
{
int ch = fr.read();
if(ch==-1)
break;
sop((char)ch); //读取文件中的一个字符
}
*/
fr.close();
}
}
Writer
Writer类是Java IO中所有Writer的基类。子类包括BufferedWriter和PrintWriter等等。
protected Writer() 创建一个新的字符流 writer，其关键部分将同步 writer 自身。
protected Writer(Object lock) 创建一个新的字符流 writer，其关键部分将同步给定的对象。
| 方法 | 描述 |
|---|---|
| Writer append(char c) | 将指定字符添加到此 writer。 |
| Writer append(CharSequence csq) | 将指定字符序列添加到此 writer。 |
| Writer append(CharSequence csq, int start, int end) | 将指定字符序列的子序列添加到此 writer.Appendable。 |
| abstract void close() | 关闭此流，但要先刷新它。 |
| abstract void flush() | |
| void write(char[] cbuf) | 写入字符数组。 |
| abstract void write(char[] cbuf, int off, int len) | 写入字符数组的某一部分。 |
| void write(int c) | 写入单个字符。 |
| void write(String str) | 写入字符串。 |
| void write(String str, int off, int len) | 写入字符串的某一部分。 |
Writer类图
例子
public class WriterDemo01{
public static void main(String args[]) throws Exception{ // 异常抛出，不处理
// 第1步、使用File类找到一个文件
File f= new File("d:" + File.separator + "test.txt") ; // 声明File对象
// 第2步、通过子类实例化父类对象
Writer out = null ; // 准备好一个输出的对象
out = new FileWriter(f) ; // 通过对象多态性，进行实例化
// 第3步、进行写操作
String str = "Hello World!!!" ; // 准备一个字符串
out.write(str) ; // 将内容输出，保存文件
// 第4步、关闭输出流
out.close() ; // 关闭输出流
//public class FileWriter extends OutputStreamWriter
//public class OutputStreamWriter extends Writer FileWriter实际上继承自 OutputStreamWriter
}
};
Read write flush close
FileInputStream
ObjectInputStream
DataInputStream
IO实例
例一：
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
try{
f.createNewFile(); //创建一个新文件
f.mkdir();//创建一个文件夹
//删除一个文件
if(f.exists()){
f.delete();
}else{
System.out.println("文件不存在");
}
//列出指定目录的全部文件（包括隐藏文件）
File[] str=f.listFiles();
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
使用RandomAccessFile写入文件
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
RandomAccessFile demo=new RandomAccessFile(f,"rw");
demo.writeBytes("asdsad");
demo.writeInt(12);
demo.writeBoolean(true);
demo.writeChar('A');
demo.writeFloat(1.21f);
demo.writeDouble(12.123);
demo.close();
}
}
向文件中写入字符串
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str="你好";
byte[] b=str.getBytes();
out.write(b);
out.close();
}
}
向文件中追加新内容
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
OutputStream out =new FileOutputStream(f,true);
String str="Rollen";
//String str="\r\nRollen"; 可以换行
byte[] b=str.getBytes();
for (int i = 0; i < b.length; i++) {
out.write(b[i]);
}
out.close();
}
}
读取文件内容
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int count =0;
int temp=0;
while((temp=in.read())!=(-1)){
b[count++]=(byte)temp;
}
in.close();
System.out.println(new String(b));
}
}
例二：
实体类
public class User implements Serializable{
private static final long serialVersionUID = -4253306203223783788L;
private int id;
private String username;
private String password;
public User(String username, String password) {
this.username = username;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
测试类
public static void main(String[] args) {
ObjectOutputStream out = null;
ObjectInputStream in = null;
try {
List<User> users = new ArrayList<User>();
User user1 = new User("admin","123");
User user2 = new User("ljl","456");
users.add(user1);
users.add(user2);
File file = new File("src/users.txt");
if(!file.exists()) {
file.createNewFile();
}
out = new ObjectOutputStream(new FileOutputStream(file,true));
out.writeObject(users);
out.flush();
in = new ObjectInputStream(new FileInputStream(file));
List<User> u2 = (List<User>) in.readObject();
for(User u :u2) {
System.out.println(u.getUsername()+"\t"+u.getPassword());
}
} catch (FileNotFoundException e) {
// TODO: handle exception
e.printStackTrace();
} catch(IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
out.close();
in.close();
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
}
}
3502
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
