【JAVA入门】Day38 - IO流

于 2024-09-11 11:17:50 发布
阅读量462 收藏 4
点赞数 19
分类专栏： JAVA入门 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oo00Z00oo/article/details/142063224
版权

【JAVA入门】Day38 - IO流

文章目录

        IO流是存储和读取数据的解决方案。

        File 表示系统中的文件或者文件夹的路径，File类只能对文件本身进行操作，不能读写文件里面存储的数据，因此IO流的出现就是为了读写文件里的数据。
        IO流既可以读写文件中的数据，也可以读取网络中的数据。它可以把文件中的数据写入本地（Output），也可以把文件中的数据读入到程序中（Input）。
        要明确，读和写都是以程序为参照物，是程序在读，程序在写。

一、IO流的分类

        IO流按照流的方向分类，可以分为两种：
在这里插入图片描述

        IO流按照操作文件类型分类，可以分为两种：
在这里插入图片描述
        注意，纯文本文件指的是：Windows 自带的记事本打开能读懂的文件，比如：txt、md、xml、lrc 等，它们可以用字符流的方式处理。而 docx、xls 等文件不是纯文本文件，只能用字节流的方式处理。

二、IO流的体系结构

在这里插入图片描述
        IO流的体系分为字节流和字符流，它们都有自己的输入和输出流，但是这些输入输出流都是抽象类，不能直接创建对象，我们还要分别看它们的子类。
        以字节流为例：
在这里插入图片描述

三、FileOutputStream

        FileOutputStream 是操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。
书写步骤：
① 创建字节输出流对象。
② 写数据。
③ 释放资源。
        下面的代码就是把一个字符’a’输出到本地文件 a.txt 中的过程。

package IOByteStream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
            演示：字节输出流FileOutputStream
            需求：写出一段文字到本地文件中（写出）
            实现步骤：创建对象、写出数据、释放资源
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");

        //2.写出数据
        fos.write(97);

        //3.释放资源
        fos.close();
    }
}

        在输出到文件的过程中存在诸多细节：
1.创建字节输出流对象时，参数可以是字符串表示的路径，也可以是 File 对象。
2.如果参数中的文件不存在会创建一个新的文件，但是一定要保证这个文件的父级路径是存在的。
3.如果文件已存在，会先清空这个文件，再写入。
4.write 方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符，97 --> a。
5.每次使用完流之后，都要释放资源。

3.1 FileOutputStream 写数据的3种方式

        FileOutputStream 写入数据的方式一共有3种，他们是：
在这里插入图片描述
        以下演示三种写出数据方式。

package IOByteStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo2 {
    public static void main(String[] args) throws IOException {
        /*
            写入数据
         */

        //1.创建一个输出流
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");

        //2.写出数据
        //fos.write(97);  //a
        //fos.write(98);  //b

        //一次写多个-->byte数组
        //byte[] bytes = {97,98,99,100,101};
        //fos.write(bytes);

        //一次写一个字节数组的一部分数据   void write(byte[] b, int off, int len)
        //参数一：数组    参数二：起始索引    参数三：字节个数
        byte[] bytes = {97,98,99,100,101};
        fos.write(bytes,1,2);   //b c

        //3.释放资源
        fos.close();
    }
}

3.2 FileOutputStream 写数据的两个问题

3.2.1 换行写
package IOByteStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
            换行写
            Windows换行是 \r\n
            Java中可以写 \r \n 任何一个作为换行符，在底层可以自动补全

            续写
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");

        //2.写出数据
        //kankelaoyezuishuai
        String str1 = "kankelaoyezuishuai";
        byte[] bytes1 = str1.getBytes();
        fos.write(bytes1);

        String br = "\r\n";
        byte[] bytes2 = br.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);


        //3.释放资源
        fos.close();

    }
}
3.2.2 续写

        我们在创建 FileOutputStream 对象时，其实有第二个参数——“续写开关”。

package IOByteStream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo4 {
    public static void main(String[] args) throws IOException {
        /*
            续写开关 boolean append
            在创建对象时,这个变量如果是true,文件就不会清空，可以续写；如果是false，文件就会被覆盖
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt",true);

        //2.写出数据
        //kankelaoyezuishuai
        String str1 = "kankelaoyezuishuai";
        byte[] bytes1 = str1.getBytes();
        fos.write(bytes1);
        
        //3.释放资源
        fos.close();
    }
}

四、FileInputStream

        FileInputStream 字节输入流可以操作本地文件，把里面的数据读取到程序中来。
书写步骤：
        ① 创建字节输入流对象。
        ② 读数据。
        ③ 释放资源。

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo5 {
    public static void main(String[] args) throws IOException {
        /*
            字节流去读
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");

        //2.读数据
        int b1 = fis.read();
        System.out.println(b1);                 //读取一个数据，得到的是97，是字符'a'的ASCII码值
        System.out.println((char)b1);           //强转得到'a'

        //read() 方法是负责读取文件里的数据的，而且是一个一个地读，如果最后读不到了（文件尾），会返回-1

        //3.释放资源
        fis.close();
    }
}

        在输入到程序的过程中，存在诸多细节：
1.如果文件不存在，就直接报错。
2.read 方法一次读一个字节，读出来的是数据在ASCII上对应的数字。
3.每调用一次 read 方法，“指针”往后移动一位。如果读取多次，读到文件末尾了，read 方法返回 -1。
4.每次使用完流必须要释放资源。

4.1 FileInputStream 循环读取

        由于 read 方法每次只能读取一个字节，所以我们要学习循环读取，这样才能读完一个文件中所有的内容。
        定义一个变量 b ，用来存储读到的每一个字符，然后用一个 while 循环打印每一个字符，循环条件用 read() 方法赋值给 b，每进行一次这个赋值，读取字符的“指针”就前进一步，循环直到 read() 方法返回 -1，此时意味着读到了文件尾，循环结束。

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo6 {
    public static void main(String[] args) throws IOException {
        /*
            字节输入流循环读取
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");

        //2.循环读取
        int b;
        while((b = fis.read()) != -1) {
            System.out.print((char)b);
        }

        //3.释放资源
        fis.close();
    }
}

五、文件拷贝

        如何拷贝一个文件？参考下面的代码。

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo7 {
    public static void main(String[] args) throws IOException {
        /*
            文件拷贝
            把D:\IdeaProjects\HelloWord\src\Files\beCopied拷贝到当前模块下

        */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");

        //2.拷贝
        //核心思想：边读边写
        int b;
        while((b = fis.read()) != -1) {
            fos.write(b);
        }

        //3.释放资源
        //规则：先开的流最后再关闭
        fos.close();
        fis.close();

    }
}

        文件拷贝存在一个很严肃的问题，如果拷贝的文件过大，速度会不会有影响？会的，速度非常慢。因为 FileInputStream 在拷贝时，一次只读写一个字节，有多少个字节，就要循环多少次。
        如果想要提高拷贝的速度，就需要一次读取多个字节，它也有相关的方法，看下面的表格：
在这里插入图片描述
        read 方法的重载可以实现一次读取多个字节，我们在拷贝时，可以创建一个较大的数组（最好是1024的整数倍），比如：1024 * 1024 * 5，50MB的数组来进行拷贝。
        在下面的例子中，我们读取了一个文件中的数据，我们使用的是一个2字节的数组，每次读取2个字节的数据，但在最后文件尾，出现了问题，我们在读取新数据时，读取到的字符会替换原数组中的数据，但是在读取文件尾的"e"时，只替换了数组的0索引，而1索引的数据没有被替换，这就导致倒数第二次读取到"cd"，最后一次还是读取到"ed"，这是错误的。

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo8 {
    public static void main(String[] args) throws IOException {
        /*
            public int read(byte[] buffer)      一次读取一个字节数组的数据

         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");

        //2.读取数据
        byte[] bytes = new byte[2];
        //一次读取多个字节数据，具体读多少，跟数组长度有关
        //返回值：本次读取到了多少个字节数据

        //文件里是abcde
        int len1 = fis.read(bytes);
        System.out.println(len1);

        String str1 = new String(bytes);        //len 2
        System.out.println(str1);               //数组：   a   b

        int len2 = fis.read(bytes);
        System.out.println(len2);

        String str2= new String(bytes);         //len 2
        System.out.println(str2);               //数组：   c   d

        int len3 = fis.read(bytes);
        System.out.println(len3);

        String str3= new String(bytes);         //len 1
        System.out.println(str3);               //数组：   e   d

        int len4 = fis.read(bytes);
        System.out.println(len4);

        String str4= new String(bytes);         //len -1
        System.out.println(str4);               //数组：   e   d

        //3.释放资源
        fis.close();
    }
}

        因此我们再读取时，要指定 String() 中读取到的字符串长度，使用new String（byte[] b, int n, int m) 构造方法，保证每次生成的字符串和读取到的字节个数保持一致。如下面的代码：

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo8 {
    public static void main(String[] args) throws IOException {
        /*
            public int read(byte[] buffer)      一次读取一个字节数组的数据

         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");

        //2.读取数据
        byte[] bytes = new byte[2];
        //一次读取多个字节数据，具体读多少，跟数组长度有关
        //返回值：本次读取到了多少个字节数据

        //文件里是abcde
        int len1 = fis.read(bytes);
        System.out.println(len1);

        String str1 = new String(bytes,0,len1);        //len 2
        System.out.println(str1);                            //数组：   a   b      生成的字符串：a    b

        int len2 = fis.read(bytes);
        System.out.println(len2);

        String str2= new String(bytes, 0,len2);         //len 2
        System.out.println(str2);                             //数组：   c   d     生成的字符串：c    d

        int len3 = fis.read(bytes);
        System.out.println(len3);

        String str3= new String(bytes, 0,len3);         //len 1
        System.out.println(str3);                              //数组：   e   d    生成的字符串：e

        int len4 = fis.read(bytes);                            //len -1
        System.out.println(len4);                              //文件尾

        //3.释放资源
        fis.close();
    }
}

        通过一次读取 byte[ ] 中多个字节的数据，我们可以改写文件拷贝，让它变得更简洁：

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo9 {
    public static void main(String[] args) throws IOException {
        /*
            "D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied"拷贝到"D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt"
         */

        long l1 = System.currentTimeMillis();

        //1.创建IO流
        FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");

        //2.一次读取多个字节的数据
        int len;
        byte[] bytes = new byte[1024 * 1024 * 5];
        while((len = fis.read(bytes)) != -1) {
            fos.write(bytes,0, len);            //将bytes[] 数组中 0索引开始 len 长度的数据写入文件
        }

        //3.关闭IO流
        fis.close();
        fos.close();

        long l2 = System.currentTimeMillis();

        System.out.println(l2 - l1);            //用了2毫秒
    }
}

六、捕获IO流异常

        之前在写IO流文件操作时，我们都是用 throws 抛出异常，如果我们想用 try…catch 结构来捕获异常，应该怎么办？

package IOByteStream;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo10 {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");
            fos.write(97);          //如果在这里抛出异常，会导致JVM跳过fos.close()代码
            fos.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

        如果还按之前的结构写，在 write() 方法处如果发生异常抛出，就会导致后续的 fos.close() 方法无法执行，导致流无法释放，因此我们需要完善 try…catch 结构，使用它的完整结构 try…catch…finally。

package IOByteStream;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo10 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");
            fos.write(97);          
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            fos.close();
        }
    }
}

        finally 的特点是：里面的代码一定会被执行，无论是否抛出并捕获异常，最终代码都会执行 { } 里的部分，除非虚拟机被停止（比如 exit() 方法）。
        还有一个细节要注意，FileInputStream 或者 FileOutputStream 流对象要在 try…catch 体系外声明并初始化为 null，因为如果写在 try { } 当中声明，生成的是局部变量，它是无法在 finally { } 结构中使用的，因此先声明，再在 try { } 中接收对象。
        虽然在套入 try…catch…finally 结构之后，fos.close() 语句被放到 finally { } 中一定会执行，但是我们要意识到，fos.close() 语句也是可能发生异常的，这里的异常可能有两种情况：

  • fos = new FileInputStream() 语句中的路径不存在，此时输出通道建立失败，fos 还是 null，如此用 fos 调用 close() 方法就会发生空指针异常。
  • fos.close() 方法本身也可能抛出 IOException 异常。

        因此我们还要对 fos.close() 语句进行单独判断：使用 if 判断 fos 是否为空，如果 fos 还是 null，代表通道建立失败，此时不必释放资源，也就不用调用 close() 方法；如果 fos 非空，可以调用 close() 方法，此时用另一个 try…catch 结构包裹 fos.close() 语句。

package IOByteStream;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo10 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;

        try {
            fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\a.txt");
            fos.write(97);          //如果在这里抛出异常
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null) {
                try {
                    fos.close();
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }             
        }
    }
}

        经过上面的改进，我们可以写出完整的包含异常抛出的文件拷贝代码：

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo11 {
    public static void main(String[] args) {
        /*
            文件拷贝
         */

        //1.创建IO流
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
            fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");

            int len;
            byte[] bytes = new byte[1024 * 1024 * 5];
            while((len = fis.read(bytes)) != -1) {
                fos.write(bytes,0,  len);
            }
        } catch(IOException e) {
            e.printStackTrace();
        } finally {

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

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

        思考上面的完整代码，代码是否过于繁琐？为此，Java 自己也意识到了，于是提供了新的改进方案。
在这里插入图片描述
        通过上面的写法，可以让创建的流对象在使用完以后自动释放资源，但要注意，不是所有的流都可以写在“创建流对象”的位置，只有实现了 AutoCloseable 接口的流对象才可以写在这里（比如我们的 FileOutputStream 和 FileInputStream）。当 try…catch 体系执行完毕之后，系统会自动释放资源。
        JDK7提供的书写方案如下：

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo12 {
    public static void main(String[] args) {
        /*
            fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
            fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");
            JDK7 写法
         */

        try(FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
        FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt")){
            //拷贝代码
            int len;
            byte[] bytes = new byte[1024 * 1024 * 5];
            while((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch(IOException e) {
            e.printStackTrace();
        }

        //无须在finally写释放资源代码，资源会自动释放
    }
}

        JDK9提供的书写方案如下：

package IOByteStream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo13 {
    public static void main(String[] args) throws FileNotFoundException {
        /*
            fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
            fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");
            JDK9 写法 IO流中捕获异常
         */
            FileInputStream fis = new FileInputStream("D:\\IdeaProjects\\HelloWord\\src\\Files\\beCopied");
            FileOutputStream fos = new FileOutputStream("D:\\IdeaProjects\\HelloWord\\src\\IOByteStream\\Copy.txt");
            try(fis;fos){
                //拷贝代码
                int len;
                byte[] bytes = new byte[1024 * 1024 * 5];
                while((len = fis.read(bytes)) != -1) {
                    fos.write(bytes, 0, len);
                }
            } catch(IOException e) {
                e.printStackTrace();
            }

            //无须在finally写释放资源代码，资源会自动释放
    }
}
Clown Piece
关注
  • 19
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day36-IO流03
m0_56069948的博客
09-12 256
节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter数据源就是存放数据的地方，比如文件、数组、字符串、管道等[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fH3tNZ46-1662957840470)(https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/%E8%8A%82%E7%82%B9%E6%B5%81.png)]处理流（也叫包装流。
java boolean io流_java基础入门-day22-IO流
weixin_31659557的博客
02-25 101
(1)I/O:Input/Output(了解)java中对数据的输入输出问题是通过io技术解决的。java提供的对象都在java.io包下。(2)IO的分类(掌握)A:按照数据的流向输入流读取数据输出流写入数据B:按照操作数据的类型字节流字符流为了操作文本的方便，引入的字符流。如果能用记事本打开并能够读懂里面的内容的数据，就可以用字符流。(3)File类(了解)硬盘上数据的存储方式就是文件，所以，...
Java - IO流
从零开始的博客
04-04 249
第一章 File类 1.1 File类的概述 java.io.File类: 用来描述计算机中文件/文件夹/路径的 文件和目录路径名的抽象表示形式。 文件: 用file表示,用来存储数据的 文件夹/目录: 用directory表示,用来存储文件的,管理文件的 路径/地址: 用path表示,用来唯一确定文件/文件夹的具体存储位置 windows系统中,文件/文件夹的路径中有\,但是在java中要表示\需要写\\ 4.2 File类的静态成员 File类中的静态成员: public static S
Java-day14(IO流)
Cat God 007的博客
09-08 231
Java IO流
Java-IO流
lizhiwei21的博客
07-31 909
通过变量,数组,或者集合存储数据都是不能永久化存储 , 因为数据都是存储在内存中只要代码运行结束，所有数据都会丢失使用IO流1，将数据写到文件中，实现数据永久化存储2，把文件中的数据读取到内存中(Java程序)I 表示intput ，是数据从硬盘进内存的过程，称之为读。O 表示output ，是数据从内存到硬盘的过程。称之为写IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作简单来说：内存在读，内存在写。
Java学习Day11------IO流、FileOutputStream、FileInputStream、字节缓冲流
dsh789的博客
11-02 117
IO流、FileOutputStream、FileInputStream、字节缓冲流IO流FileOutputStream类FileInputStream类字节缓冲流 IO流 （1）概述： 输入流：硬盘 ——> 内存 输出流：内存 ——> 硬盘 （2）从数据划分 字节流Byte 操作的是底层的0和1数据 字符流char 操作字符数据 （3）体系图 FileOut
Java入门——IO流
weixin_48719464的博客
03-06 191
转换流提供了在字节流和字符流之间的转换Java API提供了两个转换流：InputStreamReader：将InputStream转换为Reader实现将字节的输入流按指定字符集转换为字符的输入流。需要和InputStream“套接”。构造器如：Reader isr= new InputStreamReader(System.in,”gbk”);OutputStreamWriter：将Writer转换为OutputStream。
java入门day02--流程控制 scanner+选择结构
qq_44110124的博客
02-13 208
一、Scanner对象--注意io类的方法一定要写关闭，scanner.close() next（）方法：不能输出带有空格的字符串，碰到字符串会认为是分隔符或结束符； nextline（）：可输出空字符串。 实例代码 import java.util.Scanner; public class Hello { public static void main(String[] args) { //输入不限定的数字，并求总和、平均数，输入不是数字时停止运算；
java入门——IO流与网络编程
weixin_48719464的博客
03-08 425
通信双方地址IP端口号一定的规则（即：网络通信协议。有两套参考模型）OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。网络通信协议* 一、网络编程中有两个主要的问题：* 1.如何准确地定位网络上一台或多台主机；定位主机上的特定的应用* 2.找到主机后如何可靠高效地进行数据传输* 二、网络编程中的两个要素：* 1.对应问题一：IP和端口号。
day01-Java入门
12-12
【Java入门】 Java是一种广泛使用的高级编程语言，尤其适合于构建企业级应用程序、桌面应用、移动应用（尤其是Android平台）以及Web应用。对于初学者来说，Java具有良好的可读性和简洁的语法，使得它成为学习编程的...
高级软件人才培训专家-day04-SpringBootWeb入门
03-10
- **Spring 官网**: spring.io - **Spring 的子项目**: Spring 提供了多个子项目，每个子项目专注于不同的功能领域，如 Spring Security（安全性）、Spring Data（数据访问）等。 #### 1.2 SpringBoot简介 - **...
Java IO流（超详细！）
热门推荐
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
spring事务详细讲解-深入浅出
小电玩
09-08 433
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1431
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1361
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 460
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 696
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 503
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值