一、字节流FileInputStream OutputStream
方式1:一个字节一个字节的读
1. 创建一个输入流
InputStream fin = new FileInputStream("e:\\igeek\\abc.txt");
1.2 从流中读取数据
int data = 0;
while(data!=-1)
{
data = fin.read();
System.out.println(data+" ");
}
System.out.println();
方式2:将内容读入到字节数组
byte[] by = new byte[1024];// 定义一个字节数组(缓冲区)
int len = fin.read(by);// 从流中读取数据存放到by中,返回具体读了多长数据
System.out.println("读了"+len+"字节,内容:"+Arrays.toString(by));
byte[] by = new byte[5];
int len = 0;
while(len!=-1)
{
len = fin.read(by);
System.out.println("读了"+len+"字节,内容:"+Arrays.toString(by));
}
关闭文件
fin.close();
2. 创建一个输出流
OutputStream fos = new FileOutputStream("e:\\igeek\\abc.txt");
21 往流中写入数据
方式1:
fos.write('a');
方式2:
byte[] by1 = {97,98,99,100,101};// a b c d e
fos.write(by1);
方式3:
fos.write(by1, 2, 3);
2.3.关闭流
fos.close();
二、字符流 Writer Reader
字符流 Writer Reader
1. 打开文件(读取文件)
Reader r = new FileReader("e:\\igeek\\a1.txt");
2. 读取内容
读取单个字符将字符读入数组。
方式1:一个一个读
int d=0;
while(d!=-1)
{
d = r.read();
if(d>0)
{
char c = (char)d;
System.out.print(c);
}
}
方式2:读到字符数组中
char[] buf = new char[1024];// 缓冲区
int len = 0;
while(len>-1)
{
len = r.read(buf);
System.out.println("读到长度="+len);
if(len>0)
{
String str = new String(buf);
System.out.println(str);
}
}
3. 关闭文件
r.close();
// 1. 打开文件(写入文件)
Writer w = new FileWriter("e:\\igeek\\a1.txt");
// 2. 写入信息
w.write("Hello,你好!小胖!");
// 3. 关闭文件
w.close();
三、缓冲流 BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter
缓冲字节输入流 缓冲字节输出流 BufferedInputStream BufferedOutputStream 处理流 (只是一个辅助的处理流,不能单独存在);
缓冲字符输入流 缓冲字符输出流 BufferedReader BufferedWriter;
public static void main(String[] args) throws IOException
{
long t1 = System.currentTimeMillis();
InputStream f1 = new BufferedInputStream(new FileInputStream("e:\\igeek\\test.mp4"));
OutputStream f2 = new BufferedOutputStream(new FileOutputStream("e:\\igeek\\test2.mp4"));
byte[] by = new byte[1024];
int len = 0;
while(len!=-1)
{
// 读取数据到by中,返回的是具体读了多长的数据
len = f1.read(by);
if(len>0)
{
// 将读取出来的数据写入到新文件中
f2.write(by, 0, len);
}
}
f1.close();
f2.close();
long t2 = System.currentTimeMillis();
System.out.println("耗费了"+(t2-t1)+"ms");
// 256 耗费了1824ms
// 1024 耗费了537ms
// 2048 耗费了338ms
// 10240 耗费了144ms
// 102400 耗费了105ms
// 1024000 耗费了162ms
// 1024 耗费了289ms
// 10240 耗费了207ms
}
四、数据流 DataInputStream DataOutputStream
数据流 (处理流)DataInputStream DataOutputStream
private static void testReadData() throws IOException
{
// 1. 打开文件
DataInputStream input = new DataInputStream(new FileInputStream("e:\\igeek\\data1.txt"));
// 2. 读取数据
int i = input.readInt();
byte b = input.readByte();
float f = input.readFloat();
boolean b2 = input.readBoolean();
double d = input.readDouble();
String str = input.readUTF();
System.out.println(i);
System.out.println(b);
System.out.println(f);
System.out.println(b2);
System.out.println(d);
System.out.println(str);
// 3. 关闭文件
input.close();
}
private static void testWriteData() throws IOException {
// TODO Auto-generated method stub
// 1. 打开文件
DataOutputStream output = new DataOutputStream(new FileOutputStream("e:\\igeek\\data1.txt"));
// 2. 写入数据
output.writeInt(10);
output.writeByte(3);
output.writeFloat(3.1415F);
output.writeBoolean(true);
output.writeDouble(3.1415);
output.writeUTF("你好");
// 3. 关闭文件
output.close();
}
五、对象流 ObjectInputStream ObjectOutputStream
对象流 ObjectInputStream ObjectOutputStream
类对象要能够写入到对象流需要序列化必须要实现Serializable接口!
创建一个Dog类
public class Dog implements Serializable{
String name;
int age;
// 这个属性不想存档,前面加transient关键字
transient boolean isOut;
public Dog(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Dog [name=" + name + ", age=" + age + "]";
}
}
对象写入读出:
public class ObjectStreamDemo {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
// TODO Auto-generated method stub
testWrite();
testRead();
}
private static void testRead() throws FileNotFoundException, IOException, ClassNotFoundException {
// 1. 创建流
ObjectInputStream in = new ObjectInputStream(new FileInputStream("e:\\igeek\\data2.txt"));
// 2. 读取数据
Dog d1 = (Dog)in.readObject();
Dog d2 = (Dog)in.readObject();
System.out.println(d1);
System.out.println(d2);
// 3. 关闭流
in.close();
}
private static void testWrite() throws FileNotFoundException, IOException {
Dog d1 = new Dog("小白",3);
Dog d2 = new Dog("小黑",5);
// 1. 创建流
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("e:\\igeek\\data2.txt"));
// 2. 写入数据
o.writeObject(d1);
o.writeObject(d2);
// 3. 关闭流
o.close();
}
}
六、内存流 ByteArrayInputStream ByteArrayOutputStream CharArrayWriter CharArrayReader
ByteArrayInputStream ByteArrayOutputStream
// 用流的方式处理字节数组
ByteArrayOutputStream o = new ByteArrayOutputStream();
while(o.size()<10)
{
// 从我们输入的内容中读一个字节的数据
int data = System.in.read();
// 将这个数据写入到o中
o.write(data);
}
byte[] bytes = o.toByteArray();
System.out.println(Arrays.toString(bytes));
// 原本:
// 1. 定义数组(先定了数组的大小)
// 2. 将信息放入数组(自己得确定索引)
// 流的方式:
// 1. 创建一个字节输出流对象
// 2. 往里面写入字节信息
// 3. 通过toByteArray()得到一个字节数组
// 输入流:
byte[] arr = {100,101,102,103,104};
ByteArrayInputStream in = new ByteArrayInputStream(arr);
int b = 0;
while(b!=-1)
{
b = in.read();
if(b!=-1)
{
System.out.print(b+" ");
}
}
System.out.println();
用流的方式操作字符数组 CharArrayWriter CharArrayReader:
CharArrayWriter w = new CharArrayWriter();
w.write("你好");
w.write("I love you!");
char[] data = w.toCharArray();
System.out.println(Arrays.toString(data));
char[] charArr = {'哈','喽','I','l'};
CharArrayReader r = new CharArrayReader(charArr);
System.out.println((char)r.read());
System.out.println((char)r.read());
StringWriter StringReader :
// 输出流
StringWriter w = new StringWriter();
w.write("你好");
w.write(",祖国");
System.out.println(w.toString());
// 输入流
StringReader r = new StringReader("你好,123abc");
int d = 0;
while(d>-1)
{
d = r.read();
System.out.println(d);
if(d>0)
{
char c= (char)d;
System.out.println(c);
}
}
r.close();// 可以省略
七.字符流文件拷贝demo
/*
* 使用字符流拷贝一个文件
* 字符流:字节流+默认编码
* 使用字符输入流取出文件的信息,字符输入流会自动对读到的数据进行解码(解码方式默认是UTF-8)
* 之后使用字符输出流将读取到的数据写出到文件中,写出之前会自动对数据进行编码(UTF-8)
* 因此,如果拷贝图片,会在编码解码过程中出现数据的丢失,导致拷贝后的图片无法打开
* 使用字节流可以拷贝任意类型的文件,字节流直接拷贝底层二进制文件,不做任何处理
* 总结:什么时候使用字符流
* 如果可以使用系统自带的文本编辑工具打开并且不乱码的文件,都可以使用字符流
* 其余的均使用字节流
* */
public class Demo4 {
public static void main(String[] args) throws IOException{
//1、创建字符输入流对象
FileReader fr = new FileReader(new File("shi.jpg"));
//2、创建字符输出流对象
FileWriter fw = new FileWriter(new File("/Users/igeekhome/shishi.jpg"));
/*int hasRead = -1;
while((hasRead = fr.read())!=-1) {
//hasRead :读到的内容
fw.write(hasRead);
}*/
char[] c = new char[1024];
int length = -1;
while((length = fr.read(c)) != -1) {
fw.write(c, 0, length);
}
fw.close();
fr.close();
}
}