【Java SE 基础】IO

最新推荐文章于 2024-07-14 14:59:27 发布
最新推荐文章于 2024-07-14 14:59:27 发布
阅读量78 收藏
点赞数
分类专栏： Java学习 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18874217/article/details/128054257
版权

File对象

File用于操作文件和目录：

File f = new File("C:\\Windows\\notepad.exe");
//即可传入绝对路径，也可以传入相对路径 
//可以用.表示当前目录，..表示上级目录。
//Windows平台使用\作为路径分隔符，Java字符串中需要用\\表示一个\。Linux平台使用/作为路径分隔符：
System.out.println(f);

用File获取路径：

  1. getPath()，返回构造方法传入的路径

  2. getAbsolutePath()，返回绝对路径

  3. getCanonicalPath，它和绝对路径类似，但是返回的是规范路径。

    规范路径即将.和… 转换后的绝对路径 如\System32\…\notepad.exe --> \notepad.exe

文件和目录：

  1. File对象既可以表示文件，也可以表示目录；
  2. 构造一个File对象，不会导致磁盘操作，只有当调用File对象的某些方法的时候，文件或目录不存在，会出错；
  3. isFile()，判断该File对象是否是一个已存在的文件，调用isDirectory()，判断该File对象是否是一个已存在的目录：
  4. 用File对象获取到一个文件时，还可以进一步判断文件的权限和大小：
    • boolean canRead()：是否可读；
    • boolean canWrite()：是否可写；
    • boolean canExecute()：是否可执行；
    • long length()：文件字节大小。

创建和删除文件：

  1. 当File对象表示一个文件时，可以通过createNewFile()创建一个新文件，用delete()删除该文件：
  2. File对象提供了createTempFile()来创建一个临时文件，以及deleteOnExit()在JVM退出时自动删除该文件。

遍历文件和目录：

  1. 当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。

  2. listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录：

    File[] fs2 = f.listFiles(new FilenameFilter() { // 仅列出.exe文件
    public boolean accept(File dir, String name) {
        return name.endsWith(".exe"); // 返回true表示接受该文件
    }
});

  3. 和文件操作类似，File对象如果表示一个目录，可以通过以下方法创建和删除目录：

    • boolean mkdir()：创建当前File对象表示的目录；
    • boolean mkdirs()：创建当前File对象表示的目录，并在必要时将不存在的父目录也创建出来；
    • boolean delete()：删除当前File对象表示的目录，当前目录必须为空才能删除成功。

Path:

  1. Path对象和File对象类似，如果需要对目录进行复杂的拼接、遍历等操作，使用Path对象更方便。

InputStream

InputStream介绍：

  1. InputStream就是Java标准库提供的最基本的输入流。位于java.io这个包；

  2. InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。

  3. 这个抽象类定义的一个最重要的方法就是int read()签名如下：

    public abstract int read() throws IOException;
//该方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了。

FileInputStream：

  1. 从文件流中读取数据：

    public void readFile() throws IOException {
    InputStream input = null;
    try {
        input = new FileInputStream("src/readme.txt");
        int n;
        while ((n = input.read()) != -1) { // 利用while同时读取并判断
            System.out.println(n);
        }
    } finally {
        if (input != null) { input.close(); }//必须要关闭流，释放底层资源
    }
}
------------------//java7引入的新的try(resource)的语法
public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
        int n;
        while ((n = input.read()) != -1) {
            System.out.println(n);
        }
    } // 编译器在此自动为我们写入finally并调用close() try中的resource对象需实现java.lang.AutoCloseable接口，InputStream和OutputStream都实现了这个接口
}

缓冲：

  1. InputStream提供了两个重载方法来支持读取多个字节：

    • int read(byte[] b)：读取若干字节并填充到byte[]数组，返回读取的字节数
    • int read(byte[] b, int off, int len)：指定byte[]数组的偏移量和最大填充数

  2. 利用缓冲读取数据：

    public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
        // 定义1000个字节大小的缓冲区:
        byte[] buffer = new byte[1000];
        int n;
        while ((n = input.read(buffer)) != -1) { // 读取到缓冲区
            System.out.println("read " + n + " bytes.");
        }
    }
}

阻塞：

int n;
n = input.read(); // 必须等待read()方法返回才能执行下一行代码
int m = n;

InputStream实现类：

  1. FileInputStream：可以从文件获取输入流 (上面提到)

  2. ByteArrayInputStream：在内存中模拟 一个InputStream

    byte[] data = { 72, 101, 108, 108, 111, 33 };
//实际上是把一个byte[]数组在内存中变成一个InputStream,多用于测试时构造InputStream
try (InputStream input = new ByteArrayInputStream(data)) {
    int n;
    while ((n = input.read()) != -1) {
        System.out.println((char)n);
    }
}

OutputStream

OutputStream介绍：

  1. OutputStream是Java标准库提供的最基本的输出流。位于java.io这个包；

  2. OutputStream也是抽象类，它是所有输出流的超类。

  3. 这个抽象类定义的一个最重要的方法就是void write(int b)，签名如下：

    public abstract void write(int b) throws IOException;
//这个方法会写入一个字节到输出流,传入的是int参数,只写入int最低8位(为一个字节)

  4. OutputStream不仅提供了close()方法关闭输出流，还提供了一个flush()方法，将缓冲区的内容真正输出到目的地。（操作系统会等待缓冲区满再输出，flush()方法能强制输出）

FIleOutputStream：

  1. 将若干个字节写入文件流：

    public void writeFile() throws IOException {
    //没有考虑发生异常
    OutputStream output = new FileOutputStream("out/readme.txt");
    output.write(72); // H
    output.write(101); // e
    output.write(108); // l
    output.write(108); // l
    output.write(111); // o
    output.close();
}

  2. 缓冲–OutputStream提供的重载方法void write(byte[])来实现：

    public void writeFile() throws IOException {
    try (OutputStream output = new FileOutputStream("out/readme.txt")) {
        output.write("Hello".getBytes("UTF-8")); // Hello 同样会阻塞
    } // 编译器在此自动为我们写入finally并调用close()
}

OutputStream实现类：

  1. FileOutputStream： 可以从文件获取输出流

  2. ByteArrayOutputStream：可以在内存中模拟一个OutputStream

    byte[] data;
//实际上是把一个byte[]数组在内存中变成一个OutputStream,多用于测试时构造OutputStream
try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
    output.write("Hello ".getBytes("UTF-8"));
    output.write("world!".getBytes("UTF-8"));
    data = output.toByteArray();
}
System.out.println(new String(data, "UTF-8"));

  3. 补充：同时操作多个AutoCloseable资源时，在try(resource) { ... }语句中可以同时写出多个资源，用;隔开

    // 读取input.txt，写入output.txt:
try (InputStream input = new FileInputStream("input.txt");
     OutputStream output = new FileOutputStream("output.txt"))
{
    input.transferTo(output); // transferTo的作用是直接将输入流写入输出流
}

Filter模式

存在的问题：

  1. Java的IO标准库提供的InputStream根据来源可以包括：
    • FileInputStream：从文件读取数据，是最终数据源；
    • ServletInputStream：从HTTP请求读取数据，是最终数据源；
    • Socket.getInputStream()：从TCP连接读取数据，是最终数据源；
  2. 我们要给FileInputStream添加缓冲功能，需要从FileInputStream派生一个类
  3. 如果要给FileInputStream添加计算签名的功能，需要从FileInputStream派生一个类
  4. 如果要给FileInputStream添加加密/解密功能，还是需要从FileInputStream派生一个类
  5. 对其他数据来源的InputStream添加功能，就会出现非常多的子类

解决方式：

  1. 将InputStream分为两大类：

    1. 一类是直接提供数据的基础InputStream，例如：
      • FileInputStream
      • ByteArrayInputStream
      • ServletInputStream
    2. 一类是提供额外附加功能的InputStream，例如：
      • BufferedInputStream
      • DigestInputStream
      • CipherInputStream

  2. 当我们需要添加功能时，先确定提供数据来源的InputStream，例如数据来自文件

    InputStream file = new FileInputStream("test.gz");

  3. 开始添加功能，我们希望添加缓冲的功能，因此我们用BufferedInputStream包装这个InputStream，得到的包装类型是BufferedInputStream，但仍用InputStream指向它

    InputStream buffered = new BufferedInputStream(file);

  4. 最后，如果该文件被gzip压缩了，我们希望直接读取压缩的内容，就可以进一步包装一个GZIPInputStream：

    InputStream gzip = new GZIPInputStream(buffered);

但无论包装几次，我们都用InputStream来指向它，这就是FIlter模式，也可以称为装饰器模式

实践：

编写一个CountInputStream，它的作用是对输入的字节进行计数：

public class Main {
    public static void main(String[] args) throws IOException {
        byte[] data = "hello, world!".getBytes("UTF-8");
        try (CountInputStream input = new CountInputStream(new ByteArrayInputStream(data))) {//只要持有最外层的InputStream，当最外层的InputStream关闭时，内层的InputStream的close()方法也会被自动调用
            int n;
            while ((n = input.read()) != -1) {
                System.out.println((char)n);
            }
            System.out.println("Total read " + input.getBytesRead() + " bytes");
        }
    }
}

class CountInputStream extends FilterInputStream {
    private int count = 0;

    CountInputStream(InputStream in) {
        super(in);
    }

    public int getBytesRead() {
        return this.count;
    }

    public int read() throws IOException {
        int n = in.read();
        if (n != -1) {
            this.count ++;
        }
        return n;
    }

    public int read(byte[] b, int off, int len) throws IOException {
        int n = in.read(b, off, len);
        this.count += n;
        return n;
    }
}

操作Zip

ZipInputStream：

  1. ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容。
  2. JarInputStream是从ZipInputStream派生，它增加的主要功能是直接读取jar文件里面的MANIFEST.MF文件。

实践：

  1. 读取zip包

    try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) {//传入一个FileInputStream作为数据源
    ZipEntry entry = null;//一个ZipEntry表示一个压缩文件或目录
    while ((entry = zip.getNextEntry()) != null) {//返回null，表示zip流结束
        String name = entry.getName();
        if (!entry.isDirectory()) {
            int n;
            while ((n = zip.read()) != -1) {
                ...
            }
        }
    }
}

  2. 写入zip包

    try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) {
    File[] files = ...
    for (File file : files) {
        zip.putNextEntry(new ZipEntry(file.getName()));
        zip.write(getFileDataAsBytes(file));
        zip.closeEntry();//closeEntry()结束这个文件的打包。
    }
}
//要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径。

读取classpath资源

存在问题：

  1. Java存放.class的目录或jar包也可以包含任意其他类型的文件，例如：
    • 配置文件，例如.properties；
    • 图片文件，例如.jpg；
    • 文本文件，例如.txt，.csv；
  2. 不同环境下文件路径不一致，不能从磁盘的固定目录读取配置文件；

解决方法：

  1. 把default.properties配置文件文件放到classpath中，不用关心它的实际存放路径。

  2. 在classpath中的资源文件，路径总是以／开头，我们先获取当前的Class对象，然后调用getResourceAsStream()就可以直接从classpath读取任意的资源文件：

    try (InputStream input = getClass().getResourceAsStream("/default.properties")) {
    if (input != null) {//资源不存在，返回null，需要判断
        // TODO:
    }
}

  3. 灵活配置：把默认的配置放到jar包中，再从外部文件读取一个可选的配置文件，就可以做到既有默认的配置，又可以让用户自己修改配置

    Properties props = new Properties();
props.load(inputStreamFromClassPath("/default.properties"));
props.load(inputStreamFromFile("./conf.properties"));

序列化

介绍：

  1. 说明：序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组。
  2. 目的：序列化后可以把byte[]保存到文件中，或者把byte[]通过网络传输到远程，这样，就相当于把Java对象存储到文件或者通过网络传输出去了。

序列化：

  1. 一个Java对象要能序列化，必须实现一个特殊的java.io.Serializable接口，它的定义如下：

    public interface Serializable {
}
//没有定义任何方法，它是一个空接口。我们把这样的空接口称为“标记接口”.

  2. 把一个Java对象变为byte[]数组，需要使用ObjectOutputStream。它负责把一个Java对象写入一个字节流：

    public class Main {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        try (ObjectOutputStream output = new ObjectOutputStream(buffer)) {
            // 写入int:
            output.writeInt(12345);
            // 写入String:
            output.writeUTF("Hello");
            // 写入Object:
            output.writeObject(Double.valueOf(123.456));
        }
        System.out.println(Arrays.toString(buffer.toByteArray()));
    }
}
//ObjectOutputStream既可以写入基本类型,也可以写入String（以UTF-8编码），还可以写入实现了Serializable接口的Object。

反序列化：

  1. ObjectInputStream负责从一个字节流读取Java对象：

    try (ObjectInputStream input = new ObjectInputStream(...)) {
    int n = input.readInt();
    String s = input.readUTF();
    Double d = (Double) input.readObject();
}
//ObjectInputStream除了能读取基本类型和String类型外，调用readObject()可以直接返回一个Object对象。要把它变成一个特定类型，必须强制转型。

  2. readObject()可能抛出的异常有：

    • ClassNotFoundException：没有找到对应的Class；-- 传输后另一台电脑上没有定义该类，无法反序列化。
    • InvalidClassException：Class不匹配。-- 定义的字段在反序列化时被修改了类型，导致class不兼容。

  3. 为避免不兼容，Java的序列化允许class定义一个特殊的serialVersionUID静态变量，用于标识序列化的“版本",通常由IDE自动生成，在增加或修改字段时，可以改变serialVersionUID的值，能阻止不匹配的class版本

    public class Person implements Serializable {
    private static final long serialVersionUID = 2709425275741743919L;
}

安全性：

  1. Java的序列化机制可以导致一个实例能直接从byte[]数组创建，不经过构造方法，存在一定安全隐患。
  2. Java的序列化还存在兼容性问题，通过JSON这样的通用数据结构来实现序列化是更好的方法。

Reader

和InputStream区别：

  1. InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取：

    InputStreamReader
    字节流，以byte为单位字符流，以char为单位
    读取字节（-1，0~255）：int read()读取字符（-1，0~65535）：int read()
    读到字节数组：int read(byte[] b)读到字符数组：int read(char[] c)

  2. java.io.Reader是所有字符输入流的超类，它最主要的方法是：

    public int read() throws IOException;
//读取字符流的下一个字符，并返回字符表示的int，范围是0~65535。如果已读到末尾，返回-1。

FileReader:

  1. FileReader是Reader的一个子类，它可以打开文件并获取Reader:

    public void readFile() throws IOException {
    // 创建一个FileReader对象:
    Reader reader = new FileReader("src/readme.txt"); // 可以设置字符编码，但此处没有设置
    //Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8);  避免乱码，应该设置编码
    for (;;) {
        int n = reader.read(); // 反复调用read()方法，直到返回-1
        if (n == -1) {
            break;
        }
        System.out.println((char)n); // 打印char
    }
    reader.close(); // 关闭流
}

  2. Reader也是一种资源，需要保证出错的时候能正确关闭，我们可以用try (resource)来保证Reader能够正确地关闭：

    try (Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8) {
    // TODO
}

  3. Reader还提供了一次性读取若干字符并填充到char[]数组的方法：

    public void readFile() throws IOException {
    try (Reader reader = new FileReader("src/readme.txt", StandardCharsets.UTF_8)) {
        char[] buffer = new char[1000];//设置缓冲区
        int n;
        while ((n = reader.read(buffer)) != -1) {//回实际读入的字符个数，最大不超过char[]数组的长度。返回-1表示流结束。
            System.out.println("read " + n + " chars.");
        }
    }
}

Reader实现类：

  1. FileReader: 可以打开文件并获取Reader

  2. CharArrayReader: 可以在内存中模拟一个Reader

    try (Reader reader = new CharArrayReader("Hello".toCharArray())) {
}
//它的作用实际上是把一个char[]数组变成一个Reader

  3. StringReader: 可以直接把String作为数据源

    try (Reader reader = new StringReader("Hello")) {
}

InputStreamReader:

  1. Reader是基于InputStream构造的：可以通过InputStreamReader在指定编码的同时将任何InputStream转换为Reader。

    // 持有InputStream:
InputStream input = new FileInputStream("src/readme.txt");
// 变换为Reader:
Reader reader = new InputStreamReader(input, "UTF-8");

  2. 可以指定编码，并通过try (resource)更简洁地改写如下：

    try (Reader reader = new InputStreamReader(new FileInputStream("src/readme.txt"), "UTF-8")) {
    // TODO:
}
//使用try (resource)结构时，只需要关闭最外层的Reader对象即可。

Writer

和OutputStream区别：

  1. Writer就是带编码转换器的OutputStream，它把char转换为byte并输出。

    OutputStreamWriter
    字节流，以byte为单位字符流，以char为单位
    写入字节（0~255）：void write(int b)写入字符（0~65535）：void write(int c)
    写入字节数组：void write(byte[] b)写入字符数组：void write(char[] c)
    无对应方法写入String：void write(String s)

  2. Writer是所有字符输出流的超类，它提供的方法主要有：

    • 写入一个字符（0~65535）：void write(int c)；
    • 写入字符数组的所有字符：void write(char[] c)；
    • 写入String表示的所有字符：void write(String s)。

Writer实现类：

  1. FileWriter：就是向文件中写入字符流的Writer：

    try (Writer writer = new FileWriter("readme.txt", StandardCharsets.UTF_8)) {
    writer.write('H'); // 写入单个字符
    writer.write("Hello".toCharArray()); // 写入char[]
    writer.write("Hello"); // 写入String
}

  2. CharArrayWriter：可以在内存中创建一个Writer：

    try (CharArrayWriter writer = new CharArrayWriter()) {
    writer.write(65);
    writer.write(66);
    writer.write(67);
    char[] data = writer.toCharArray(); // { 'A', 'B', 'C' }
}
//它的作用实际上是构造一个缓冲区，可以写入char，最后得到写入的char[]数组

  3. StringWriter也是一个基于内存的Writer，它和CharArrayWriter类似。实际上，StringWriter在内部维护了一个StringBuffer，并对外提供了Writer接口。

OutputStreamWriter:

  1. Writer是基于OutputStream构造的，可以通过OutputStreamWriter将OutputStream转换为Writer，转换时需要指定编码。

    try (Writer writer = new OutputStreamWriter(new FileOutputStream("readme.txt"), "UTF-8")) {
    // TODO:
}

PrintStream和PrintWriter

PrintStream:

  1. PrintStream是一种FilterOutputStream，它在OutputStream的接口上，额外提供了一些写入各种数据类型的方法：

    • 写入int：print(int)
    • 写入boolean：print(boolean)
    • 写入String：print(String)
    • 写入Object：print(Object)，实际上相当于print(object.toString())

  2. 我们经常使用的System.out.println()实际上就是使用PrintStream打印各种数据。其中，System.out是系统默认提供的PrintStream，表示标准输出：

    System.out.print(12345); // 输出12345
System.out.print(new Object()); // 输出类似java.lang.Object@3c7a835a
System.out.println("Hello"); // 输出Hello并换行

PrintWriter:

  1. PrintStream最终输出的总是byte数据，而PrintWriter则是扩展了Writer接口，它的print()/println()方法最终输出的是char数据:

    public class Main {
    public static void main(String[] args)     {
        StringWriter buffer = new StringWriter();
        try (PrintWriter pw = new PrintWriter(buffer)) {
            pw.println("Hello");
            pw.println(12345);
            pw.println(true);
        }
        System.out.println(buffer.toString());
    }
}

使用Files

FIles：

  1. Files封装了很多读写文件的简单方法，例如把一个文件的全部内容读取为一个byte[]：

    byte[] data = Files.readAllBytes(Paths.get("/path/to/file.txt"));

  2. 把一个文件的全部内容读取为String：

    // 默认使用UTF-8编码读取:
String content1 = Files.readString(Paths.get("/path/to/file.txt"));
// 可指定编码:
String content2 = Files.readString(Paths.get("/path/to/file.txt"), StandardCharsets.ISO_8859_1);
// 按行读取并返回每行内容:
List<String> lines = Files.readAllLines(Paths.get("/path/to/file.txt"));

  3. 写入文件：

    // 写入二进制文件:
byte[] data = ...
Files.write(Paths.get("/path/to/file.txt"), data);
// 写入文本并指定编码:
Files.writeString(Paths.get("/path/to/file.txt"), "文本内容...", StandardCharsets.ISO_8859_1);
// 按行写入文本:
List<String> lines = ...
Files.write(Paths.get("/path/to/file.txt"), lines);

  4. Files工具类还有copy()、delete()、exists()、move()等快捷方法操作文件和目录。

  5. Files提供的读写方法，受内存限制，只能读写小文件，例如配置文件等。

五彩斑斓的熊猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java se中的se指什么,什么是Java SE？
weixin_42299566的博客
03-10 6891
本文概述SE代表Java Standard Edition是一个计算平台, 我们可以在其中执行软件, 并且可以将其用于开发和部署台式机和服务器环境的可移植代码。它使用了Java编程语言。它是Java软件平台家族的一部分。 Java SE具有各种通用API和Java类库。它是Java编程的核心平台, 并提供所有库和API, 例如java.lang, java.io, java.math, java....
Java SE 08 IO
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
02-12 695
 1.Java流式输入/输出原理               2.Java流类的分类                               Java I/O类库需要多种不同功能的组合，通过叠合多个对象来提供所期望的功能。（装饰器设计模式）3.输入/输出流类                                                                     ...
java io报错_解决错误java.io.InvalidClassException
weixin_32667011的博客
02-20 2654
今天遇到一个现场问题，任务报错java.io.InvalidClassException。在开发环境是没有报错的，正式环境报错。大概类似于下面这样(非报错原文，摘自网上同类博客)在网上查找资料后了解到 ：该异常是由于反序列化时, 当前类的serialVersionUID 与 反序列化后的类的serialVersionUID 不同所致。在未显示声明情况下由java编译器计算得出，但是不同的java编...
Java SE是什么？Java各个版本区别
m0_67392182的博客
04-03 845
一、Java的各个常用版本： Java SE**、java EE****、Java ME**三个版本。下面介绍各个版本区别： （Java SE下载：https://www.oracle.com/technetwork/java/javase/downloads/index.html） 1. Java SE（Java Platform，Standard Edition） Java se 以前称为J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE是基础包，
Java基础知识面试题（2020最新版）
热门推荐
ThinkWon的博客
02-19 131万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
java 基本IO操作
m0_63184409的博客
05-05 944
java基础
java se1.6配套Jdk,javase 1.6与jdk1.6
weixin_42560991的博客
03-13 1103
JDK1.6(JavaSE1.6/JDK6)-iteye2018年12月10日java开发必要环境,压缩包中附带JDK6~JDK10的分享链接,如果觉得满意,麻烦给个好评,十分感谢JDK1.6(JavaSE1.6/JDK6)_javase-1.6-Java工具类资源-CSDN...2018年12月10日java开发必要环境,压缩包中附带JDK6~JDK10的分享链接,如果觉得满意,麻烦给个好评...
java基础知识点总结（一）
nann-viiv 的博客
01-21 6845
打算重新看看java基础，把开始学的时候模糊的概念理清楚，不定时更新~~~ 一、环境篇 1. JDK和JRE 三个概念： JDK： java development kit（java开发工具） JRE： java runtime environment（java运行时环境） JVM： java Virtual Machine（java虚拟机） a. JDK： JDK就是我们开发人员使用的开发工具，它里面包含了JRE、JVM和基础类库。所以编程的话只需要安装JDK，配置环境变量，path路径就可以了。 b.
Java 零基础入门学习（小白也能看懂！）
QQ3447387928的博客
01-18 1万+
📚博客主页：爱敲代码的小杨.✨专栏：《Java SE语法》❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️ Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。不仅如此，Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。以下 Java 特性来自 Java 白皮书因此：Java不仅仅是一门编程语言，也是一个由一些列计算机软件和规
java se 基础练习 Java学习资料
06-29
这份"java se 基础练习"的学习资料旨在帮助初学者巩固和深化Java编程基础，从而更好地掌握这门广泛使用的编程语言。以下将详细介绍Java SE的基础知识点： 1. **Java环境配置**：在开始Java编程之前，首先需要在...
java SE基础练习 Java学习资料
06-25
这个“java SE基础练习”资料包显然是为了帮助初学者或者希望巩固基础的开发者准备的。它可能包含了源代码示例、教程文档、练习题等丰富的学习资源。下面我们将深入探讨Java SE的一些关键知识点。 1. **基础语法**...
Java SE 基础 练习 Java学习资料
06-24
这份"Java SE 基础 练习 Java学习资料"包含的资源将帮助你深入理解Java编程语言的基础概念和实战技能。以下是这些学习资料可能涵盖的一些关键知识点： 1. **Java环境配置**：首先，你需要安装JDK（Java Development...
java SE基础学习项目 Java学习资料
06-25
这个"java SE基础学习项目"显然是一份针对初学者或者需要巩固基础的开发者的学习资源。在这个项目中，你可能会找到一系列的教程、代码示例、练习题和可能的项目实践，以帮助你深入理解Java编程语言的基础概念。 ...
java SE基础知识点文档
05-31
这份"java SE基础知识点文档"包含了从零开始学习Java编程所必需的关键概念和技能。以下是一些重要的Java SE基础知识： 1. **Java环境配置**：安装JDK（Java Development Kit），设置JAVA_HOME环境变量，配置PATH和...
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 611
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 832
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 964
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 323
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值