BufferedReader的小例子
注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：
1. BufferedReader buf = new BufferedReader(
2. new InputStreamReader(System.in));
下面给一个实例：
1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStreamReader;
4.
5. /**
6. * 使用缓冲区从键盘上读入内容
7. * */
8. public class BufferedReaderDemo{
9. public static void main(String[] args){
10. BufferedReader buf = new BufferedReader(
11. new InputStreamReader(System.in));
12. String str = null;
13. System.out.println("请输入内容");
14. try{
15. str = buf.readLine();
16. }catch(IOException e){
17. e.printStackTrace();
18. }
19. System.out.println("你输入的内容是：" + str);
20. }
21.}
运行结果：
请输入内容
dasdas
你输入的内容是：dasdas
Scanner类
其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧
1. import java.util.Scanner;
2.
3. /**
4. * Scanner的小例子，从键盘读数据
5. * */
6. public class ScannerDemo{
7. public static void main(String[] args){
8. Scanner sca = new Scanner(System.in);
9. // 读一个整数
10. int temp = sca.nextInt();
11. System.out.println(temp);
12. //读取浮点数
13. float flo=sca.nextFloat();
14. System.out.println(flo);
15. //读取字符
16. //...等等的，都是一些太基础的，就不师范了。
17. }
18.}
其实Scanner可以接受任何的输入流
下面给一个使用Scanner类从文件中读出内容
1. import java.io.File;
2. import java.io.FileNotFoundException;
3. import java.util.Scanner;
4.
5. /**
6. * Scanner的小例子，从文件中读内容
7. * */
8. public class ScannerDemo{
9. public static void main(String[] args){
10.
11. File file = new File("d:" + File.separator + "hello.txt");
12. Scanner sca = null;
13. try{
14. sca = new Scanner(file);
15. }catch(FileNotFoundException e){
16. e.printStackTrace();
17. }
18. String str = sca.next();
19. System.out.println("从文件中读取的内容是：" + str);
20. }
21.}
【运行结果】：
从文件中读取的内容是：这些文件中的内容哦！
数据操作流DataOutputStream、DataInputStream类
1. import java.io.DataOutputStream;
2. import java.io.File;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5.
6. public class DataOutputStreamDemo{
7. public static void main(String[] args) throws IOException{
8. File file = new File("d:" + File.separator + "hello.txt");
9. char[] ch = { 'A', 'B', 'C' };
10. DataOutputStream out = null;
11. out = new DataOutputStream(new FileOutputStream(file));
12. for(char temp : ch){
13. out.writeChar(temp);
14. }
15. out.close();
16. }
17.}
A B C
现在我们在上面例子的基础上，使用DataInputStream读出内容
1. import java.io.DataInputStream;
2. import java.io.File;
3. import java.io.FileInputStream;
4. import java.io.IOException;
5.
6. public class DataOutputStreamDemo{
7. public static void main(String[] args) throws IOException{
8. File file = new File("d:" + File.separator + "hello.txt");
9. DataInputStream input = new DataInputStream(new FileInputStream(file));
10. char[] ch = new char[10];
11. int count = 0;
12. char temp;
13. while((temp = input.readChar()) != 'C'){
14. ch[count++] = temp;
15. }
16. System.out.println(ch);
17. }
18.}
【运行结果】：
AB
合并流 SequenceInputStream
SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.OutputStream;
7. import java.io.SequenceInputStream;
8.
9. /**
10. * 将两个文本文件合并为另外一个文本文件
11. * */
12.public class SequenceInputStreamDemo{
13. public static void main(String[] args) throws IOException{
14. File file1 = new File("d:" + File.separator + "hello1.txt");
15. File file2 = new File("d:" + File.separator + "hello2.txt");
16. File file3 = new File("d:" + File.separator + "hello.txt");
17. InputStream input1 = new FileInputStream(file1);
18. InputStream input2 = new FileInputStream(file2);
19. OutputStream output = new FileOutputStream(file3);
20. // 合并流
21. SequenceInputStream sis = new SequenceInputStream(input1, input2);
22. int temp = 0;
23. while((temp = sis.read()) != -1){
24. output.write(temp);
25. }
26. input1.close();
27. input2.close();
28. output.close();
29. sis.close();
30. }
31.}
【运行结果】
结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。
文件压缩 ZipOutputStream类
先举一个压缩单个文件的例子吧：
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.util.zip.ZipEntry;
7. import java.util.zip.ZipOutputStream;
8.
9. public class ZipOutputStreamDemo1{
10. public static void main(String[] args) throws IOException{
11. File file = new File("d:" + File.separator + "hello.txt");
12. File zipFile = new File("d:" + File.separator + "hello.zip");
13. InputStream input = new FileInputStream(file);
14. ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
15. zipFile));
16. zipOut.putNextEntry(new ZipEntry(file.getName()));
17. // 设置注释
18. zipOut.setComment("hello");
19. int temp = 0;
20. while((temp = input.read()) != -1){
21. zipOut.write(temp);
22. }
23. input.close();
24. zipOut.close();
25. }
26.}
【运行结果】
运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。
不过结果肯定是正确的，我只是提出我的一个疑问而已。
上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.util.zip.ZipEntry;
7. import java.util.zip.ZipOutputStream;
8.
9. /**
10. * 一次性压缩多个文件
11. * */
12.public class ZipOutputStreamDemo2{
13. public static void main(String[] args) throws IOException{
14. // 要被压缩的文件夹
15. File file = new File("d:" + File.separator + "temp");
16. File zipFile = new File("d:" + File.separator + "zipFile.zip");
17. InputStream input = null;
18. ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
19. zipFile));
20. zipOut.setComment("hello");
21. if(file.isDirectory()){
22. File[] files = file.listFiles();
23. for(int i = 0; i < files.length; ++i){
24. input = new FileInputStream(files[i]);
25. zipOut.putNextEntry(new ZipEntry(file.getName()
26. + File.separator + files[i].getName()));
27. int temp = 0;
28. while((temp = input.read()) != -1){
29. zipOut.write(temp);
30. }
31. input.close();
32. }
33. }
34. zipOut.close();
35. }
36.}
【运行结果】
先看看要被压缩的文件吧：
接下来看看压缩之后的：
大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的
1. import java.io.File;
2. import java.io.IOException;
3. import java.util.zip.ZipFile;
4.
5. /**
6. * ZipFile演示
7. * */
8. public class ZipFileDemo{
9. public static void main(String[] args) throws IOException{
10. File file = new File("d:" + File.separator + "hello.zip");
11. ZipFile zipFile = new ZipFile(file);
12. System.out.println("压缩文件的名称为：" + zipFile.getName());
13. }
14.}
【运行结果】：
压缩文件的名称为：d:\hello.zip
现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件(也就是压缩文件中只有一个文件的情况)，我们采用前面的例子产生的压缩文件hello.zip
1. import java.io.File;
2. import java.io.FileOutputStream;
3. import java.io.IOException;
4. import java.io.InputStream;
5. import java.io.OutputStream;
6. import java.util.zip.ZipEntry;
7. import java.util.zip.ZipFile;
8.
9. /**
10. * 解压缩文件（压缩文件中只有一个文件的情况）
11. * */
12.public class ZipFileDemo2{
13. public static void main(String[] args) throws IOException{
14. File file = new File("d:" + File.separator + "hello.zip");
15. File outFile = new File("d:" + File.separator + "unZipFile.txt");
16. ZipFile zipFile = new ZipFile(file);
17. ZipEntry entry = zipFile.getEntry("hello.txt");
18. InputStream input = zipFile.getInputStream(entry);
19. OutputStream output = new FileOutputStream(outFile);
20. int temp = 0;
21. while((temp = input.read()) != -1){
22. output.write(temp);
23. }
24. input.close();
25. output.close();
26. }
27.}
【运行结果】：
解压缩之前：
这个压缩文件还是175字节
解压之后产生：
又回到了56字节，表示郁闷。
现在让我们来解压一个压缩文件中包含多个文件的情况吧
ZipInputStream类当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.OutputStream;
7. import java.util.zip.ZipEntry;
8. import java.util.zip.ZipFile;
9. import java.util.zip.ZipInputStream;
10.
11./**
12. * 解压缩一个压缩文件中包含多个文件的情况
13. * */
14.public class ZipFileDemo3{
15. public static void main(String[] args) throws IOException{
16. File file = new File("d:" + File.separator + "zipFile.zip");
17. File outFile = null;
18. ZipFile zipFile = new ZipFile(file);
19. ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));
20. ZipEntry entry = null;
21. InputStream input = null;
22. OutputStream output = null;
23. while((entry = zipInput.getNextEntry()) != null){
24. System.out.println("解压缩" + entry.getName() + "文件");
25. outFile = new File("d:" + File.separator + entry.getName());
26. if(!outFile.getParentFile().exists()){
27. outFile.getParentFile().mkdir();
28. }
29. if(!outFile.exists()){
30. outFile.createNewFile();
31. }
32. input = zipFile.getInputStream(entry);
33. output = new FileOutputStream(outFile);
34. int temp = 0;
35. while((temp = input.read()) != -1){
36. output.write(temp);
37. }
38. input.close();
39. output.close();
40. }
41. }
42.}
【运行结果】：
被解压的文件：
解压之后再D盘下会出现一个temp文件夹，里面内容：
PushBackInputStream回退流
1. import java.io.ByteArrayInputStream;
2. import java.io.IOException;
3. import java.io.PushbackInputStream;
4.
5. /**
6. * 回退流操作
7. * */
8. public class PushBackInputStreamDemo{
9. public static void main(String[] args) throws IOException{
10. String str = "hello,rollenholt";
11. PushbackInputStream push = null;
12. ByteArrayInputStream bat = null;
13. bat = new ByteArrayInputStream(str.getBytes());
14. push = new PushbackInputStream(bat);
15. int temp = 0;
16. while((temp = push.read()) != -1){
17. if(temp == ','){
18. push.unread(temp);
19. temp = push.read();
20. System.out.print("(回退" + (char) temp + ") ");
21. }else{
22. System.out.print((char) temp);
23. }
24. }
25. }
26.}
【运行结果】：
hello(回退,) rollenholt1. /**
2. * 取得本地的默认编码
3. * */
4. public class CharSetDemo{
5. public static void main(String[] args){
6. System.out.println("系统默认编码为：" + System.getProperty("file.encoding"));
7. }
8. }
【运行结果】：
系统默认编码为：GBK
乱码的产生：1. import java.io.File;
2. import java.io.FileOutputStream;
3. import java.io.IOException;
4. import java.io.OutputStream;
5.
6. /**
7. * 乱码的产生
8. * */
9. public class CharSetDemo2{
10. public static void main(String[] args) throws IOException{
11. File file = new File("d:" + File.separator + "hello.txt");
12. OutputStream out = new FileOutputStream(file);
13. byte[] bytes = "你好".getBytes("ISO8859-1");
14. out.write(bytes);
15. out.close();
16. }
17.}
【运行结果】：
??
一般情况下产生乱码，都是由于编码不一致的问题。
对象的序列化
对象序列化就是把一个对象变为二进制数据流的一种方法。
一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。
先让我们实现一个具有序列化能力的类吧：
1. import java.io.*;
2. /**
3. * 实现具有序列化能力的类
4. * */
5. public class SerializableDemo implements Serializable{
6. public SerializableDemo(){
7.
8. }
9. public SerializableDemo(String name, int age){
10. this.name=name;
11. this.age=age;
12. }
13. @Override
14. public String toString(){
15. return "姓名："+name+" 年龄："+age;
16. }
17. private String name;
18. private int age;
19.}
这个类就具有实现序列化能力，
在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类
先给一个ObjectOutputStream的例子吧：
1. import java.io.Serializable;
2. import java.io.File;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
5. import java.io.ObjectOutputStream;
6.
7. /**
8. * 实现具有序列化能力的类
9. * */
10.public class Person implements Serializable{
11. public Person(){
12.
13. }
14.
15. public Person(String name, int age){
16. this.name = name;
17. this.age = age;
18. }
19.
20. @Override
21. public String toString(){
22. return "姓名：" + name + " 年龄：" + age;
23. }
24.
25. private String name;
26. private int age;
27.}
28./**
29. * 示范ObjectOutputStream
30. * */
31.public class ObjectOutputStreamDemo{
32. public static void main(String[] args) throws IOException{
33. File file = new File("d:" + File.separator + "hello.txt");
34. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
35. file));
36. oos.writeObject(new Person("rollen", 20));
37. oos.close();
38. }
39.}
【运行结果】：
当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。
虽然我们不能直接查看里面的内容，但是我们可以使用ObjectInputStream类查看：
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.ObjectInputStream;
4.
5. /**
6. * ObjectInputStream示范
7. * */
8. public class ObjectInputStreamDemo{
9. public static void main(String[] args) throws Exception{
10. File file = new File("d:" + File.separator + "hello.txt");
11. ObjectInputStream input = new ObjectInputStream(new FileInputStream(
12. file));
13. Object obj = input.readObject();
14. input.close();
15. System.out.println(obj);
16. }
17.}
【运行结果】
姓名：rollen年龄：20
到底序列化什么内容呢?
其实只有属性会被序列化。
Externalizable接口
被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。
当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。
现在我们来演示一下序列化和反序列话：
1. package IO;
2.
3. import java.io.Externalizable;
4. import java.io.File;
5. import java.io.FileInputStream;
6. import java.io.FileOutputStream;
7. import java.io.IOException;
8. import java.io.ObjectInput;
9. import java.io.ObjectInputStream;
10.import java.io.ObjectOutput;
11.import java.io.ObjectOutputStream;
12.
13./**
14. * 序列化和反序列化的操作
15. * */
16.public class ExternalizableDemo{
17. public static void main(String[] args) throws Exception{
18. ser(); // 序列化
19. dser(); // 反序列话
20. }
21.
22. public static void ser() throws Exception{
23. File file = new File("d:" + File.separator + "hello.txt");
24. ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
25. file));
26. out.writeObject(new Person("rollen", 20));
27. out.close();
28. }
29.
30. public static void dser() throws Exception{
31. File file = new File("d:" + File.separator + "hello.txt");
32. ObjectInputStream input = new ObjectInputStream(new FileInputStream(
33. file));
34. Object obj = input.readObject();
35. input.close();
36. System.out.println(obj);
37. }
38.}
39.
40.class Person implements Externalizable{
41. public Person(){
42.
43. }
44.
45. public Person(String name, int age){
46. this.name = name;
47. this.age = age;
48. }
49.
50. @Override
51. public String toString(){
52. return "姓名：" + name + " 年龄：" + age;
53. }
54.
55. // 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
56. @Override
57. public void writeExternal(ObjectOutput out) throws IOException{
58. out.writeObject(this.name);
59. out.writeInt(age);
60. }
61.
62. // 复写这个方法，根据需要读取内容 反序列话的时候需要
63. @Override
64. public void readExternal(ObjectInput in) throws IOException,
65. ClassNotFoundException{
66. this.name = (String) in.readObject();
67. this.age = in.readInt();
68. }
69.
70. private String name;
71. private int age;
72.}
【运行结果】：
姓名：rollen年龄：20
本例中，我们将全部的属性都保留了下来，
Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，
当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：
下面举一个例子：
1. package IO;
2.
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileOutputStream;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
8. import java.io.Serializable;
9.
10./**
11. * 序列化和反序列化的操作
12. * */
13.public class serDemo{
14. public static void main(String[] args) throws Exception{
15. ser(); // 序列化
16. dser(); // 反序列话
17. }
18.
19. public static void ser() throws Exception{
20. File file = new File("d:" + File.separator + "hello.txt");
21. ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
22. file));
23. out.writeObject(new Person1("rollen", 20));
24. out.close();
25. }
26.
27. public static void dser() throws Exception{
28. File file = new File("d:" + File.separator + "hello.txt");
29. ObjectInputStream input = new ObjectInputStream(new FileInputStream(
30. file));
31. Object obj = input.readObject();
32. input.close();
33. System.out.println(obj);
34. }
35.}
36.
37.class Person1 implements Serializable{
38. public Person1(){
39.
40. }
41.
42. public Person1(String name, int age){
43. this.name = name;
44. this.age = age;
45. }
46.
47. @Override
48. public String toString(){
49. return "姓名：" + name + " 年龄：" + age;
50. }
51.
52. // 注意这里
53. private transient String name;
54. private int age;
55.}
【运行结果】：
姓名：null年龄：20
最后在给一个序列化一组对象的例子吧：
1. import java.io.File;
2. import java.io.FileInputStream;
3. import java.io.FileOutputStream;
4. import java.io.ObjectInputStream;
5. import java.io.ObjectOutputStream;
6. import java.io.Serializable;
7.
8. /**
9. * 序列化一组对象
10. * */
11.public class SerDemo1{
12. public static void main(String[] args) throws Exception{
13. Student[] stu = { new Student("hello", 20), new Student("world", 30),
14. new Student("rollen", 40) };
15. ser(stu);
16. Object[] obj = dser();
17. for(int i = 0; i < obj.length; ++i){
18. Student s = (Student) obj[i];
19. System.out.println(s);
20. }
21. }
22.
23. // 序列化
24. public static void ser(Object[] obj) throws Exception{
25. File file = new File("d:" + File.separator + "hello.txt");
26. ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
27. file));
28. out.writeObject(obj);
29. out.close();
30. }
31.
32. // 反序列化
33. public static Object[] dser() throws Exception{
34. File file = new File("d:" + File.separator + "hello.txt");
35. ObjectInputStream input = new ObjectInputStream(new FileInputStream(
36. file));
37. Object[] obj = (Object[]) input.readObject();
38. input.close();
39. return obj;
40. }
41.}
42.
43.class Student implements Serializable{
44. public Student(){
45.
46. }
47.
48. public Student(String name, int age){
49. this.name = name;
50. this.age = age;
51. }
52.
53. @Override
54. public String toString(){
55. return "姓名： " + name + " 年龄：" + age;
56. }
57.
58. private String name;
59. private int age;
60.}
【运行结果】：
姓名： hello年龄：20
姓名： world年龄：30
姓名： rollen年龄：40
提问和评论都可以，用心的回复会被更多人看到
评论
发布评论
相关文章
-
Java IO - 源码: InputStream
本文主要从JDK 11 源码角度分析InputStream。
Java IO/NIO/AIO -
Java NIO - IO多路复用详解
本文主要对IO多路复用，Ractor模型以及Java NIO对其的支持。
Java IO/NIO/AIO -
Java进阶-IO（2）
话接上回，继续java IO部分的学习。上一次说完了字节流的读写数据，这次介绍一下字符流的读写数据。
java 开发语言 后端 intellij-idea 字符流 -
【Java笔记】IO流（2）：字符流
当使用字节流读取文件时，遇到中文字符时，可能不会显示完整的字符，因为一个中文字符可能占用多个字节储存。
java 开发语言 后端 Desktop 字符流
