IO技术二（常用流）

最新推荐文章于 2024-09-25 11:06:23 发布
最新推荐文章于 2024-09-25 11:06:23 发布
阅读量697 收藏 20
点赞数 33
分类专栏： Java入门 文章标签： 开发语言 java IO技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48205251/article/details/137174063
版权

目录

文件字节流

将字符串/字节数组的内容写入到文件中

利用文件流实现文件的复制

文件字符流

使用 FileReader 与 FileWriter 实现文本文件的复制

缓冲字节流

使用缓冲流实现文件的高效率复制

缓冲字符流

使用 BufferedReader 与 BufferedWriter 实现文本文件的复制

字节数组流

简单测试 ByteArrayInputStream 的使用

数据流

DataInputStream 和 DataOutputStream 的使用

对象流

ObjectInputStream/ObjectOutputStream 的使用

转换流

使用 InputStreamReader 接收用户的输入，并输出到控制台

随意访问文件流

RandomAccessFile 的使用

文件字节流

        FileInputStream 通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文 本文件等）。Java 也提供了 FileReader 专门读取文本文件。

        FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。Java 也提 供了 FileWriter 专门写入文本文件。

将字符串/字节数组的内容写入到文件中

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

public class TestFileOutputStream {
    public static void main(String[ ] args) {
        FileOutputStream fos = null;
        String string = "欢迎学习Java！";
        try {
            // true 表示内容会追加到文件末尾；false 表示重写整个文件内容。
            fos = new FileOutputStream("d:/a.txt", true);
            //该方法是直接将一个字节数组写入文件中; 而 write(int n)是写入一个字节
            fos.write(string.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

        用到一个 write 方法：void write(byte[ ] b)，该方法不再一个字节一个字节地写入，而是直接写入一个字节数组；另外其还有一个重载的方法：void write(byte[ ] b, int off, int length)，这个方法也是写入一个字节数组，但是我们程序员可以指定从字节数组 的哪个位置开始写入，写入的长度是多少。

利用文件流实现文件的复制

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

public class TestFileCopy {

    public static void main(String[ ] args) {
        //将 a.txt 内容拷贝到 b.txt
        copyFile("d:/a.txt", "d:/b.txt");
    }
    
    /**
     * 将 src 文件的内容拷贝到 dec 文件
     * @param src 源文件
     * @param dec 目标文件
     */
    static void copyFile(String src, String dec) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        //为了提高效率，设置缓存数组！（读取的字节数据会暂存放到该字节数组中）
        byte[ ] buffer = new byte[1024];
        int temp = 0;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dec);
            //边读边写
            //temp 指的是本次读取的真实长度，temp 等于-1 时表示读取结束
            while ((temp = fis.read(buffer)) != -1) {
                /*将缓存数组中的数据写入文件中，注意：写入的是读取的真实长度；
                 *如果使用 fos.write(buffer)方法，那么写入的长度将会是 1024，即缓存
                 *数组的长度*/
                fos.write(buffer, 0, temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //两个流需要分别关闭
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在使用文件字节流时，我们需要注意以下两点：

  1. 为了减少对硬盘的读写次数，ᨀ高效率，通常设置缓存数组。相应地，读取时使用的方 法为：read(byte[ ] b)；写入时的方法为：write(byte[ ] b, int off, int length)。
  2. 程序中如果遇到多个流，每个流都要单独关闭，防止其中一个流出现异常后导致其他流 无法关闭的情况。

文件字符流

        文件字节流可以处理所有的文件，但是字节流不能很好的处理 Unicode 字 符，经常会出现“乱码”现象。所以，我们处理文本文件，一般可以使用文件字符流，它以字符为单位进行操作。

使用 FileReader 与 FileWriter 实现文本文件的复制

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestFileCopy2 {
    public static void main(String[ ] args) {
        // 写法和使用 Stream 基本一样。只不过，读取时是读取的字符。
        FileReader fr = null;
        FileWriter fw = null;
        int len = 0;
        try {
            fr = new FileReader("d:/a.txt");
            fw = new FileWriter("d:/d.txt");
            //为了提高效率，创建缓冲用的字符数组
            char[ ] buffer = new char[1024];
            //边读边写
            while ((len = fr.read(buffer)) != -1) {
                fw.write(buffer, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

缓冲字节流

        Java 缓冲流本身并不具有 IO 流的读取与写入功能，只是在别的流（节点流或其他处理 流）上加上缓冲功能ᨀ高效率，就像是把别的流包装起来一样，因此缓冲流是一种处理流（包 装流）。

        当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就 能够更高效的读写信息。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷 新时再一次性的读取到程序或写入目的地。

        因此，缓冲流还是很重要的，我们在 IO 操作时记得加上缓冲流来ᨀ升性能。

        BufferedInputStream 和 BufferedOutputStream 这两个流是缓冲字节流，通过内部缓存数 组来提高操作流的效率。

使用缓冲流实现文件的高效率复制

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

public class TestBufferedFileCopy1 {

    public static void main(String[ ] args) {
        // 使用缓冲字节流实现复制
        long time1 = System.currentTimeMillis();
        copyFile1("D:/电影/你的电影.mkv", "D:/电影/你的电影1.mkv");
        long time2 = System.currentTimeMillis();
        System.out.println("缓冲字节流花费的时间为：" + (time2 - time1));
        // 使用普通字节流实现复制
        long time3 = System.currentTimeMillis();
        copyFile2("D:/电影/你的电影.mkv", "D:/电影/你的电影2.mkv");
        long time4 = System.currentTimeMillis();
        System.out.println("普通字节流花费的时间为：" + (time4 - time3));
    }

    /**
     * 缓冲字节流实现的文件复制的方法
     * @param src
     * @param dec
     */
    static void copyFile1(String src, String dec) {
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        int temp = 0;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dec);
            //使用缓冲字节流包装文件字节流，增加缓冲功能，提高效率
            //缓存区的大小（缓存数组的长度）默认是 8192，也可以自己指定大小
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            while ((temp = bis.read()) != -1) {
                bos.write(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //注意：增加处理流后，注意流的关闭顺序！“后开的先关闭！”
            try {
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 普通节流实现的文件复制的方法
     * @param src
     * @param dec
     */
    static void copyFile2(String src, String dec) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        int temp = 0;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dec);
            while ((temp = fis.read()) != -1) {
                fos.write(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

copyFile2 好几分钟都没复制完，我强制停止了

在关闭流时，应该先关闭最外层的包装流，即“后开的先关闭”。

缓存区的大小默认是 8192 字节，也可以使用其它的构造方法自己指定大小。

缓冲字符流

        BufferedReader/BufferedWriter 增加了缓存机制，大大ᨀ高了读写文本文件的效率，同时， 提供了更方便的按行读取的方法：readLine(); 处理文本时，我们一般可以使用缓冲字符流。

使用 BufferedReader 与 BufferedWriter 实现文本文件的复制

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferedFileCopy2 {
    public static void main(String[] args) {
        // 注：处理文本文件时，实际开发中可以用如下写法，简单高效！！
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        String tempString = "";
        try {
            fr = new FileReader("d:/a.txt");
            fw = new FileWriter("d:/d.txt");
            //使用缓冲字符流进行包装
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            //BufferedReader 提供了更方便的 readLine()方法，直接按行读取文本
            //br.readLine()方法的返回值是一个字符串对象，即文本中的一行内容
            while ((tempString = br.readLine()) != null) {
                //将读取的一行字符串写入文件中
                bw.write(tempString);
                //下次写入之前先换行，否则会在上一行后边继续追加，而不是另起一行
                bw.newLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bw != null) {
                    bw.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

readLine()方法是 BufferedReader 特有的方法，可以对文本文件进行更加方便的读取操作。

写入一行后要记得使用 newLine()方法换行。

字节数组流

        ByteArrayInputStream 和 ByteArrayOutputStream 经常用在需要流和数组之间转化的情 况！

        说白了，FileInputStream 是把文件当做数据源。ByteArrayInputStream 则是把内存中的” 某个字节数组对象”当做数据源。

简单测试 ByteArrayInputStream 的使用

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class TestByteArray {

    public static void main(String[ ] args) {
        //将字符串转变成字节数组
        byte[ ] b = "abcdefg".getBytes();
        test(b);
    }

    public static void test(byte[ ] b) {
        ByteArrayInputStream bais = null;
        StringBuilder sb = new StringBuilder();
        int temp = 0;
        //用于保存读取的字节数
        int num = 0;
        try {
            //该构造方法的参数是一个字节数组，这个字节数组就是数据源
            bais = new ByteArrayInputStream(b);
            while ((temp = bais.read()) != -1) {
                sb.append((char) temp);
                num++;
            }
            System.out.println(sb);
            System.out.println("读取的字节数：" + num);
        } finally {
            try {
                if (bais != null) {
                    bais.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

数据流

        数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式 从底层输入输出流中操作 Java 基本数据类型与字符串类型。

        DataInputStream 和 DataOutputStream ᨀ供了可以存取与机器无关的所有 Java 基础类型 数据（如：int、double、String 等）的方法。

        DataInputStream 和 DataOutputStream 是处理流，可以对其他节点流或处理流进行包装， 增加一些更灵活、更高效的功能。

DataInputStream 和 DataOutputStream 的使用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataStream {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        DataInputStream dis = null;
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try {
            fos = new FileOutputStream("D:/data.txt");
            fis = new FileInputStream("D:/data.txt");
            //使用数据流对缓冲流进行包装，新增缓冲功能
            dos = new DataOutputStream(new BufferedOutputStream(fos));
            dis = new DataInputStream(new BufferedInputStream(fis));
            //将如下数据写入到文件中
            dos.writeChar('a');
            dos.writeInt(10);
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            dos.writeUTF("心目中的Java大学");
            //手动刷新缓冲区：将流中数据写入到文件中
            dos.flush();
            //直接读取数据：读取的顺序要与写入的顺序一致，否则不能正确读取数据。
            System.out.println("char: " + dis.readChar());
            System.out.println("int: " + dis.readInt());
            System.out.println("double: " + dis.readDouble());
            System.out.println("boolean: " + dis.readBoolean());
            System.out.println("String: " + dis.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(dos!=null){
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(dis!=null){
                    dis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fis!=null){
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用数据流时，读取的顺序一定要与写入的顺序一致，否则不能正确读取数据。

对象流

        数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象 （字符串除外），如果要对某个对象进行读写操作，我们需要学习一对新的处理流： ObjectInputStream/ObjectOutputStream。

        ObjectInputStream/ObjectOutputStream 是以“对象”为数据源，但是必须将传输的对象进 行序列化与反序列化操作。

ObjectInputStream/ObjectOutputStream 的使用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Date;

public class TestObjectStream {
    public static void main(String[] args) {
        write();
        read();
    }
    /**
     * 使用对象输出流将数据写入文件
     */
    public static void write(){
        // 创建 Object 输出流，并包装缓冲流，增加缓冲功能
        OutputStream os = null;
        BufferedOutputStream bos = null;
        ObjectOutputStream oos = null;
        try {
            os = new FileOutputStream(new File("d:/bjsxt.txt"));
            bos = new BufferedOutputStream(os);
            oos = new ObjectOutputStream(bos);
            // 使用 Object 输出流
            //对象流也可以对基本数据类型进行读写操作
            oos.writeInt(12);
            oos.writeDouble(3.14);
            oos.writeChar('A');
            oos.writeBoolean(true);
            oos.writeUTF("哪都通大学");
            //对象流能够对对象数据类型进行读写操作
            //Date 是系统ᨀ供的类，已经实现了序列化接口
            //如果是自定义类，则需要自己实现序列化接口
            oos.writeObject(new Date());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭输出流
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 使用对象输入流将数据读入程序
     */
    public static void read() {
        // 创建 Object 输入流
        InputStream is = null;
        BufferedInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            is = new FileInputStream(new File("d:/bjsxt.txt"));
            bis = new BufferedInputStream(is);
            ois = new ObjectInputStream(bis);
            // 使用 Object 输入流按照写入顺序读取
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());
            System.out.println(ois.readChar());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readUTF());
            System.out.println(ois.readObject().toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭 Object 输入流
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

转换流

        InputStreamReader/OutputStreamWriter 用来实现将字节流转化成字符流。比如，如下场 景：

        System.in 是字节流对象，代表键盘的输入，如果我们想按行接收用户的输入时，就必 须用到缓冲字符流 BufferedReader 特有的方法 readLine()，但是经过观察会发现在创建 BufferedReader 的 构 造 方 法 的 参 数 必 须 是 一 个 Reader 对 象 ， 这 时 候 我 们 的 转 换 流 InputStreamReader 就派上用场了。

        而 System.out 也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将 读取的一行字符串直接显示到控制台，就需要用到字符流的 write(String str)方法，所以我们 要使用 OutputStreamWriter 将字节流转化为字符流。

使用 InputStreamReader 接收用户的输入，并输出到控制台

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class TestConvertStream {
    public static void main(String[] args) {
        // 创建字符输入和输出流:使用转换流将字节流转换成字符流
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
            // 使用字符输入和输出流
            String str = br.readLine();
            // 一直读取，直到用户输入了 exit 为止
            while (!"exit".equals(str)) {
                // 写到控制台
                bw.write(str);
                bw.newLine();// 写一行后换行
                bw.flush();// 手动刷新
                // 再读一行
                str = br.readLine();
            }
        } 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();
                }
            }
        }
    }
}

随意访问文件流

RandomAccessFile 可以实现两个作用：

  1. 实现对一个文件做读和写的操作。
  2. 可以访问文件的任意位置。不像其他流只能按照先后顺序读取。

        在开发某些客户端软件时，经常用到这个功能强大可以”任意操作文件内容”的类。比如， 软件的使用次数和使用日期，可以通过本类访问文件中保存次数和日期的地方进行比对和修 改。 Java 很少开发客户端软件，所以在 Java 开发中这个类用的相对较少。

学习这个流我们需掌握三个核心方法：

  1. RandomAccessFile(String name, String mode) name 用来确定文件； mode 取 r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
  2. seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头 的字节个数。
  3. getFilePointer() 获得流的当前读写位置。

RandomAccessFile 的使用

import java.io.IOException;
import java.io.RandomAccessFile;

public class TestRandomStream {
    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try {
            // 将若干数据写入到 a.txt 文件
            int[ ] data = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
            raf = new RandomAccessFile("d:/a.txt", "rw");
            for (int i = 0; i < data.length; i++) {
                raf.writeInt(data[i]);
            }
            // 直接从 a.txt 中读取数据，位置为从 36 字节开始。
            raf.seek(4);
            System.out.println(raf.readInt()); // 读取 4 个字节（int 为 4 个字节）
            // 直接从 a.txt 中读取数据，隔一个读一个数据
            for (int i = 0; i < 10; i += 2) {
                raf.seek(i * 4);
                System.out.print(raf.readInt() + "\t");
            }
            System.out.println(); // 换行
            // 在 8 字节处插入一个新数据 45，替换以前的数据 30
            raf.seek(8);
            raf.writeInt(45);
            for (int i = 0; i < 10; i++) {
                raf.seek(i * 4);
                System.out.print(raf.readInt() + "\t");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf != null) {
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Link_Zero
关注
专栏目录
java——IO流技术.pdf
04-03
### Java IO流技术详解 #### 一、IO流概述 在Java编程中，**IO流**(Input/Output Stream)主要用于实现数据的输入与输出操作。无论是文件读写、网络通信还是程序间的交互，几乎所有的数据交换都依赖于IO流。 #####...
Java-IO流/Stream流总结
07-12
Java的IO流与Stream流是Java程序中处理输入输出的核心技术。IO流主要分为字节流和字符流，这两种流分别处理二进制数据（如图片、音频等）和文本数据（如ASCII、UTF-8编码的文本）。下面将详细阐述这两个流的分类、...
文档JAVA-IO流
02-19
### 文档JAVA-IO流 #### 一、IO流概述 1. **什么是IO** - I代表**输入**(input)，O代表**输出**...通过上述知识点的学习，我们可以更好地理解和应用Java中的IO流技术，尤其是在处理文件读写以及文本处理方面。
JAVA IO流技术
09-19
Java IO流技术是Java平台中用于处理输入输出的重要机制，其核心在于数据的传输，从数据源到程序或从程序到目的地。在Java中，流分为两大类：输入流（InputStream、Reader）和输出流（OutputStream、Writer）。输入流...
java高级特性 - io流.pdf
05-29
然后，创建文件夹也是IO流常用的功能之一。示例中展示了如何使用File类的mkdir方法来创建一个新的目录。在创建目录时，同样应该注意跨平台的问题，使用separator和pathSeparator来确保代码的兼容性。 对于列出目录...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1176
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
工厂模式的介绍及实现
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 547
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 220
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 426
Android的系统结构的设计混合了分层设计和分块设计。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 716
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
最新发布
y050505的博客
09-25 419
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
Java 入门指南：Java 8 新特性 —— Lambda 表达式
Zachyy的博客
09-21 1189
Java Lambda 表达式是 Java 8 引入的一个功能，它允许以更简洁的方式编写函数式接口的实现。 Lambda 表达式可以被认为是一种匿名函数，它没有名称，但有参数列表、函数体和可能的异常列表。它可以用来替代使用匿名内部类实现函数式接口的方式 Lambda 表达式可以简化代码，使代码更加简洁、可读性更强，尤其在使用函数式接口和结合 Java Stream API 进行编程时非常有用。
第 28 章 Javascript错误处理与调试
weixin_44010641的博客
09-23 1362
JavaScript 在错误处理调试上一直是它的软肋，如果脚本出错，给出的提示经常也让人摸不着头脑。ECMAScript 第 3 版为了解决这个问题引入了 try…catch 和 throw 语句以及一些错误类型，让开发人员更加适时的处理错误。
JVM内存模型
weixin_63691530的博客
09-23 832
Java程序的跨平台特性主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设备上运行，Java虚拟机中的Java解释器负责将字节码文件解释成为特定的机器码进行运行。
SpringBoot文档管理系统：性能优化
2401_85743969的博客
09-24 832
在在线文档管理系统开发之前所做的市场调研及其他的相关的管理系统，都是没有任何费用的，都是通过开发者自己的努力，所有的工作的都是自己亲力亲为，在碰到自己比较难以解决的问题，大多是通过同学和指导老师的帮助进行相关信息的解决，所以对于在线文档管理系统的开发在经济上是完全可行的，没有任何费用支出的。系统开发所使用的技术也都是自身所具有的，也是当下广泛应用的技术之一。开发整个系统使用的是云计算，流量的可扩展性和基于流量的智能调整云计算的优点就是流量的可扩展性和基于流量的智能调整，保障系统的安全及数据信息的及时备份。
Windows系统修改Tomcat虚拟机内存参数
iOS逆向与安全
09-23 460
Windows系统同样建议配置到setenv.bat文件中。建议将环境变量设置到setenv.sh 文件。用于查询Tomcat指标的基于文本的界面。
java使用ByteBuffer进行多文件合并和拆分
HBLOG
09-21 666
因为验证证书的需要，需要把证书文件和公钥给到客户，考虑到多个文件交互的不便性，所以决定将2个文件合并成一个文件交互给客户。刚开始采用字符串拼接2个文件内容，但是由于是加密文件，采用字符串形式合并后，拆分后文件不可用，最后采用基于二进制流拆分和合并文件，效果不错！会正确读取到前 4 个字节，并将其转换为整数，这样你就得到了文件内容的大小。如果你按照之前的代码将文件内容合并时，将文件大小以 4 字节整数形式写入到文件中，那么你可以使用。（公钥证书内容）的长度转换为 4 个字节的整数，并写入到字节缓冲区中。
【OSS安全最佳实践】降低因账号密码泄露带来的未授权访问风险
segwy的博客
09-21 1356
如果因个人或者企业账号密码泄露引发了未经授权的访问，可能会出现非法用户对OSS资源进行违法操作，或者合法用户以未授权的方式对OSS资源进行各类操作，这将给数据安全带来极大的威胁。为此，OSS提供了在实施数据安全保护时需要考虑的多种安全最佳实践。以下最佳实践遵循一般准则，并不等同完整的安全解决方案。这些最佳实践可能不适合您的环境或不满足您的环境要求，仅建议将其视为参考因素。请您在日常使用中提高数据安全意识并时刻做好内容安全防范措施。
Java IO流详解：基础概念与常用类实例
Java的IO流笔记是一份详尽的学习资料，主要涵盖了Java中处理输入输出操作的核心概念和技术。本文档围绕IO流的四大抽象类——`InputStream`、`OutputStream`、`Reader`和`Writer`展开，它们分别负责字节和字符的输入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值