IO流
IO流:设备与设备之间的数据传输.
IO流的分类:
按流的方向分:
输入流:读数据的
输出流:写数据的
按数据类型分:
字节流:
字节输入流:InputStream
字节输出流:OutputStream
字符流:
字符输入流:Reader
字符输出流:Writer
OutputStream:该类是抽象类.
FileOutputStream是它的子类.构造方法:
public FileOutputStream(string name)
开发步骤:1>创建文件输出流对象.2>写数据.3>关闭资源.
相关代码:
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos=new FileOutputStream("b.txt");
fos.write("hello,IO,I'm coming".getBytes());
fos.close();
}
}
输出流中写数据的方法:
public abstract void write(int b):将指定的字节写入到输出流中.
public void write(byte[] b):将指定的字节数组写入到输出流中.
public void write(byte[] b,int off,int len):将字节数组的一部分写入到输入流中.
换行符:每个系统对应的IO换行符不一样.
windows:\r\n
Linux:\n
Mac:\r
InputStream:是个抽象类.
FileInputStream是它的子类:构造方法:
public FileInputStream(String name)
开发步骤:1>创建文件输入流对象.2>读数据3>释放资源.
输入流中读数据的方法:
public int read():一次读取一个字节.
public int read(byte[] b):一次读取一个字节数组.返回的是实际读取的字节数.
相关代码:
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
FileInputStream ips=new FileInputStream("C:\\Java\\MapDemo.java");
byte[] b=new byte[1024];
int len=0;
while((len=ips.read(b))!=-1){
System.out.print(new String(b,0,len));
}
}
}
例题:将MapDemo.java文件内容copy到当前目录下的a.txt.
相关代码:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
FileInputStream ips=new FileInputStream("C:\\Java\\MapDemo.java");
FileOutputStream ops=new FileOutputStream("a.txt");
byte[] b=new byte[1024];
int len=0;
while((len=ips.read(b))!=-1){
ops.write(b,0,len);
}
ips.close();
ops.close();
}
}
字节缓冲输入流:BufferedInputStream
构造方法:BufferedInputStream(InputStream in):指定默认缓冲区大小创建字节缓冲输入流对象.
字节缓冲输出流:BufferedOutputStream
构造方法:BufferedOutputStream(OutputStream out):指定默认缓冲区大小创建字节缓冲输出流对象.
注意:缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所有缓冲流不能直接对文件操作.
flush()和close()的区别:
flush():刷新缓冲区的流,强迫将缓冲字节都写入该流中,刷新之后可以写数据的.
close():关闭流对象所指向的这个资源文件,一旦关闭,写不入数据.
相关代码:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("C:\\Java\\MapDemo.java"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("b.txt"));
byte[] b=new byte[1024];
int len=0;
while((len=bis.read(b))!=-1){
bos.write(b,0,len);
bos.flush();
}
bis.close();
bos.close();
}
}
字符输入流:Reader:抽象类.
InputStreamReader:子类.构造方法:
public InputStreamReader(InputStream in,charest ch):字节输入流+编码模式(默认GBK).
字符输出流:Wreater:抽象类.
OutputStreamWriter:子类.构造方法:
public OutputStreamWriter(OutputStream out,charest ch):字节输出流+编码模式(默认GBK).
相关代码:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\Java\\MapDemo.java"),"GBK");
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("c.txt"),"GBK");
char[] ch=new char[1024];
int len=0;
while((len=isr.read(ch))!=-1){
osw.write(ch,0,len);
osw.flush();
}
isr.close();
osw.close();
}
}
便捷类:FileReader.构造方法:
public FileReader(String filename)
FileWriter.构造方法:
public FileWriter(String filename)
相关代码:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fr=new FileReader("C:\\Java\\MapDemo.java");
FileWriter fw=new FileWriter("d.txt");
char[] ch=new char[1024];
int len=0;
while((len=fr.read(ch))!=-1){
fw.write(ch, 0, len);
fw.flush();
}
fr.close();
fw.close();
}
}
字符缓冲输入流:BufferedReader.构造函数:
public BufferedReader(Reader in):创建默认缓冲区大小的一个字符缓冲输入流.
特有功能:
public String readLine():一次读取一行.
字符缓冲输出流:BufferedWriter:构造函数:
public BufferedWriter(writer in)"创建默认缓冲区大小的一个字符缓冲输出流.
特有功能:
public void newLine():写入一个换行符.
相关代码:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("C:\\Java\\MapDemo.java"));
BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt"));
//一次读取一行
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
//复制
copy(br, bw);
}
private static void copy(BufferedReader br, BufferedWriter bw)
throws IOException {
char[] ch=new char[1024];
int len=0;
while((len=br.read(ch))!=-1){
bw.write(ch,0,len);
bw.flush();
bw.newLine();
}
br.close();
bw.close();
}
}
DataInputStream和DataOutputStream都属于数据流:可以针对Java基本数据类型的数据进行读写.
构造方法:public DataInputStream(InputStream in)和pubic DataOutputStream(OutputStream out)
相关代码:
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataInputStreamDemo {
public static void main(String[] args) throws IOException {
// write();
//读数据
read();
}
private static void read() throws FileNotFoundException, IOException {
DataInputStream dis=new DataInputStream(new FileInputStream("dos.txt"));
byte readByte = dis.readByte();
int readInt = dis.readInt();
short readShort = dis.readShort();
long readLong = dis.readLong();
char readChar = dis.readChar();
boolean readBoolean = dis.readBoolean();
float readFloat = dis.readFloat();
double readDouble = dis.readDouble();
dis.close();
System.out.println(readByte);
System.out.println(readInt);
System.out.println(readShort);
System.out.println(readLong);
System.out.println(readChar);
System.out.println(readBoolean);
System.out.println(readFloat);
System.out.println(readDouble);
}
private static void write() throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
//写数据
dos.writeByte(100) ;
dos.writeInt(1000) ;
dos.writeShort(120) ;
dos.writeLong(1000000L);
dos.writeChar('A') ;
dos.writeBoolean(true) ;
dos.writeFloat(11.11F) ;
dos.writeDouble(12.12) ;
dos.close();
}
}
ByteArrayInputStream和ByteArrayOutputStream:内存操作流,针对内存的数据进行操作,程序一结束,这些内存的数据就会消失.
特点:针对小文件进行操作(聊天室项目中使用它进行发送文件)
ByteArrayInputStream:内存操作输入流.构造函数:
public ByteArrayInputStream(byte[] buf):参数是一个字节数组(缓冲数组)
ByteArrayOutputStream:内存操作输出流:构造函数:
public ByteArrayOutputStream():创建默认的缓冲区大小的内存缓冲输出流(单位是字节.)
成员方法:
public Byte[] toByteArray():创建一个新分配的Byte数组(将内存数据操作流对象转换成数组对象)
void reset():重置内存数据操作流.
注意:此流对象可以不用关闭.
相关代码:
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayInputStreamDemo {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream baos=new ByteArrayOutputStream();
baos.write(("hello").getBytes());
baos.write(("Java").getBytes());
//将内存操作输出流对象转换为字节数组.
byte[] byteArray = baos.toByteArray();
ByteArrayInputStream bais=new ByteArrayInputStream(byteArray);
//一次读一个字节
int len=0;
while((len=bais.read())!=-1){
System.out.print((char)len);
}
}
}
结果为:
helloJava
打印流:
字节打印流:PrintStream
字符打印流:PrintWriter
打印流特点:
1>在复制文件时,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)
2>打印流可以有自动刷新功能.
public PrintWriter(Writer out,boolean autoFlush):第二个参数指定为true,则自动刷新.
3>打印流可以直接针对文本文件进行操作.
只要构造方法的参数有File类或者是String类型,都可以针对文本文件进行操作
PrintWriter:构造方法:public PrintWriter(String filename).
写数据时,使用println():换行.
相关代码:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//封装数据源.
BufferedReader br=new BufferedReader(new FileReader("a.txt"));
//封装目的地
PrintWriter pw=new PrintWriter(new FileWriter("pw.txt"),true);
String line=null;
while((line=br.readLine())!=null){
pw.println(line);
}
br.close();
pw.close();
}
}
标准输入流和输出流:System中有两个字段:
in-->InputStream is=System.in;BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
相关代码:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class SystemInDemo {
public static void main(String[] args) {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个字符串:");
String line = null;
try {
line = br.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("您输入的字符串为:"+line);
}
}
out-->OutputStream ps=System.out;BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
相关代码:
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class SystemOutDemo {
public static void main(String[] args) {
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
try {
bw.write("立华奏");
bw.newLine();
bw.write("小薰");
bw.newLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入.不是实际意义上的流,因为它来自Object类.
常用的构造方法:
public RandomAccessFile(String name,String mode):参数一:指定文件路径,参数二:指定的一种模式:"rw"(可读可写).
相关代码:
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args) {
// write();
reader();
}
private static void reader() {
RandomAccessFile raf=null;
try {
raf=new RandomAccessFile("raf.txt", "rw");
byte b=raf.readByte();
char c=raf.readChar();
String s=raf.readUTF();
System.out.println(b);
System.out.println(c);
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}finally{
if(raf!=null){
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static void write() {
RandomAccessFile raf=null;
try {
raf=new RandomAccessFile("raf.txt", "rw");
raf.writeByte(100);
raf.writeChar('a');
raf.writeUTF("立华奏");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(raf!=null){
try {
raf.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联.合并流在复制文件的时候,只能操作数据源,不能操作目的地.
构造方法:public SequenceInputStream(InputStream s1,InputStream s2)
相关代码:
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
public class SequenceInputStreamDemo {
public static void main(String[] args) {
//分别封装这个两个文件
InputStream s1=null;
InputStream s2=null;
try {
s1 = new FileInputStream("a.txt");
s2 = new FileInputStream("b.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
//创建合并流对象
SequenceInputStream sis=new SequenceInputStream(s1, s2);
//封装目的地
BufferedOutputStream bos=null;
try {
bos = new BufferedOutputStream(new FileOutputStream("sis.txt"));
byte[] b=new byte[1024];
int len=0;
while((len=sis.read(b))!=-1){
bos.write(b,0,len);
bos.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(sis!=null){
try {
sis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bos!=null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
另一种构造方法:复制多个文件:
public SequenceInputStream(Enumeration<? extends InputStream> e)
运用Vector集合的特有功能:public Enumeration<E> elements()
相关代码:
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
public class SequenceInputStreamDemo2 {
public static void main(String[] args) {
//创建一个Vector集合
Vector<InputStream> v=new Vector<InputStream>();
//封装三个文件
try {
InputStream is1=new FileInputStream("a.txt");
InputStream is2=new FileInputStream("b.txt");
InputStream is3=new FileInputStream("c.txt");
v.add(is1);
v.add(is2);
v.add(is3);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
Enumeration<InputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);
BufferedOutputStream bos=null;
try {
bos=new BufferedOutputStream(new FileOutputStream("sis2.txt"));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
byte[] b=new byte[1024];
int len=0;
try {
while((len=sis.read(b))!=-1){
bos.write(b,0,len);
bos.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(bos!=null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(sis!=null){
try {
sis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
ObjectInputStream和ObjectOutputStream
ObjectOutputStream:序列化流:将对象像流的方式或者网络传输中的数据写数据.对象--->流数据
成员方法:
public final void writeObjecy(Object obj):将obj对象写入当前的序列化中.
ObjectInputStream:反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原对象.
成员方法:
public final Object readObject():从当前反序列化流中读取一个对象.
Serializeable:序列化接口.类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化,如果自定义一个类没有实现这
接口,就不能使用序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口.
注意事项:
比如一个类中有很多成员变量,并不想让一些成员变量被序列化,Java提供了一个关键字:transient:不用被序列化的时候用它修饰
序列化和反序列化考点:
1)将对象--->流数据或者流数据--->对象,该对象所在的类要实现一个标记接口:serializable 多线程有一个关键字:同步机制(synchronized)
2)序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决
3)transient:修饰的变量不会被序列化.
相关代码:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectStreamDemo {
public static void main(String[] args) {
// write();
//创建一个反序列化流对象
reader();
}
private static void reader() {
ObjectInputStream ois=null;
try {
ois=new ObjectInputStream(new FileInputStream("oos.txt"));
Object readObject = ois.readObject();
System.out.println(readObject);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(ois!=null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static void write() {
//创建一个对象
Person p=new Person("立华奏",20);
//创建一个序列化流对象
ObjectOutputStream oos=null;
try {
oos=new ObjectOutputStream(new FileOutputStream("oos.txt"));
oos.writeObject(p);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(oos!=null){
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
结果为:
Person [name=立华奏, age=0]
Properties:属性集合类,该类继承自Hashtable<K,V>,该类属于Map集合
Properties 类表示了一个持久的属性集。
Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串(一般情况:它用作配置文件去使用,MySQL或者Oracle中用它做配置文件)
构造方法:public Properties():创建一个空属性列表
属性集合类:Properties有自己的遍历和添加元素的功能
给属性列表中添加元素:
public Object setProperty(String key,String value)
public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
public String getProperty(String key)用指定的键在此属性列表中搜索属性值
Properties 可保存在流中或从流中加载.
将文件中的数据加载到属性集合中:public void load(Reader reader)
将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)第二个参数:comments:对当前属性列表的描述.
相关代码:
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo {
public static void main(String[] args) {
// mystore();
myload();
}
private static void myload() {
Properties prop=new Properties();
//创建字符输入流对象
FileReader fr=null;
try {
fr=new FileReader("name.txt");
//调用方法
prop.load(fr);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println(prop);
}
private static void mystore() {
//创建属性集合类对象
Properties prop=new Properties();
prop.setProperty("立华奏", "20");
prop.setProperty("小薰", "20");
//创建字符输出流
FileWriter fw=null;
try {
fw=new FileWriter("name.txt");
prop.store(fw, "name contents");
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fw!=null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
结果为:
{立华奏=20, 小薰=20}