输入及输出
•输入输出（I/O）
把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read操作
从程序往外部设备写数据，称为输出，即output，进行数据的write操作
•InputStream和OutputStream的子类都是字节流
-可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
•Reader和Writer的子类都是字符流
主要处理字符或字符串，字符流处理单元为1个字符。
字节流将读取到的字节数据，去指定的编码表中获取对应文字。
public static void main(String[] args) {
try {
//创建FileInputStream的对象,指定要输入(读)的文件,文件不存在,抛出异常
FileInputStream in = new FileInputStream("E:\\demo.txt");
//每次read();一次,从输入流中读到一个字节,当读取完后会返回-1
int b = in.read();
System.out.println(b);
int b1 = in.read();
System.out.println(b1);
int b2 = in.read();
System.out.println(b2);
int b3 = in.read();
System.out.println(b3);
int b4 = in.read();
System.out.println(b4);
int b5 = in.read();
System.out.println(b5);
int b6 = in.read();
System.out.println(b6);
} catch (IOException e) {
e.printStackTrace();
}
}
输入输出成对出现
public static void main(String[] args) {
FileInputStream in = null;
FileOutputStream out = null;
try {
/*
创建FileInputStream对象,指定要输入(读)的文件,文件不存在,会抛出异常
*/
in = new FileInputStream("E:\\demo.txt");
/*
创建FileOutputStream对象,会自动创建输出的文件
*/
out = new FileOutputStream("F:\\demo.txt");
int b = 0;
while ((b = in.read()) != -1) {
System.out.println(b);
out.write(b);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭流对象,释放系统资源
try {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
有效代码
public static void main(String[] args) throws IOException {
/*
创建FileInputStream对象,指定要输入(读)的文件,文件不存在,会抛出异常
*/
FileInputStream in = new FileInputStream("E:\\demo.txt");
/*
创建FileOutputStream对象,会自动创建输出的文件
*/
FileOutputStream out = new FileOutputStream("F:\\demo.txt");
int b = 0;
while ((b = in.read()) != -1) {
System.out.println(b);
out.write(b);
}
in.close();
out.close();
}
读写效率的提升
package com.ff.javaio.Day2;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class StreamDemo3 {
public static void main(String[] args) throws IOException {
/*
创建FileInputStream对象,指定要输入(读)的文件,文件不存在,会抛出异常
*/
FileInputStream in = new FileInputStream("E:\\demo.txt");
/*
创建FileOutputStream对象,会自动创建输出的文件
*/
FileOutputStream out = new FileOutputStream("F:\\demo.txt");
/*
read();每次从输入流中读取一个字符 返回字符值 读完返回-1
read(byte[] b)每次从输入流中读取一个byte数组长度个字符,返回数组中实际装入内容个数,读完返回-1
*/
byte [] b = new byte[10];
int length=0;
while((length=in.read(b))!=-1){
/* out.write(b);每次传10个字符,不足10个字符,会自动填充空格*/
out.write(b,0,length);//向外写出一个byte数组个字节,从数组指定位置开始,写length个字节
}
in.read(b);
in.close();
out.close();
}
}
缓冲字节输入/出流
public static void main(String[] args) throws IOException {
//创建输入节点流，负责对文件读写
FileInputStream in = new FileInputStream("D:\\Users\\17509\\Desktop\\Tule - Fearless.mp3");
//创建处理对象，内部有一个缓冲数组，默认为8192个字节，包装输入流，提供缓冲功能，也可以设置缓冲区大小
BufferedInputStream bin = new BufferedInputStream(in);
FileOutputStream out = new FileOutputStream("E:/新建文件.mp3");
BufferedOutputStream bout = new BufferedOutputStream(out);
/* int b= 0;
while ((b=bin.read())!=-1){
bout.write(b);
}*/
int length = 0;
byte[] b = new byte[1024];
while ((length = bin.read(b)) != -1) {
bout.write(b, 0, length);
}
bout.flush();//刷新缓冲区
bout.close();
bin.close();
}
字符流
字符流，以字符为单位读写数据
Reader
转换流 InpuStreamReader
FileReader
BufferedReader
Writer
转换流 OutStreamWriter
FileWriter
BufferedWriter
Reader 的基本方法 读取一个字符并以整数的形式返回, 如果返回-1已到输入流的末尾。
Writer 的基本方法向输出流中写入一个字符数据,该字节数据为参数b的16位
FileReader&&FileWriter
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("D:\\test.txt");
FileWriter writer = new FileWriter("D:\\test1.txt");
/*int c = ' ';
while((c= reader.read())!=-1){
System.out.println((char)c);
writer.write(c);
}*/
//读取为字符类型数组
char[] c = new char[5];
int length;
while((length= reader.read(c))!=-1){
System.out.println(length);
writer.write(c,0,length);
}
writer.close();
reader.close();
}
BufferedReader&&BufferedWriter
FileWriter方法中有字符拼接，写入时不会覆盖原来的内容，会在后面继续拼接
BufferedWriter中readLine();方法,实现了每次可以读取文件中一行的功能
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("D:\\test.txt");
BufferedReader breader = new BufferedReader(reader);
// FileWriter方法中有字符拼接，写入时不会覆盖原来的内容，会在后面继续拼接
FileWriter writer = new FileWriter("D:\\test1.txt", true);
BufferedWriter bwriter = new BufferedWriter(writer);
//读完时返回null；
//breader.readLine()一次读一行数据
/*System.out.println(breader.readLine());
System.out.println(breader.readLine());
System.out.println(breader.readLine());*/
String line = null;
while ((line = breader.readLine()) != null) {
bwriter.write(line);//一次一行写入
bwriter.newLine();//新的一行
}
bwriter.flush();
bwriter.close();
breader.close();
}
Print打印流
打印流:单向的从程序中向外输出数据
PrintWriter:打印字符流
案例: 例如 从服务器端向 客户端浏览器 输出网页信息.
public static void main(String[] args) throws FileNotFoundException {
PrintWriter out = new PrintWriter("E:\\demo.html");
out.println("<h1>这是从服务器端响应回来的数据</h1>");
out.println("<h1>这是从服务器端响应回来的数据</h1>");
out.write("<h2>这是从服务器端响应回来的数据</h2>");
out.print(true);// print底层使用的还是write() 只是重载了多个,可以处理多种的数据类型
out.close();
}
对象输入输出流(对象序列化和反序列化)
对象输入输出流
对象:内存中的对象
为什么要将对象输出?
内存中的数据在电脑关闭,服务器停止时数据就会消失
有时候需要将这些数据保存起来
对象的输出流： ObjectOutputStream
对象的输入流: ObjectInputStream
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 对象的序列化
FileOutputStream out = new FileOutputStream("D:\\demo.txt");
//ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。
ObjectOutputStream oout = new ObjectOutputStream(out);
String s ="abc";
Date date =new Date();
oout.writeObject(s);
oout.writeObject(date);
oout.close();
//反序列化
FileInputStream in = new FileInputStream("D:\\demo.txt");
//在ObjectInputStream 中用readObject()方法可以直接读取一个对象
ObjectInputStream oin =new ObjectInputStream(in);
String s =(String) oin.readObject();
Date date = new Date();
System.out.println(s);
System.out.println(date);
oin.close();
}
新建Student类
/*
需要被序列化类的对象,此类必须要实现Serializable接口
*/
public class Student implements Serializable {
//会自动为类生成一个 默认ID号,当此类中的内容发生修改后,id号会发生变化
//实用工具生成一个序列化ID号,这样类发生修改后,此ID依然不会改变
private static final long serialVersionUID = -7119195593092378008L;
int num;
String name;
//被transient修饰的属性,不能被序列化
transient String adress;
public Student(int num, String name,String adress) {
this.num = num;
this.name = name;
this.adress= adress;
}
@Override
public String toString() {
return "Student{" +
"num=" + num +
", name='" + name + ",adress="+adress+'\'' +
'}';
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileOutputStream fos = new FileOutputStream("D:\\demo.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
Student stu = new Student(12,"jim","陕西省");
oos.writeObject(stu);
oos.close();
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream in = new FileInputStream("D:\\demo.txt");
ObjectInputStream oin = new ObjectInputStream(in);
Student student = (Student)oin.readObject();
System.out.println(student);
oin.close();
}