IO流简述

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量140 收藏
点赞数
文章标签： java c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55168344/article/details/130076567
版权
本文详细介绍了Java中的IO流，包括输入输出流的标准化过程，节点流如FileReader和FileWriter的使用，以及缓冲流和转换流的作用和典型实现。此外，还涵盖了对象流的序列化和反序列化机制，以及RandomAccessFile的使用。
摘要由CSDN通过智能技术生成

1.IO流概述

1.1 流的分类

 

1.2 流的体系结构

 第一行是四大抽象基类

蓝色框的需要重点关注

1.3 重点说明的几个流结构

1.4 输入输出的标准化过程

1.4.1输入过程

1.实例化File类的对象，指明要操作的文件
2.创建相应的输入流，将File类的对象作为参数，传入流的构造器中
3.数据的读入过程：

        创建相应的byte[ ] 或 char[ ].

4.关闭流资源

说明：程序中出现的异常需用try-catch-finally处理

1.4.2 输出过程

1.实例化File类的对象，指明写出的数据的位置
（不要求此数据一定存在，但上层文件夹必须存在）

2.创建相应的输出流，将File类的对象作为参数，传入流的构造器中

3.数据的读入过程：

int len;

        使用while(流.read()!= -1){

                流.write(byte/char , 0, len)

}

4.关闭流资源

说明：程序中出现的异常需用try-catch-finally处理

2.节点流（文件流）

2.1 FileReader/FileWriter的使用:

2.1.1 FileReader的使用

/*
将day09下的hello.txt文件内容读入程序中，并输出到控制台

说明点：
1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
3. 读入的文件一定要存在，否则就会报FileNotFoundException。

 */
    @Test
    public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file =new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1;
            char[] cbuf = new char[5];
            int len;
           while((len = fr.read(cbuf))!=-1){
           
               String str = new String(cbuf,0,len);
               System.out.println(str);
           }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null)
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

    }

2.1.2 FileWriter的使用

 /*

    从内存中写出数据到硬盘的文件里。

    说明：
    1. 输出操作，对应的File可以不存在的。并不会报异常
    2.
         File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
         File对应的硬盘中的文件如果存在：
                如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖
                如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容

         */
        @Test
    public void testFileWrite() {
            FileWriter fw = null;
            try {
                //1.提供File类的对象，指明写出到的文件
                File file = new File("hello1.txt");

            

                //2.提供FileWriter的对象，用于数据的写出
                fw = new FileWriter(file, false);

                //3.写出的操作
                fw.write("I have a dream!\n");
                fw.write("you need to have a dream!");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                //4.流资源的关闭
                if (fw != null) {

                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

2.1.3 文本文件的复制

  @Test
    public void FileReaderWriterTest()  {
             FileReader fr = null;
             FileWriter fw = null;
             try {
                 //1.创建File类的对象，指明读入和写出的文件
                 File srcFile = new File("hello.txt");
                 File destFile = new File("hello2.txt");

                 //2.创建输入流和输出流的对象
                 fr = new FileReader(srcFile);
                 fw = new FileWriter(destFile);

                 //3.数据的读入和写出操作
                 char[] cbuf = new char[5];
                 int len;//记录每次读入到cbuf数组中的字符的个数
                 while((len = fr.read(cbuf))!=-1){
                     //每次写出len个字符
                     fw.write(cbuf,0,len);

                 }
             } catch (IOException e) {
                 e.printStackTrace();
             } finally {
                 //4.关闭流资源
                 //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
                 //方式二：
                     try {
                         if(fr !=null)
                         fr.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }

                     try {
                         if (fw !=null)
                         fw.close();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
             }

         }

2.2 FileInPutStream/FileOutPutStream的使用：

public void copyFile(String srcPath,String destPath){

    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        File file1 = new File(srcPath);
        File file2 = new File(destPath);

        fis = new FileInputStream(file1);
        fos = new FileOutputStream(file2);
        byte[] buf =new byte[10];
        int len;
        while((len = fis.read(buf))!=-1){
            fos.write(buf,0,len);

        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis !=null)
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        if(fos !=null)
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

    }

}

【注意】

相对路径在IDEA和Eclipse中使用的区别？

IDEA:

如果使用单元测试方法，相对路径基于当前的Module的

如果使用main()测试，相对路径基于当前Project的

Eclipse:

不管使用那种方式，相对路径都是基于当前Project的

3.缓冲流的使用

3.1 缓冲流涉及到的类：

* BufferedInputStream
* BufferedOutputStream
* BufferedReader
* BufferedWriter

3.2 作用：

提高流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区，默认情况下是8kb

3.3 典型代码

3.3.1 使用BufferedInputStream 和BufferedOutputStream:

@Test
    public void BufferedStreamTest()  {
         BufferedInputStream bis = null;
         BufferedOutputStream bos = null;
         try {
             //1.造文件
             File srcFile = new File("爱情与友情.jpg");
             File destFile = new File("爱情与友情3.jpg");
             //2.造流
             //2.1造字节流
             FileInputStream fis =new FileInputStream(srcFile);
             FileOutputStream fos =new FileOutputStream(destFile);
             //2.2造缓冲流
             bis = new BufferedInputStream(fis);
             bos = new BufferedOutputStream(fos);
             //3.复制的细节:读取、写入
             byte[] bf = new byte[10];
             int len;
             while((len =bis.read(bf))!=-1){
                 bos.write(bf,0,len);
                 //bos.flush();//刷新缓冲区
             }
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (bis!=null) {
                 try {
                     bis.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (bos!=null) {
                 try {
                     bos.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }

         }
         //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
     }

3.3.2 使用BufferedReader和BufferedWriter:

 @Test
    public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("helio3.txt")));
            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf))!=-1){
//                bw.write(cbuf,0,len);
//     //           bw.flush();
//            }

            //方式二：使用String
            String data;
            while((data = br.readLine())!=null){ //一次读一行
                //方法一：
//                bw.write(data + "\n" ); //data中不包含换行符
                //方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (br!=null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } if (bw!=null) {
                    try {
                        bw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

            }

        } }
    }

4.转换流的使用

4.1 转换流涉及到的类：

InputStreamReader：将一个字节的输入流转换为字符的输入流
解码：字节、字节数组  --->字符数组、字符串

OutputStreamWriter：将一个字符的输出流转换为字节的输出流
编码：字符数组、字符串 ---> 字节、字节数组

说明：编码决定了解码的方式

4.2 作用：

提供字节流与字符流之间的转换

4.3 图示：

4.4 典型实现：

@Test
public void test2() throws Exception {

    //1.造文件、造流
    File file1 = new File("dbcp.txt");
    File file2 = new File("dbcp_gbk.txt");

    FileInputStream fis = new FileInputStream(file1);
    FileOutputStream fos = new FileOutputStream(file2);

    InputStreamReader isr = new InputStreamReader(fis,"utf-8");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

    //2.读写过程
    char[] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf)) != -1){
        osw.write(cbuf,0,len);
    }

    //3.关闭资源
    isr.close();
    osw.close();

}

4.5 说明：

//文件编码的方式（比如：GBK），决定了解析时使用的字符集（也只能是GBK）。

4.6编码集

4.6.1 常见的编码表

ASCII：美国标准信息交换码。
        用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
        用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

4.6.2 对后面学习的启示

客户端/浏览器端   <--------> 后台（java Go python node.js php）<------->数据库

要求前前后后使用的字符集都要统一：UTF-8

5.其它流的使用

5.1 标准的输入输出流:

System.in:标准的输入流，默认从键盘输入
System.out:标准的输出流，默认从控制台输出

修改默认的输入和输出行为：

System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流

练习：

/*
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
直至当输入“e”或者“exit”时，退出程序。

方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in（字节流）  --->  转换流 ---> BufferedReader(字符流)的readLine()

 */
public static void main(String[] args) { //IDEA的单元测试方法中，不支持在控制台输入数据，需在main()中才能接收
    BufferedReader br = null;
    try {
        InputStreamReader isr = new InputStreamReader(System.in);
        br = new BufferedReader(isr);

        while (true) {
            System.out.println("请输入字符串：");
            String data = br.readLine();
            if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
                System.out.println("程序结束");
                break;
            }

            String upperCase = data.toUpperCase();
            System.out.println(upperCase);

        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            try {
                br.close();//多个流共存，只需关闭最外层的处理流
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

5.2 打印流：

PrintStream 和PrintWriter

说明：

        提供了一系列重载的print() 和 println(),用于多种数据类型的输出
        System.out 返回的是PrintStream的实例

5.3 数据流：

DataInputStream 和 DataOutputStream

作用：用于读取或写出基本数据类型的变量或字符串

示例代码：

/*

练习：将内存中的字符串、基本数据类型的变量写出到文件中。

注意：处理异常的话，仍然应该使用try-catch-finally.
*/

  @Test
  public void test3() throws IOException {
      //1.
      DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
      //2.
      dos.writeUTF("刘建辰");
      dos.flush();//刷新操作，将内存中的数据写入文件
      dos.writeInt(23);
      dos.flush();
      dos.writeBoolean(true);
      dos.flush();
      //3.
      dos.close();

  }


  /*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

  注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！

 */


  @Test
  public void test4() throws IOException {
      //1.
      DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
      //2.
      String name = dis.readUTF();
      int age = dis.readInt();
      boolean isMale = dis.readBoolean();

      System.out.println("name = " + name);
      System.out.println("age = " + age);
      System.out.println("isMale = " + isMale);

      //3.
      dis.close();

  }

6.对象流的使用

6.1 对象流：

ObjectInputStream 和 ObjectOutputStream

6.2 作用：

ObjectOutputStream：

内存中的java对象----> 保存到磁盘中、通过网络传输出去：序列化过程

ObjectInputStream：

磁盘中的文件 、通过网络接收过来----> 内存中的java对象：反序列化过程

6.3 对象的序列化机制：

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从 而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传 输到另一个网络节点。

//当其它程序获取了这种二进制流，就可以恢复成原 来的Java对象

6.4 序列化过程：

/*
序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
使用ObjectOutputStream实现
*/
@Test
public void testObjectOutputStream(){
    ObjectOutputStream oos = null;

    try {
        //1.
        oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
        //2.
        oos.writeObject(new String("我爱北京天安门"));
        oos.flush();//刷新操作

       oos.writeObject(new Person("王铭",23));
        oos.flush();

        oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
        oos.flush();

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(oos != null){
            //3.
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

6.5 反序列化过程：

/*
反序列化：将磁盘文件中的对象还原为内存中的一个java对象
使用ObjectInputStream来实现
*/
@Test
public void testObjectInputStream(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("object.dat"));

        //操作多种数据类型时，读取时的顺序要和写入时的顺序相同
        Object obj = ois.readObject();//读取对象
        String str = (String) obj;//强转

        Person p = (Person) ois.readObject();
        Person p1 = (Person) ois.readObject();

        System.out.println(str);
        System.out.println(p);
        System.out.println(p1);

    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if(ois != null){
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

6.6 实现序列化的对象所属的类需要满足：

1.需要实现接口：Serializable
2.当前类提供一个全局常量：serialVersionUID
3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性
  也必须是可序列化的。（默认情况下，基本数据类型可序列化）
补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

7.RandonAccessFile的使用

7.1 随机存取文件流：RandomAccessFile

7.2 使用说明：

1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。 如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖） 4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果 seek(int pos)

7.3 代码1

@Test
public void test1() {

    RandomAccessFile raf1 = null;
    RandomAccessFile raf2 = null;
    try {
        //1.
        raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
        raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
        //2.
        byte[] buffer = new byte[1024];
        int len;
        while((len = raf1.read(buffer)) != -1){
            raf2.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //3.
        if(raf1 != null){
            try {
                raf1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        if(raf2 != null){
            try {
                raf2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

7.4 代码2

 @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        int len;
        byte[] buffer = new byte[20];
        while((len=raf1.read(buffer))!=-1){
            builder.append(new String(buffer,0,len));
        }
        //调回指针，写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());
        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();

        //思考：将StringBuilder替换为ByteArrayOutputStream
    }
 

8.Path Paths Files的使用

qq_55168344
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
游戏密码123456问题
mql6767521的博客
05-23 1050
java第二版第七章课后题第五题 某人在玩游戏的时候输入密码123456后成功进入游戏（输错5次则被强行退出），要求用程序实现密码验证的过程。 1）使用Sysytem.in包装为字符流读取键盘输入。 2）BufferedReader对字符流进行包装。调用BufferedReader的readLine()方法每次读取一行。 3）在for循环判中判断输入的密码是否为“123456”，如果是则打印“恭喜你进入游戏”，并跳出循环，否则继续循环读取键盘输入。 4）当循环完毕，密码还不正确，则打印“密码错误，结束游戏”
【公益知识库zscc.club】47-IO流(Properties简述).avi
11-09
【公益知识库zscc.club】47-IO流(Properties简述)
I/O流的典型使用方法
Yoara的备忘录
10-10 797
 1.输入缓冲文件    可以使用以String或FIle对象作为文件名的FileReader。为了提高速度，我们将产生的引用传递给BufferedReader构造器用于文件缓冲，由于BufferedReader也提供readline()方法，所以它将是最终文件读取的接口。public class BufferedInputFile { public static String read(
java se基础--I/O流
kunpeng90的博客
03-19 145
IO流1.java.io包下File类:java程序中的此类的一个对象,就对应着硬盘中的一个文件或网络中的一个资源.File file1 = new File("d:\\io||helloworld.txt");File file2 = new File("d:\\io\\io1");&gt;1.File即可以表示一个文件(.doc  .xls .mps  .avi  .jpg .dat),也可以...
java io 性能_java io性能分析
weixin_42506884的博客
02-16 340
摘要：本文大多技术围绕调整磁盘文件 I/O,但是有些内容也同样适合网络 I/O 和窗口输出。第一部分技术讨论底层的I/O问题，然后讨论诸如压缩，格式化和串行化等高级I/O问题。然而这个讨论没有包含应用设计问题，例如搜索算法和数据结构，也没有讨论系统级的问题，例如文件高速缓冲。Java语言采取两种截然不同的磁盘文件结构。一个是基于字节流，另一个是字符序列。在Java 语言中一个字符有两个字节表示，而...
Java IO流简述
安夜的cookie
05-22 175
概述   IO流用来处理设备之间的数据传输，java对数据的操作是通过流的方式，java用于操作流的对象都在IO包中。 分类   1、按数据流向    输入流：读入数据    输出流：读出数据   2、按照数据类型    字节流：    可以读取任何类型的文件    字符流：    只能读取文本文件 IO流基类概述   1、字节流的抽象基类：   InputStream ，OutputStream...
java IO流简述
Andy丁的博客
07-12 7083
1 IO流 1.1 IO流的分类   输入流 输出流 说明 字节流 InputStream OutputStream 字节流是处理字节的（二进制） 字符流 Reader Writer 字符流是处理字符的 注：这几个类都是抽象类。
javan io流简述
Javapengyuyan的博客
01-22 176
Java Io流 IO流用来处理设备之间的数据传输，Java程序中，对于数据的输入/输出操作 都是以“流”的方式进行的。java.io包下提供了各种“流”类的接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 对于计算机来说，数据都是以二进制形式读出或写入的。我们可以把文件想象为一个桶，我们可以通过管道将桶里的水抽出来。这里的管道也就相当于Java中的流。流的本质是一种有序的数据集合，有数据源和目的地。 流的分类 按照流的方向（输出输入都是站在程序所在内存的角度划分的） 输入流：只能从中读数据
IO流简述 [Java]
m0_57001006的博客
12-24 64
IO流概述: 首先我们要知道: IO流中的I表示的是 : Input — 也就是输入流 IO流中的O表示的还是 : Output — 也就是输出流 所以我们的IO流也可以称之为输入输出流 内存中存储的数据是临时的 一旦电脑关闭之后内存中的数据就会消失 举例: 在我们java中数组中和集合中存储的数据都是存储到了内存当中 硬盘中存储的输出时持久的 就算电脑关闭之后硬盘中存储的数据也不会消失 举例: txt文件和jpg文件等等都是存储到了硬盘中 我们这里的输入流中的输入表示的是 : 从硬盘中(持久)
简述IO流
weixin_56177676的博客
04-16 1248
注：本文章由本人整理笔记。参考韩顺平IO流专题链接在此 IO流，就是Input流 (输入流) 和Output流 (输出流) 的简写。JavaIO流根据处理数据类型的不同分为字符流和字节流，根据数据流向不同分为输入流和输出流，对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。 （1）、文件 文件 :文件,对我们并不陌生，文件是保存数据的地方,比如大家经常使用的word文档,txt文件,excel文件..都是文件。它既可以保存一张图...
第10章IO.docx
05-25
1. **简述字符流与字节流的区别** 字节流和字符流的主要区别在于它们处理数据的基本单位不同： - **字节流**：以8位字节为单位，适合处理二进制数据。 - **字符流**：以16位字符为单位，适合处理文本数据。 2...
lymforever.github.io
02-09
在压缩包文件列表中，我们看到的"lymforever.github.io-master"通常代表了项目的主分支，这在GitHub的工作流中非常常见。"master"分支是默认的开发分支，包含了项目的主要代码和资源。打开这个压缩包，我们可能会...
knowapaul.github.io
02-22
7. CSS简介：简述CSS的概念，如何应用样式，以及选择器、属性和值的基本知识。 8. 响应式设计：探讨媒体查询和流式布局，以使网页适应不同设备的屏幕尺寸。 9. JavaScript基础：如果项目包含此部分，可能涉及...
joaoaugustomezentier.github.io
02-26
【描述】描述部分为空，可能意味着这个项目没有提供具体的介绍或者简述。在GitHub上，项目描述通常会包含项目的用途、特点或者使用方法等信息，以便于访问者快速理解其功能和价值。 【标签】"HTML"表明这个项目与...
C++ - 函数重载
jiaowenjie的专栏
08-06 311
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1076
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Spring事务
最新发布
c1tenj2的博客
08-07 425
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 387
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
简述io流的分类以及输入流和输出流作用?
05-25
I/O流是Java中处理输入输出问题的重要组成部分，它是用来处理数据流的。根据数据流的方向，I/O流可以分为输入流和输出流，根据数据类型又可以分为字节流和字符流。 1. 字节流与字符流 字节流：以字节为单位进行数据传输。通常用于处理二进制数据，如图片、音频、视频等。字节流的基类是InputStream和OutputStream。 字符流：以字符为单位进行数据传输。通常用于处理文本数据。字符流的基类是Reader和Writer。 2. 输入流和输出流 输入流：用于从外部读取数据到内存中，可以通过read()方法读取数据。例如，从文件中读取数据到程序中。 输出流：用于从内存中输出数据到外部，可以通过write()方法输出数据。例如，将程序中的数据写入到文件中。 输入流和输出流的基类是InputStream/Reader和OutputStream/Writer。 输入流和输出流的作用： 输入流的主要作用是读取数据，可以从文件、网络等各种输入源中读取数据。 输出流的主要作用是将数据输出到指定的输出源，例如文件、网络等。 总之，I/O流是Java中处理输入输出问题的重要组成部分，可以方便地处理数据流，提高程序的可靠性和效率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值