Java I/O

最新推荐文章于 2024-10-14 08:13:56 发布
最新推荐文章于 2024-10-14 08:13:56 发布
阅读量176 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Nan_Feng726/article/details/97954799

1、File文件操作类

1.1 File类使用

java.io.File是是一个普通的类，可以通过两个构造方法直接产生实例化对象：
public File(String pathname);
public File(String parent,String child); —— 设置父路径和子路径

File类提供了以下方法对文件进行基本操作：

  • 创建一个新文件：
public boolean createNewFile() throws IOException
  • 判断文件是否存在
public boolean exists();
  • 删除文件
public boolean delete();

一个简单应用：

public class Test {
    public static void main(String[] args) throws  IOException {
        //定义要操作的文件路径
        File file = new File("E:\\比特\\JavaSE\\code\\TestIO.java");
        if (file.exists()){
            file.delete();
        }else {
            file.createNewFile();
        }
    }
}

注意：定义要操作的文件路径时，不同的操作系统使用的斜杠不同，因此我们可以采用File类的一个常量public static final String separator来描述。separator由不同操作系统下的JVM来决定到底是哪个杠杠。

上面代码优化为：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义要操作的文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "TestIO.java");
        if (file.exists()) {
            file.delete();
        } else {
            file.createNewFile();
        }
    }
}
1.2 目录操作
  • 取得父路径或父File对象

public String getParent();

public File getParentFile();

  • 创建目录（无论有多少级父目录，都会创建）

public boolean mkdirs()
简单应用：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义要操作的文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "JavaIO.java" + File.separator + "Nanfeng"
                + File.separator + "TestIO.java");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();  //有多少级父目录就创建多少级
        }
        if (file.exists()) {
            file.delete();
        } else {
            file.createNewFile();
        }
    }
}
1.3 文件信息
  • 判断路径是否是文件：public boolean isFile();
  • 判断路径是否是目录：public boolean isDirectory();
  • 取得文件大小(字节)：public long length();
  • 最后一次修改日期：public long lastModified();
  • 列出一个目录的全部组成：public File[] listFiles();

2、字节流与字符流

File类不支持文件内容的处理，如果要处理文件内容，必须要通过流的操作模式来完成。流分为输入流和输出流。
在 java.io 包中，流分为两种：字节流和字符流：
1）字节流：InputStream、OutputStream
2）字符流：Reader、Writer
字节流与字符流的本质区别：
字节流是原生的操作，而字符流是经过处理后的操作。

不论是字节流还是字符流，操作流程都是一样的，以文件操作为例：
1）根据文件路径创建File类对象
2）根据字节流或字符流的子类实例化父类对象
3）进行数据的读取或写入操作
4）关闭流(close())

2.1 字节输出流(OutputStream)

由于OutputStream是一个抽象类，所以要想为父类实例化，就必须使用子类。由于方法名称都由父类声明好了，所以我们只需要关心子类的构造方法。如果要进行文件的操作，可以使用FileOutputStream类来处理，这个类的构造方法为：
1）接收File类(覆盖)：public FileOutputStream(File file) throws FileNotFoundException;
2）接收File类(追加)：public FileOutputStream(File file,boolean append)
简单应用：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义要操作的文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();  //有多少级父目录就创建多少级
        }
        OutputStream output = new FileOutputStream(file);
        //要求输出到文件的内容
        String msg = "南风知我意";
        //将内容变为字节数组
        output.write(msg.getBytes());
        //关闭输出流
        output.close();
    }
}

上面这段代码如果重复执行，内容会不停的覆盖，如果要实现内容的追加，则需要用另外一种构造方法。

public class Test {
    public static void main(String[] args) throws IOException {
        //定义要操作的文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();  //有多少级父目录就创建多少级
        }
        OutputStream output = new FileOutputStream(file, true);
        //要求输出到文件的内容
        String msg = "   念你已成疾";
        //将内容变为字节数组
        output.write(msg.getBytes());
        //关闭输出流
        output.close();
    }
}

在这里插入图片描述
JDK 1.7之后，追加了一个AutoCloseable接口，主要目的是自动进行关闭处理。

class Message implements AutoCloseable {
    public Message() {
        System.out.println("创建一条新消息");
    }

    @Override
    public void close() throws Exception {
        System.out.println("[AutoCloseable]自动关闭方法");
    }

    public void print() {
        System.out.println("www.nanfeng.java");
    }
}

public class Test {
    public static void main(String[] args) {
        //必须在try中定义对象
        try (Message msg = new Message()) {
            msg.print();
        } catch (Exception e) {

        }
    }
}

因此上面的例子可以改为：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义要操作的文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();  //有多少级父目录就创建多少级
        }
        try (OutputStream output = new FileOutputStream(file, true)) {
            //要求输出到文件的内容
            String msg = "吹梦到西洲";
            //将内容变为字节数组
            output.write(msg.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
2.2 字节输入流(InputStream)

和字节输出流一样，字节输入流也是一个抽象类，如果要对它进行实例化，同样也需要使用子类。如果要对文件进行处理，则使用FileInputStream类。

public class Test {
    public static void main(String[] args) throws IOException {
        //定义文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        //保证文件存在
        if (file.exists()) {
            InputStream input = new FileInputStream(file);
            byte[] data = new byte[1024];   //每次可以读取的最大数量
            int len = input.read(data);     //此时数据读取到数组中
            String result = new String(data, 0, len);     //将字节数组转为String
            System.out.println("读取内容【" + result + "】");
            input.close();
        }
    }
}
2.3 字符输出流：Writer

字符适合处理中文数据，Writer是字符输出流的处理类。
在Writer类里也提供了write()方法，而且该方法接收的类型都是char型。
需要注意的是，Writer类提供了一个直接输出字符串的方法：public void write(String str) throws IOException;如果要操作文件，使用FileWriter类。

简单应用：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        String msg = "南风知我意，念你已成疾！";
        Writer out = new FileWriter(file);
        out.write(msg);
        out.close();
    }
}

在这里插入图片描述

2.4 字符输入流：Reader

Reader也是一个抽象类，如果要进行文件的读取，要使用FileReader。
Reader类中没有方法可以直接读取字符串类型，只能通过字符数组进行读取操作。

public class Test {
    public static void main(String[] args) throws IOException {
        //定义文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (file.exists()) {
            Reader in = new FileReader(file);
            char[] data = new char[1024];
            int len = in.read(data);    //将数据读取到字符数组中
            String result = new String(data, 0, len);
            System.out.println("读取内容【" + result + "】");
            in.close();
        }
    }
}

在这里插入图片描述

所有字符流操作，无论是写入还是输出，数据都先保存在缓存中。如果字符流不关闭，数据就有可能保存在缓存中并没有输出到目标源，这时就必须使用out.flush()强制刷新才能得到完整数据。

3、转换流

字节流和字符流的相互转换：

  • OutputStreamWriter：将字节输出流转成字符输出流
  • InputStreamReader：将字节输入流转成字符输入流

简单应用：

public class Test {
    public static void main(String[] args) throws IOException {
        //定义文件路径
        File file = new File("E:" + File.separator + "比特"
                + File.separator + "JavaSE" + File.separator + "code"
                + File.separator + "hello.txt");
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        OutputStream output = new FileOutputStream(file);
        Writer out = new OutputStreamWriter(output);
        String msg = "南风知我意，吹梦到西洲！";
        out.write(msg);
        out.close();
    }
}

4、字符编码

开发中常用UTF-8编码，解码和编码不一致就会产生乱码。

读取Java运行属性：
System.getProperties().list(System.out);

5、内存操作流

之前所有操作都是针对文件进行IO处理，其实IO操作也可以发生在内存中，这种称为内存操作流。
文件流的操作一定会产生一个文件数据，如果现在需要进行IO处理，但又不希望产生文件，这种情况就可以使用内存作为操作终端。
内存操作流最核心的就是将所有OutputStream输出的程序保存在了程序里面。

内存流也分为两类：
1）字节内存流：ByteArrayInputStream、ByteArrayOutputStream
2）字符内存流：CharArrayReader、CharArrayWriter
简单应用：通过内存流实现大小写转换

public class Test {
    public static void main(String[] args) throws IOException {
        String msg = "Hello Nanfeng";
        //实例化InputStream类对象，实例化的时候需要将你操作的数据保存到内存中，最终读取的就是你设置的内容
        InputStream input = new ByteArrayInputStream(msg.getBytes());
        OutputStream output = new ByteArrayOutputStream();
        int temp = 0;
        while ((temp = input.read()) != -1) {
            //对每个字节进行处理，处理之后所有数据都在outputStream类中
            output.write(Character.toUpperCase(temp));
        }
        //直接输出output对象
        System.out.println(output);
        input.close();
        output.close();
    }
}

使用内存流实现将两个文件合并处理(文件量不大)

public class JavaIO {
    public static void main(String[] args) throws IOException {
        File[] files = new File[]{
                new File("E:" + File.separator + "比特" + File.separator + "JavaSE" + File.separator + "code" + File.separator + "data-a.txt"),
                new File("E:" + File.separator + "比特" + File.separator + "JavaSE" + File.separator + "code" + File.separator + "data-b.txt")
        };
        String[] data = new String[2];
        for (int i = 0; i < files.length; i++) {
            data[i] = readFile(files[i]);
        }
        StringBuffer buf = new StringBuffer();  //组合操作
        String contentA[] = data[0].split(" ");
        String contentB[] = data[1].split(" ");
        for (int i = 0; i < contentA.length; i++) {
            buf.append(contentA[i]).append("(").append(contentB[i]).append(")").append(" ");
        }
        System.out.println(buf);
    }

    public static String readFile(File file) throws IOException {
        if (file.exists()) {
            InputStream input = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            int temp = 0;
            byte[] data = new byte[10];
            while ((temp = input.read(data)) != -1) {
                //将数据保存在bos中
                bos.write(data, 0, temp);
            }
            bos.close();
            input.close();
            //将读取内容返回
            return new String(bos.toByteArray());
        }
        return null;
    }
}

6、打印流

打印流解决的是OutputStream的设计缺陷，如果操作的不是二进制数据，只是想通过程序向终端目标输出信息的话，OutputStream不是很方便，其缺点有两个：
1）所有的数据必须转为字节数组
2）如果要输出的是int，double等类型就不方便了
打印流的设计属于装饰设计模式，核心依然是某个类的功能。

打印流分为字节打印流PrintStream和字符打印流PrintWriter，后者使用频率较高。

6.1 使用打印流：
public class DaYinLiu {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter printutil = new PrintWriter(new FileOutputStream(new File("E:\\比特\\JavaSE\\code\\test.txt")));
        printutil.print("姓名：");
        printutil.println("Nanfeng");
        printutil.print("年龄：");
        printutil.println(21);
        printutil.print("工资：");
        printutil.println(10.000000000000000001);
        printutil.close();
    }
}
6.2 格式化输出

格式化输出：
public PrintStream printf(String format,Object ... args)

public class DaYinLiu {
    public static void main(String[] args) throws FileNotFoundException {
        String name = "Nanfeng";
        int age = 21;
        double salary = 1.1063726327;
        PrintWriter printutil = new PrintWriter(new FileOutputStream(new File("E:\\比特\\JavaSE\\code\\test.txt")));
        printutil.printf("姓名：%s,年龄：%d,工资：%1.2f", name, age, salary);
        printutil.close();
    }
}

格式化字符串：
public static String format(String fromat,Object ... args);

public class DaYinLiu {
    public static void main(String[] args) throws FileNotFoundException {
        String name = "Nanfeng";
        int age = 21;
        double salary = 1.1063726327;
        String str = String.format("姓名：%s,年龄：%d,工资：%1.2f", name, age, salary);
        System.out.println(str);
    }
}

7、System类对IO的支持

在System类中定义了三个操作的常量：
1）标准输出（显示器）：public final static PrintStream out;
2）错误输出：public final static PrintStream err;
3）标准输入（键盘）：public final static InputStream;

8、两种输入流

8.1 BufferedReader类

BufferedReader类属于一个缓冲的输入流，而且是一个字符流的操作对象。在Java中缓冲流也分为两种：字节缓冲流(BufferedInputStream)、字符缓冲流(BufferedReader)。

BufferedReader类提供了直接读取一行数据的方法(以回车为换行符)：
String readLine() throws IOException;
利用BufferedReader类实现键盘输入：

public class ShuRuLiu {
    public static void main(String[] args) throws IOException {
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入信息：");
        String str = buf.readLine();    
        System.out.println("输入信息为：" + str);
    }
}

使用以上形式实现的键盘输入有两个特点：
1）默认使用回车换行
2）由于接收的数据类型为String，可以使用String类的各种操作进行数据处理并且可以变为各种常见数据类型

8.2 java.util.Scanner类

Scanner是一个专门进行输入流处理的程序类，利用这个类可以方便处理各种数据类型，也可以直接结合正则表达式进行各项处理。Scanner类解决了BufferedReader类的缺陷，替代了BufferedReader类。

Scanner类提供的方法：

  • 判断是否有指定数据类型：public boolean hasNextXxx();
  • 取得指定类型的数据：public 数据类型 nextXxx();
  • 定义分隔符：public Scanner useDelimiter(Pattern pattern);
  • 构造方法：public Scanner(InputStream source);

使用Scanner类实现数据输入：

public class ShuRuLiu {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入信息：");
        if (scanner.hasNext()) {
            System.out.println("输入信息为：" + scanner.next());
        }
        scanner.close();
    }
}

使用Scanner类操作文件：

public class ShuRuLiu {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(new FileInputStream(new File("E:\\比特\\JavaSE\\code\\test.txt")));
        scanner.useDelimiter("\n");     //自定义分隔符
        while (scanner.hasNext()) {
            System.out.println(scanner.next());
        }
        scanner.close();
    }
}

9、序列化

对象序列化是指：将内存中保存的对象变为二进制数据流的形式进行传输，或者是将其保存在文本中。但是并不是所有类的对象都可以被序列化。
严格来说，需要被序列化的类对象需要传输使用，同时这个类必须实现java.io.Serializable接口，但是这个接口没有任何的方法定义，只是一个标识而已。

实现对象序列化：

class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name = " + name + ", age = " + age + "]";
    }
}

public class XuLieHua {
    public static final File FILE = new File("E:\\比特\\JavaSE\\code\\testSer.txt");

    public static void main(String[] args) throws IOException {
        ser(new Person("Nanfeng", 21));
    }

    public static void ser(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE));
        oos.writeObject(obj);
        oos.close();
    }
}

补充：transient关键字
序列化的处理在java.io包里有两类，Serializable是使用最多的序列化接口，它采用自动化模式完成，在默认情况下所有的属性都会被序列化保存下来。如果现在某些属性不希望被保存了，那么就可以使用transient关键字。
还有一个Externalizable接口需要自己动手来处理序列化，很少使用。

Java I/O 详解：基础、文件操作与 NIO 实践
微笑听雨
05-30 5592
Java I/O (输入输出) 是指用于读取和写入数据的 API，包括从文件、网络和其他数据源进行读取和写入操作。Java 提供了丰富的类和接口来实现各种 I/O 操作，主要包括标准 I/O、文件 I/O 和新 I/O (NIO)。
Java I/O 模型详解：BIO、NIO 与 AIO 的特性与应用
微笑听雨
05-30 8138
BIO（Blocking I/O）：适合简单、少量连接的应用场景，编程简单但性能较低。 NIO（Non-blocking I/O）：适合高并发、大量连接的应用，使用复杂但性能较好。 AIO（Asynchronous I/O）：适合超高并发、长连接的应用，异步非阻塞，性能最佳。
关于StreamReader的知识分享
good575654643的博客
10-23 3639
今天我们来简单的介绍一下StreamReader，在将StreamReader之前，我们先来了解一下他的父类：TextReader。对于TextReader，大家可能比较陌生，下面我们来看一下TextReader是什么。 一、TextReader 首先让我们来理解一下什么是TextReader，从字面意思入手的话，大家就会恍然大悟了，一个对于Text的读取器，可是又是怎么读取的呢？聪明的你肯定...
【Java Web]文件内容部分的操作
weixin_61567666的博客
05-11 242
目录 一、文件的读 1.方法 2.代码 （1）一个字节一个字节的读取 （2）一次读一堆 （3）文件内容中有中文 二、文件的写 1.方法 2.代码 （1） 一个字节一个字节的写 （2）一堆的写 3.应用 （1）文件复制工具 （2）目录复制工具 （3）文本替换工具 一、文件的读 InputStream 输入流 可以想象一个水龙头在滴水 数据从水龙头中流出的这样一个过程 1.方法 方法 说明 abstract int read() ...
Java I/O 相关面试题
qq_45818776的博客
10-01 4325
Java I/O 相关面试题
【Java】I/O 操作详解
最新发布
island1314的博客
10-14 7027
本章主要介绍了 I/O流 的相关知识。包括File类，包括创建File对象、File 类的常用方法、遍历目录下的文件和删除文件及目录；字节流，包括字节流的概念、字节流读文件、字节流写文件和文件的复制；字符流，包括字符流的定义及基本用法、字符流读文件和字符流写文件；转换流的使用；序列化和反序列化。通过本章的学习，读者应该了解 I/O 流，并且熟练掌握了 I/O 流的相关知识
Java I/O 模型的演进
老卫的技术站
03-01 2112
什么是同步？什么是异步？阻塞和非阻塞又有什么区别？本文先从 Unix 的 I/O 模型讲起，介绍了5种常见的 I/O 模型。而后再引出 Java 的 I/O 模型的演进过程，并用实例说明如何选择合适的 Java I/O 模型来提高系统的并发量和可用性。
java I/O流部分习题及答案解析
weixin_52796601的博客
12-17 8236
1、 下列选项中，哪一个不是InputStream的直接子类（ ） A、ByteArrayInputStream B、FileInputStream C、BufferedInputStream D、PipedInputStream 1、 下列选项中，哪个类是用来读取文本的字符流？（ ） A、FileReader B、FileWriter C、FileInputStream D、FileOutputStream 2、 当文件不存在或不可读时，使用FileInputStream读取文件会报下列哪一种错误（
Java之I/O流（最详细的I/O流总结）
熊凯瑞的博客
05-15 8878
I/O流I/O流1、定义2、分类2.1 字节流和字符流2.2 输入流和输出流2.3 节点流和处理流3、结构4、字节流4.1 定义4.2 说明4.3 字节流概述4.4 InputStream的常用方法4.5 OutputStream的常用方法5、字节流读写文件5.1 说明5.2 注意5.3 字节输入流——相关代码5.4 字节输出流——相关代码6、文件的拷贝6.1 需求6.2 分析6.3 注意6.4 快捷键6.5 相关代码7、字节流的缓冲区7. 相关代码8、字节缓冲流8.1 说明8.2 特点8.3 相关代码8.
Java I/O error while reading input message；Stream closed问题解决
热门推荐
旭东怪的博客
06-21 1万+
问题描述： org.springframework.http.converter.HttpMessageNotReadableException: I/O error while reading input message; nested exception is java.io.IOException: Stream closed
探索Java I/O 模型的演进
08-25
Java I/O 模型的演进是随着技术发展和并发需求的提升而逐步完善的。在理解Java I/O模型之前，我们需要先了解一些基础概念，包括同步与异步、阻塞与非阻塞。 同步和异步是描述用户线程与内核交互方式的概念。同步I/O...
Java I/O 流代码实例大全（01~09）
07-27
Java I/O 流代码实例大全（01~09） File、FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
Java I/O: Tips and Techniques for Putting I/O to Work, 2nd Edition
03-14
Elliotte Rusty Harold 的《Java I/O, 2nd Edition》。通常找到的版本是.chm格式的电子书转成的Pdf，而且效果不好。我将.chm文件和一个自己转成的pdf文件一起打包放上来，以便大家查阅。第一版的一个pdf文件也一起...
java I/O
02-16
Java I/O 是Java编程语言中一个至关重要的领域，它涵盖了数据的输入与输出操作，包括文件操作、流处理、字符编码、网络通信等。在Java I/O系统中，各种类和接口构成了一个庞大的框架，使得开发者能够高效地处理数据...
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O
12-26
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O Java是一种面向对象的编程语言，由Sun Microsystems于1995年推出。它是一种跨平台的语言，意味着可以在不同的操作系统上运行...
Int和Integer的区别
Nan_Feng726的博客
06-11 1万+
Int和Integer的区别 1、Integer是Int的包装类，Int是八种基本数据类型之一。 2、Integer变量必须实例化以后才可以使用，而Int变量不需要实例化。 3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象，而Int是直接存储数据值。 4、Integer的默认值是null，Int的默认值是0。 Int和Integer的比较（扩展） 先...
hashcode与equals的关系
Nan_Feng726的博客
08-10 4334
hashcode与equals的关系 hashCode()：将任意一个对象根据指定的算法转为32位int equlas()：比较两个对象是否相等 equals相等的两个对象，hashCode一定相等。hashCode相等的两个对象，equals不一定相等。 理解： 我们可以把hashCode()想象成一个函数f(x)，equals就相当于是x轴坐标，比如说我们学过的二次函数图像，当x轴相等的时...
基于多线程的网络聊天室的实现思路
Nan_Feng726的博客
03-21 1404
写在前面 QQ、微信几乎替换了移动电话在我们生活中的应用，它们使远程交流变得简单，所以，模仿QQ、微信的一些功能，我实现了一个简单的支持注册、群聊、私聊、退出的网络聊天室。 多线程网络聊天室 功能： 服务器端（注册，私聊，群聊，退出） 客户端（发送聊天信息，接收聊天信息） 业务： 服务器端 1、管理注册的用户 2、私聊对象发送数据 3、在线用户发送数据 4、退出时删除用户 5、循环监听客户端...
双重枷锁单例模式
Nan_Feng726的博客
08-01 1172
public class Singleton1 { private static volatile Singleton1 SINGLETON; 保证这个单例的对象一定是属性全部初始化之后的单例对象 不会指令重排，return的这个SINGLETON一定是所有属性完全初始化之后的单例对象 private Singleton1() {} // 线程2 public st...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值