IO-4

墨蓝 2022-07-29 10:53 161阅读 0赞

**IO-4**

**01\_IO流(序列流)**

\* 1.什么是序列流

\*序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.

\* 2.使用方式

\* 整合两个:SequenceInputStream(InputStream, InputStream)

FileInputStreamfis1 = new FileInputStream("a.txt");     //创建输入流对象,关联a.txt

FileInputStreamfis2 = new FileInputStream("b.txt");     //创建输入流对象,关联b.txt

SequenceInputStreamsis = new SequenceInputStream(fis1, fis2); //将两个流整合成一个流!!!

FileOutputStreamfos = new FileOutputStream("c.txt");         //创建输出流对象,关联c.txt

intb;

while((b= sis.read()) != -1) \{       //用整合后的读

fos.write(b);       //写到指定文件上

sis.close();     //sis在关闭的时候,会将构造方法中传入的流对象也都关闭

fos.close();

**02\_IO流(序列流整合多个)**

\* 整合多个:SequenceInputStream(Enumeration)

FileInputStreamfis1 = new FileInputStream("a.txt"); //创建字节输入流对象,关联a.txt

FileInputStreamfis2 = new FileInputStream("b.txt"); //创建字节输入流对象,关联b.txt

FileInputStreamfis3 = new FileInputStream("c.txt"); //创建字节输入流对象,关联c.txt

Vector<InputStream>v = new Vector<>();        //创建vector集合对象,FileInputStream也行

v.add(fis1);       /将流对象添加

v.add(fis2);

v.add(fis3);

Enumeration<InputStream>en = v.elements();      //获取枚举引用

SequenceInputStreamsis = new SequenceInputStream(en); //传递给SequenceInputStream构造,将枚举中的输入流整合成一个

FileOutputStreamfos = new FileOutputStream("d.txt");

intb;

while((b= sis.read()) != -1) \{

fos.write(b);

sis.close();

fos.close();

**03\_IO流(内存输出流\*\*\*\*\*)**

\* 1.什么是内存输出流

\*该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

\*FileInputStream读取中文的时候出现了乱码解决方案:

\*1,字符流读取

\*2,ByteArrayOutputStream

\* 2.使用方式

\*创建对象: new ByteArrayOutputStream()

\*写出数据: write(int), write(byte\[\])

\*获取数据: toByteArray()

FileInputStreamfis = new FileInputStream("a.txt");

ByteArrayOutputStreambaos = new ByteArrayOutputStream();   //在内存中创建了可以增长的内存数组

intb;

while((b= fis.read()) != -1) \{

baos.write(b);

//byte\[\]newArr = baos.toByteArray();    //将内存缓冲区中所有的字节存储在newArr中

//System.out.println(newString(newArr));

System.out.println(baos);

fis.close();  //baos不用关因为它是在内存中创建的,用完就释放了,而流之所以要关,是因为流相当于在内存和硬盘之间建立了一条管道!!!!!!!!

**04\_IO流**

\* 定义一个文件输入流,调用read(byte\[\]b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

\* 分析:

\* 1,reda(byte\[\] b)是字节输入流的方法,所以创建FileInputStream,关联a.txt

\* 2,创建内存输出流,将读到的数据写到内存输出流中

\* 3,创建字节数组,长度为5

\* 4,将内存输出流的数据全部转换为字符串打印

\* 5,关闭输入流

publicstatic void main(String\[\] args) throws IOException \{

//1,reda(byte\[\]b)是字节输入流的方法,创建FileInputStream,关联a.txt

FileInputStreamfis = new FileInputStream("a.txt");

//2,创建内存输出流,将读到的数据写到内存输出流中

ByteArrayOutputStreambaos = new ByteArrayOutputStream();

//3,创建字节数组,长度为5

byte\[\]arr = new byte\[5\];

intlen;

while((len= fis.read(arr)) != -1) \{

baos.write(arr,0, len);

//System.out.println(newString(arr,0,len));  //会乱码!!!!!!

//4,将内存输出流的数据全部转换为字符串打印

System.out.println(baos);      //即使没有调用,底层也会默认帮我们调用toString()方法

//5,关闭输入流

fis.close();

**05\_IO流(对象操作流ObjecOutputStream)**

\* 1.什么是对象操作流

\*该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

\*序列化:将对象写到文件上,也就是我把这些数据按照某种规定写到文档上去,反序列化就是我把写过去的数据再翻译过来,翻译成对应的对象去使用了

\*注:如果想执行序列化,对象类必须实现Serializable接口!!!!!!

\* 2.使用方式

\*写出: new ObjectOutputStream(OutputStream), writeObject()

public class Demo3\_ObjectOutputStream \{

\* 将对象写出,序列化

publicstatic void main(String\[\] args) throws IOException \{

Personp1 = new Person("张三", 23);

Personp2 = new Person("李四", 24);

//      FileOutputStream fos = newFileOutputStream("e.txt");

//      fos.write(p1);

//      FileWriter fw = newFileWriter("e.txt");

//      fw.write(p1);

//无论是字节输出流,还是字符输出流都不能直接写出对象

ObjectOutputStreamoos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流,e,txt中的内容看不懂正常,只要系统能读出来就好!!!!!

oos.writeObject(p1);

oos.writeObject(p2);

oos.close();

**06\_IO流(对象操作流ObjectInputStream)(**

\* 读取: newObjectInputStream(InputStream), readObject()

publicclass Demo3\_ObjectInputStream \{

/\*\*

\* @param args

\* @throws IOException

\* @throws ClassNotFoundException

\* @throws FileNotFoundException

\* 读取对象,反序列化

\*/

publicstatic void main(String\[\] args) throws IOException, ClassNotFoundException \{

ObjectInputStreamois = new ObjectInputStream(new FileInputStream("e.txt"));

Personp1 = (Person) ois.readObject();    //转换数据类型!!!!!

Personp2 = (Person) ois.readObject();

System.out.println(p1);

System.out.println(p2);

ois.close();

**07\_IO流(对象操作流优化)**

\*　将对象存储在集合中写出

Personp1 = new Person("张三", 23);

Personp2 = new Person("李四", 24);

Personp3 = new Person("马哥", 18);

Personp4 = new Person("辉哥", 20);

ArrayList<Person>list = new ArrayList<>();

list.add(p1);

list.add(p2);

list.add(p3);

list.add(p4);

ObjectOutputStreamoos = new ObjectOutputStream(new FileOutputStream("f.txt"));

oos.writeObject(list);                //把整个集合对象一次写出

oos.close();

\* 读取到的是一个集合对象

ObjectInputStreamois = new ObjectInputStream(new FileInputStream("f.txt"));

ArrayList<Person>list = (ArrayList<Person>)ois.readObject();       //将集合对象一次读取,泛型在运行期会被擦除,索引运行期相当于没有泛型

//想去掉黄色可以加注解               @SuppressWarnings("unchecked")

for(Person person : list) \{

//System.out.println(person);  //遍历集合!!

System.out.println(person.getName()+ "..." +person.getAge());

ois.close();

**08\_IO流(加上id号)**

\* 注意

\*要写出的对象必须实现Serializable接口才能被序列化

\*不用必须加id号(加上就是可以在报错的时候看的更清晰一些,不加报错的时候会随机生成一长串id号)

**09\_IO流(打印流的概述和特点)**

\* PrintStream和PrintWriter分别是打印的字节流和字符流

\* 1.什么是打印流

\*该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式

\*System.out就是一个PrintStream, 其默认向控制台输出信息,PrintStream打印的是字节流!!!

System.out.println("aaa");

PrintStreamps = System.out;   //获取标注输出流

ps.println(97); //其实底层用的是Integer.toString(x),将x转换为数字字符串打印97

ps.write(97);             //查找码表,找到对应的a并打印

ps.println("xxx");

ps.println(newPerson("张三", 23));

Personp = null;

ps.println(p);    //如果是null,就返回null,如果不是null,就打印对象的toString()

\* 2.使用方式

\*打印: print(), println()

\*自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding) 打印字符流!!!

\*打印流只操作数据目的

PrintWriterpw = new PrintWriter(new FileOutputStream("g.txt"), true);//true代表可以自动刷出!!!

pw.write(97);

pw.print("大家好");

pw.println("你好"); //自动刷出,只针对的是println方法,对其他方法不管用,但如果将其放在最后位置,则都能刷出!!!

pw.close();

**10\_IO流(标准输入输出流概述和输出语句)**

\* 1.什么是标准输入输出流(掌握)

\*System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据

\*System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据

\* 2.修改标准输入输出流(了解)

\*修改输入流: System.setIn(InputStream)

\*修改输出流: System.setOut(PrintStream)

System.setIn(newFileInputStream("a.txt")); //修改标准输入流

System.setOut(newPrintStream("b.txt"));     //修改标准输出流

InputStreamin = System.in;    //获取标准输入流

PrintStreamps = System.out; //获取标准输出流

intb;

while((b= in.read()) != -1) \{               //从a.txt上读取数据

ps.write(b);      //将数据写到b.txt上

in.close();

ps.close();

\*注:System.out.println();也是一个输出流,不用关,因为没有和硬盘上的文件产生关联的管道,只有产生了相关联的管道才关!!!

**11\_IO流(修改标准输入输出流拷贝图片)(了解)   开发中不推荐使用!!!**

System.setIn(newFileInputStream("IO图片.png"));               //改变标准输入流

System.setOut(newPrintStream("copy.png"));              //改变标准输出流

InputStreamis = System.in;    //获取标准输入流

PrintStreamps = System.out; //获取标准输出流

intlen;

byte\[\]arr = new byte\[1024 \* 8\];

while((len= is.read(arr)) != -1) \{

ps.write(arr,0, len);

is.close();

ps.close();

**11\_IO流(两种方式实现键盘录入)**

\* A:BufferedReader的readLine方法。

//InputStreamReader是转换流,是是字节到字符转换的桥梁,将System.in读取的字节数据转换成字符数据!!!这就相当于设计模式..对System.in进行包装

\*BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

Stringline = br.readLine();

System.out.println(line);

br.close();

\* B:Scanner (这种更好,功能更强大!!!)

Scannersc = new Scanner(System.in);

Stringline = sc.nextLine();

System.out.println(line);

sc.close();

**12\_IO流(随机访问流概述和读写数据)**

\* A:随机访问流概述

\*RandomAccessFile概述

随机访问流可以在指定位置去写,指定位置去读

\*RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。

\*支持对随机访问文件的读取和写入。

\* B:read(),write(),seek()//设置指针的方法

RandomAccessFileraf = new RandomAccessFile("g.txt", "rw");

//raf.write(97);     写到文件中的是a

//intx = raf.read();

//System.out.println(x);   输出97

raf.seek(10);        //在指定位置设置指针

raf.write(98);      //在10的位置写入b

raf.close();

**13\_IO流(数据输入输出流)**

\* 1.什么是数据输入输出流

\*DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据(读写各种基本数据类型!!! )

\*例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.

FileOutputStreamfos = new FileOutputStream("h.txt");

fos.write(997);

fos.write(998);

//h.txt中会乱码,且只有两个字节,因为997不在-128--127之间,并且调用write时会自动砍掉前24位!!!

fos.close();

\* 2.使用方式

\*DataOutputStream(OutputStream), writeInt(), writeLong()

DataOutputStreamdos = new DataOutputStream(new FileOutputStream("b.txt"));

dos.writeInt(997);

dos.writeInt(998);

dos.writeInt(999);

dos.close();

\*DataInputStream(InputStream), readInt(), readLong()

DataInputStreamdis = new DataInputStream(new FileInputStream("b.txt"));

intx = dis.readInt();

inty = dis.readInt();

intz = dis.readInt();

System.out.println(x);

System.out.println(y);

System.out.println(z);

dis.close();

**14\_IO流(Properties的概述和作为Map集合的使用)**

\* A:Properties的概述

\*Properties 类表示了一个持久的属性集。

\*Properties 可保存在流中或从流中加载。

\*属性列表中每个键及其对应值都是一个字符串。

\* B:案例演示,Properties作为Map集合的使用

**15\_IO流(Properties的特殊功能使用)**

\* A:Properties的特殊功能  是双列集合,在开发中当作配置文件存储一些信息

\*public Object setProperty(String key,String value)

\*public String getProperty(String key)

\*public Enumeration<String> stringPropertyNames()

\* B:案例演示

\*Properties的特殊功能

Propertiesprop = new Properties();

prop.setProperty("name","张三");

prop.setProperty("tel","18912345678");

//System.out.println(prop);

Enumeration<String>en = (Enumeration<String>) prop.propertyNames();

while(en.hasMoreElements())\{

Stringkey = en.nextElement();                  //获取Properties中的每一个键

Stringvalue = prop.getProperty(key);               //根据键获取值

System.out.println(key+ "="+ value);

**16\_IO流(Properties的load()和store()功能)**

\* A:Properties的load()读取和store()写出功能

\* B:案例演示

\*Properties的load()和store()功能

Propertiesprop = new Properties();

prop.load(newFileInputStream("config.properties"));   //将文件上的键值对读取到集合中,文件中键和值用:或=去连接!!!

prop.setProperty("tel","18912345678");   //只是在内存中改了,但并没有写到配置文件中,写到文件中用store方法!!!

prop.store(newFileOutputStream("config.properties"), null);//第二个参数是对列表参数的描述,可以给值及一段字符串,也可以给null!!!

System.out.println(prop);

\*注:附config.properties,配置文件内容格式如下:

qq=12345

tel=18912345678

username=zhangsan

IO-4

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 4.文件操作和IO

相关 Java-基础-4.IO流

相关 4种常见的IO模型（阻塞IO和非阻塞IO、同步IO和异步IO）

相关计算机组成原理（4）IO

相关 UE4 IOS Launch

相关 Java IO4：字符编码

相关 ios入门4_运算符

相关 IO-4

相关 UE4 IOS 打包

相关 4中IO模型介绍