Java的IO流处理与线程

我不是女神ヾ 2023-10-04 13:49 5阅读 0赞

### 今天内容： (1)I/O流 (2)线程 ###

### 1.I/O流 ###

**1.1 FileOutputStream类(重中之重**)  
(1)基本概念  
java.io.FileOutputStream类\*\*主要用于将图像数据之类的原始字节流写入输出流（写）\*\*中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]

(2)常用的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]

**1.2 FileInputStream类(重中之重)**  
(1)基本概念  
java.io.FileInputStream类主要用于**从输入流中读取图像数据之类的原始字节流（读）**。

(2)常用的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]  
DEMO1：  
读取方法一

1：构造FileInputStream类型对象
                FileInputStream fo1 = new FileInputStream("E:/a.txt");
    //            2：通过输入流从文件读取数据内容
                int res=fo1.read();
                System.out.println("读取到的单个字节是："+res+"对应的字符是："+(char)res);
    //            没读完毕一个字节后，可以继续读取下一个字节
                res=fo1.read();
                System.out.println("读取到的单个字节是："+res+"对应的字符是："+(char)res);

读取方法二：

int res=0;
    while ((res=fo1.read())!=-1){
        
          System.out.println("读取到的单个字节是："+res+"对应的字符是："+(char)res);
          }

读取方法三：

byte[] sArr=new byte[20];
    //            read(byte类型的数据，开始下标，读取的字节长度)
                int res =fo1.read(sArr,3,11);
                System.out.println("读取到的数据内容是："
                        + new String(sArr, 3, res)
                        + "，实际读取到的数据大小是：" + res);
                fo1.close();

String回顾：

package Three;
    
    import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
    
    public class StringTest {
        
        public static void main(String[] args) {
        
            // 1.使用无参方式构造String类型的对象并打印  ""  null
            String str1 =new String();
            System.out.println("str1="+str1);//str1 = 啥也没有
            System.out.println("--------------------------------");
            // 2.使用字节数组来构造String对象并打印
            byte[] bArr={
        97,98,99,100,101};
            // 表示使用bArr数组中下标从1开始的3个字节来构造字符串对象
            String str2=new String(bArr,1,3);
            System.out.println("str2="+str2);//str2 = bcd
            String str3=new String(bArr);
            System.out.println("str3="+str3);//str3 = abcde
    
            System.out.println("--------------------------------");
            // 3.使用字符数组来构造String对象并打印
            char[] cArr={
        'h','e','l','l','o'};
            String str4=new String(cArr,1,4);
            System.out.println("str4="+str4);//str4 = el
            String str5=new String(cArr);
            System.out.println("str5="+str5);//str5 = hello
            System.out.println("--------------------------------");
            // 4.使用字符串来构造String对象并打印
            String str6 = new String("world");
            System.out.println("str6 = " + str6); //str6 = world
        }
    
    }

应用：

package StreamTEst;
    
    import java.io.FileInputStream;
    
    
    public class FileInputStreamTest {
        
        public static void main(String[] args)   {
        
            try {
        
    //            1：构造FileInputStream类型对象
                FileInputStream fo1 = new FileInputStream("E:/a.txt");
    //          
                byte[] sArr=new byte[20];
    //            read(byte类型的数据，开始下标，读取的字节长度)
                int res =fo1.read(sArr,3,11);
                System.out.println("读取到的数据内容是："
                        + new String(sArr)
                        + "，实际读取到的数据大小是：" + res);
                fo1.close();//读取到的数据内容是：   a97helloa97      ，实际读取到的数据大小是：11
                byte[] s={
        101,102};
                String x=new String(s,0,1);
                System.out.println("x:"+x);
    
            }catch (Exception e ){
        
                e.printStackTrace();
            }
        }
    }

作业要求：  
使用I/O流实现c:/a.txt到c:/b.txt文件的拷贝功能

import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    
    public class Coyetest {
        
        public static void main(String[] args)  {
        
            try {
        
                FileInputStream str1=new FileInputStream("E:/a.txt");
                FileOutputStream str2=new FileOutputStream("E:/b.txt");
    
                System.out.println("输出ing");
    //                方式一
    //            int res=0;
    //            while ((res=str1.read())!=-1) {
        
    //                str2.write(res);
    //
    //            }
    //            方式二：准备一个和目标文件一样大的缓冲区，一次性全部拷贝完毕
    //                   获取该输入流所关联文件的大小
    //            该方式的缺点：当文件很大时，无法申请和文件大小一样的缓冲区
    //            int len =str1.available();
    //            System.out.println("获取文件的大小是:"+len);
    //            byte[] bArr=new byte[len];
    //            // 表示一次性将文件中的所有内容读取出来放入缓冲区
    //            int res =str1.read(bArr);
    //            System.out.println("实际写入文件的大小是："+res);
    //            // 表示一次性将缓冲区的所有内容写入到输出流中
    //            str2.write(res);
                // 方式三：准备一个适当的缓冲区，每次将缓冲区读满就写入输出流中
                // 以后开发中推荐该方式
                byte[] bArr =new byte[1024*8];
                int res=0;
                while ((res=str1.read())!=-1){
        
                    str2.write(bArr,0,res);
                }
    //            后创建的先关闭
            System.out.println("拷贝文件成功");
            str2.close();
            str1.close();
            }catch (Exception e){
        
                e.printStackTrace();
            }
    
        }
    }

**1.3 BufferedWriter类(重点**)  
(1)基本概念（**抽象类：模版设计模式**）  
java.io.BufferedWriter类主要用于向输出流中**写入单个字符、字符数组以及字符串**

(2)常用的方法

package StreamTEst;
    
    import java.io.BufferedWriter;
    import java.io.FileOutputStream;
    import java.io.OutputStreamWriter;
    
    public class BWtest {
        
        public static void main(String[] args) {
        
            try {
        
                // 1.构造BufferedWriter类型的对象与E:/a.txt文件关联
                //由于BufferedWriter需要一个字符流，所以我下面需要传两次，将字节字符字节转换为流
                BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(
                        new FileOutputStream("E:/a.txt")));
                // 2.向输出流中写入单个字符、字符数组以及字符串
                // 写入单个字符
                bw.write("a");
                char[] cArr={
        'h','e','l','l','0'};
                // 将cArr中下标从1开始的2个字符写入输出流
                bw.write(cArr,1,2);
                // 将cArr整个数组中的所有内容写入输出流
                bw.write(cArr);
                // 将整个字符串写入输出流
                bw.write("world");
                // 将行分隔符写入输出流中
                bw.newLine(); // 换行符
                System.out.println("写入数据成功");
                // 3.关闭流对象并释放有关的资源
    //            其实关闭外面一层就可以了，不需要关闭两层，例如你把你画了妆的女朋友追到手了， 
    //            那她卸了妆你还需要追一遍吗，不需要呀
                bw.close();
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
    }

注意：  
1：文件在硬盘上是字节流  
2：OutputStreamWriter字符流转字节流的桥梁  
3.关闭流对象并释放有关的资源：其实关闭外面一层就可以了，不需要关闭两层，例如你把你画了妆的女朋友追到手了，那她卸了妆你还需要追一遍吗，不需要呀  
**1.4 BufferedReader类(重点)**  
(1)基本概念  
java.io.BufferedReader类主要用于从输入流中读取单个字符、字符数组以及一行字符串内容。

(2)常用的方法  
![加粗样式][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 4]

package StreamTEst;
    
    import java.io.*;
    
    public class BRTest {
        
        public static void main(String[] args) {
        
            try {
        
                // 1.构造BufferedReader类型的对象与c:/a.txt文件关联
                BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("E:/a.txt")));
                // 2.从输入流中读取数据内容并打印出来
                // 以字符为单位读取文件中的所有内容
                // 在windows系统中行分隔符为： \r\n
                /*int res=0;
                while ((res=br.read())!=-1){
                    System.out.println("读取到的字符是："+(char)res+
                            ",对应的ASCLL值为："+res);
                }*/
                // 准备一个字符数组，实现读满字符数组的一部分以及整个字符数组
    //            char[] cArr =new char[20];
    //            // 表示从br中读取15个字符存放到cArr中下标从2开始的位置上
    //            int res= br.read(cArr,2,13);
    //            String str=new String(cArr,2,13);
    //            System.out.println("读取到的数据是："+str+"数据大小是："+res);
    //            int res1= br.read(cArr);
    //            System.out.println("读取到的数据是："+new String(cArr,0,res1 )+"数据大小是："+res1);
                // 一次性读取一行字符串内容
                String str1=br.readLine();
                System.out.println("读取到的数据内容;"+str1);
                // 3.关闭流对象并释放有关的资源
                br.close();
            }catch (Exception e){
        
                e.printStackTrace();
            }
    
        }
    
    }

**1.5 PrintStream类(重点)**  
(1)基本概念  
java.io.PrintStream类**主要用于方便地打印各种数据内容***并且自动刷新*。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 5]

(2)常用的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 6]

package StreamTEst;
    
    import IOTest.FileOutPutStreamTest;
    
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    
    public class PrintStreamTest {
        
        public static void main(String[] args) {
        
            try{
        
           //以字符串的形式向文件中写入内容
            // 1.构造PrintStream类型的对象与c:/a.txt文件关联
            PrintStream pst =new PrintStream(new FileOutputStream("E:/a.txt"));
            // 2.通过该输出流向文件中写入数据内容"hello"
            pst.println("hello");
            System.out.println("写入数据成功！！！");
            // 3.关闭流对象并释放有关的资源
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
    }

**1.6 ObjectOutputStream类(重点)**\----对象转成序列  
(1)基本概念  
java.io.ObjectOutputStream类主要用于**将Java语言中的对象整体写入输出流**中。  
\*\*\*只能将支持 java.io.Serializable 接口的对象写入流中。\*\*\*（重点注意代码中的第二行的序列化写入）  
类通过实现 java.io.Serializable 接口以启用其序列化功能。  
所谓序列化就是指将一个对象相关的所有信息有效组织成字节序列的转化过程。

(2)常用的方法  
Uesr类：

package StreamTEst;
    //需要进行类序列化
    public class Uesr implements java.io.Serializable{
        
        //        编程实现以对象的方式向文件中写入数据
        private String uesrName;
        private String passWord;
        // 使用transient关键字修饰成员变量表示该成员变量不参与序列化的操作
        private transient String phone;    // 用于描述手机号码
        public  Uesr(){
        }
        public Uesr(String uesrName, String passWord, String phone) {
        
            setUesrName( uesrName);
            setPassWord(passWord);
            setPhone(phone);
        }
    
        public String getUesrName() {
        
            return uesrName;
        }
    
        public void setUesrName(String uesrName) {
        
            this.uesrName = uesrName;
        }
    
        public String getPassWord() {
        
            return passWord;
        }
    
        public void setPassWord(String passWord) {
        
            this.passWord = passWord;
        }
    
        public String getPhone() {
        
            return phone;
        }
    
        public void setPhone(String phone) {
        
            this.phone = phone;
        }
    }

ObjectOutputStreamTest类：

package StreamTEst;
    
    import java.io.FileOutputStream;
    import java.io.ObjectOutputStream;
    
    public class ObjectOutputStreamTest {
        
        public static void main(String[] args) {
        
            try {
        
                // 1.构造ObjectOutputStream类型的对象与c:/a.txt文件关联
                ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("E:/a.txt"));
                // 2.准备一个User类型的对象并初始化
                Uesr u =new Uesr("祝祝","123","188861818888");
                // 3.将User类型的对象整体写入到输出流中
                os.writeObject(u);
                System.out.println("数据写入文件成功");
                // 4.关闭流对象并释放有关的资源
                os.close();
    
            }catch (Exception e ){
        
                e.printStackTrace();
            }
        }
    }

**1.7 ObjectInputStream类(重点)**\-----字节转回对象  
(1)基本概念  
java.io.ObjectInputStream类主要用于**从输入流中一次性将一个对象的内容读取出来**  
实现了从字节序列到对象的转化过程，叫做**反序列化。**

(2)常用的方法

package StreamTEst;
    
    import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class ObjectInputStreamTest {
        
        public static void main(String[] args) {
        
            try{
        
                ObjectInputStream ois=new ObjectInputStream( new FileInputStream("E:/a.txt"));
    //            从输入流中读取对象并且打印出来
                Object obj=ois.readObject();
                System.out.println("读取到的对象是："+obj);
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
    }

经验分享：  
当需要**写入多个对象**到文件中时，建议先**将多个对象放入一个集合对象**中，然后**将集合对象看做一个整体**只**需要调用一次writeObject方法**就可以写入所有内容，此时**只需要调用一次readObject方法**就可以将所有内容读取出来，这样就避免了通过返回值来判断是否读取到文件的末尾。

作业：  
1.重点掌握IO流的框架和FileCopyTest.java文件的代码。  
2.不断地提示用户输入要发送的内容，若发送的内容是"bye"则聊天结束，  
否则将用户输入的内容写入到文件c:/a.txt中。  
要求使用BufferedReader类来读取键盘的输入 System.in代表键盘输入  
要求使用PrintStream类负责将数据写入文件  
3.复习所学的所有内容准备下周三的阶段考试。

作业代码：[https://shimo.im/docs/8DGHQxPJGC9GQWgD][https_shimo.im_docs_8DGHQxPJGC9GQWgD]

搞定！！！！  
记得及时复习哟

脚踏实地，方能仰望星空！！！  
宇宙山河烂漫，生活点滴温暖！！！  
道阻且长，行则将至；行而不辍，未来可期!!!

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210518165035623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210518165046359.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210518165143749.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210519154131383.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210519171029142.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210519174236435.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210519174415922.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[https_shimo.im_docs_8DGHQxPJGC9GQWgD]: https://shimo.im/docs/8DGHQxPJGC9GQWgD