Java 注解详解

Java 注解（Annotation）是一种特殊的语法结构，用于在代码中添加元数据。注解不会直接影响程序的运行，但可以被编译器、开发工具或运行时环境读取并处理。注解广泛应用于 Java 的各种框架和库中，如 Spring、Hibernate 等。

常用注解

1. `@Override`

用于标识一个方法是重写父类的方法。

示例代码：

class Parent {
    void display() {
        System.out.println("Parent display");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display");
    }
}

2. `@Deprecated`

表示某个方法、类或字段已过时，不建议使用。

示例代码：

class Example {
    @Deprecated
    void oldMethod() {
        System.out.println("This method is deprecated");
    }
    
    void newMethod() {
        System.out.println("This is the new method");
    }
}

3. `@SuppressWarnings`

用于抑制编译器的警告信息。

@SuppressWarnings 注解用于抑制编译器的警告信息，其 value 属性可以接受不同类型的警告名称，以便指定要抑制的具体警告类型。以下是 @SuppressWarnings 注解中 value 属性常见的取值及其使用方法：

"all"：抑制所有类型的警告。

@SuppressWarnings("all")
void someMethod() {
    // 代码实现
}

"unchecked"：抑制未检查操作的警告，如使用泛型时的类型转换警告。
```
@SuppressWarnings("unchecked")
void someMethod() {
    // 代码实现
}
```

"deprecation"：抑制使用已过时方法或类时的警告。

@SuppressWarnings("deprecation")
void someMethod() {
    // 代码实现
}

"rawtypes"：抑制使用原始类型（Raw Type）时的警告。

@SuppressWarnings("rawtypes")
void someMethod() {
    // 代码实现
}

"unused"：抑制未使用变量或方法时的警告。

@SuppressWarnings("unused")
void someMethod() {
    // 代码实现
}

通过在 @SuppressWarnings 注解中指定不同的 value 值，可以针对性地抑制特定类型的编译器警告，帮助开发者更好地管理代码质量和调试信息。

示例代码：

class Example {
    @SuppressWarnings("unchecked")
    void exampleMethod() {
        List list = new ArrayList(); // 可能会产生 unchecked 警告
        list.add("Hello");
    }
}

4. `@FunctionalInterface`

用于标识一个接口是函数式接口，即只包含一个抽象方法的接口。

示例代码：

@FunctionalInterface
interface MyFunctionalInterface {
    void execute();
}

class Example {
    public static void main(String[] args) {
        MyFunctionalInterface myFunc = () -> System.out.println("Executing...");
        myFunc.execute();
    }
}

5. 自定义注解

可以根据需要定义自己的注解。

示例代码：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

class Example {
    @MyAnnotation(value = "Hello, Annotation!")
    void annotatedMethod() {
        System.out.println("This method is annotated");
    }
}

元注解详解

元注解（Meta-Annotation）是用于注解其他注解的注解，它可以用来控制注解的行为和作用范围。Java 提供了几种内置的元注解，用于定义和处理自定义注解。

常用的元注解

@Target：用于指定注解可以应用的目标元素类型，包括类、方法、字段等。常见取值有：
- ElementType.TYPE：类、接口（包括注解类型）、枚举
- ElementType.METHOD：方法
- ElementType.FIELD：字段
- 其他取值可参考 Java 官方文档
@Retention：用于指定注解的保留策略，即注解在什么级别保存和使用。常见取值有：
- RetentionPolicy.SOURCE：注解仅保留在源代码中，编译时丢弃
- RetentionPolicy.CLASS：注解保留在编译后的字节码文件中，运行时丢弃
- RetentionPolicy.RUNTIME：注解保留在运行时，可以通过反射读取
@Documented：用于指定注解是否包含在 Java 文档中
@Inherited：用于指定注解是否被子类继承

示例代码

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyMetaAnnotation {
    String value() default "Default Value";
}

@MyMetaAnnotation(value = "Custom Value")
class MetaAnnotationExample {

    @MyMetaAnnotation
    void annotatedMethod() {
        System.out.println("Annotated Method");
    }

    public static void main(String[] args) {
        MetaAnnotationExample example = new MetaAnnotationExample();
        example.annotatedMethod();
    }
}

在上面的示例中，MyMetaAnnotation 是一个自定义注解，同时也使用了元注解 @Target 和 @Retention。MyMetaAnnotation 可以应用于类和方法，保留到运行时。在 MetaAnnotationExample 类中，展示了如何在类和方法上使用自定义注解。

File类

Java File 类详解

Java 中的 File 类用于表示文件或目录的抽象路径名，它提供了一系列方法来操作文件系统中的文件和目录。File 类可以用于创建、删除、重命名文件或目录，以及获取文件或目录的属性信息等操作。

常用方法

File(String pathname)：根据指定的路径名创建一个新的 File 实例。
boolean exists()：判断文件或目录是否存在。
boolean isFile()：判断当前 File 实例是否表示一个文件。
boolean isDirectory()：判断当前 File 实例是否表示一个目录。
String[] list()：返回目录下的文件和目录的名称数组。
boolean createNewFile()：创建一个新的空文件。
boolean mkdir()：创建此 File 实例表示的目录。
boolean delete()：删除文件或目录。彻底删除，不进入回收站。
boolean renameTo(File dest)：重命名文件或目录为指定的路径名。
`long length()`：返回文件的长度，单位为字节。
`String getName()`：返回文件或目录的名称。
`String getParent()`：返回父目录的路径名字符串。
`boolean canRead()`：测试应用程序是否可以读取此抽象路径名表示的文件。
`boolean canWrite()`：测试应用程序是否可以修改此抽象路径名表示的文件。
`String getAbsolutePath()`：返回此抽象路径名的绝对路径名字符串。
`long lastModified()`：返回文件最后修改时间的毫秒数。
`File[] listFiles()`：返回目录中的文件和目录的抽象路径名数组。
`boolean isHidden()`：测试此抽象路径名表示的文件是否是一个隐藏文件。
`boolean setReadOnly()`：设置文件或目录为只读。
`boolean setWritable(boolean writable, boolean ownerOnly)`：设置文件或目录的可写权限，ownerOnly 参数指定是否仅修改所有者的权限。
`boolean setExecutable(boolean executable, boolean ownerOnly)`：设置文件或目录的可执行权限，ownerOnly 参数指定是否仅修改所有者的权限。

示例代码

import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        // 创建一个新的 File 实例
        File file = new File("example.txt");

        try {
            // 判断文件是否存在，如果不存在则创建新文件
            if (!file.exists()) {
                file.createNewFile();
                System.out.println("文件创建成功");
            }

            // 判断是否是文件
            if (file.isFile()) {
                System.out.println("这是一个文件");
            }

            // 获取文件名
            System.out.println("文件名：" + file.getName());

            // 获取文件的绝对路径
            System.out.println("文件路径：" + file.getAbsolutePath());

            // 删除文件
            if (file.delete()) {
                System.out.println("文件删除成功");
            } else {
                System.out.println("文件删除失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，展示了如何使用 File 类创建、判断、获取文件信息以及删除文件的操作。通过调用 File 类的方法，可以方便地对文件和目录进行操作。

流

输入输出流是 Java 中用于处理输入和输出的机制，它们用于从源读取数据或向目标写入数据。输入流用于从文件、网络连接或其他数据源读取数据，而输出流用于向文件、网络连接或其他数据目标写入数据。

流关闭顺序：

先关出，再关入

从外往内关

输入流

输入流是用于从数据源读取数据的流。在 Java 中，InputStream 是所有输入流的抽象基类，它提供了读取字节的方法。常见的输入流包括 FileInputStream、BufferedInputStream、DataInputStream 等。

示例代码：

import java.io.*;

public class InputStreamExample {
    public static void main(String[] args) {
        try {
            InputStream input = new FileInputStream("input.txt");
            int data = input.read();
            while (data != -1) {
                System.out.print((char) data);
                data = input.read();
            }
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileInputStream 创建了一个输入流，然后通过 read() 方法逐个字节地读取文件中的数据，并将其转换为字符打印出来。

输出流

输出流用于向数据目标写入数据。在 Java 中，OutputStream 是所有输出流的抽象基类，它提供了写入字节的方法。常见的输出流包括 FileOutputStream、BufferedOutputStream、DataOutputStream 等。

示例代码：

import java.io.*;

public class OutputStreamExample {
    public static void main(String[] args) {
        try {
            OutputStream output = new FileOutputStream("output.txt");
            String data = "Hello, Output Stream!";
            output.write(data.getBytes());
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileOutputStream 创建了一个输出流，然后通过 write() 方法将字符串写入到文件中。

通过输入输出流，可以实现对文件、网络连接等数据源的读取和写入操作，是 Java 中处理输入输出的重要机制。

分段读取文件

在 Java 中，可以使用输入流来分段读取文件的内容。以下是一个示例代码，演示了如何使用 FileInputStream 分段读取文件的内容：

import java.io.*;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            FileInputStream fileInput = new FileInputStream(file);
            byte[] buffer = new byte[1024]; // 定义缓冲区
            int bytesRead;
            while ((bytesRead = fileInput.read(buffer)) != -1) {
                System.out.write(buffer, 0, bytesRead); // 输出读取的内容
            }
            fileInput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个 FileInputStream 对象来读取文件内容，然后定义了一个缓冲区 buffer，使用 read() 方法从文件中读取数据到缓冲区中，最后输出读取的内容。

分段写入文件

类似地，可以使用输出流来分段写入文件的内容。以下是一个示例代码，演示了如何使用 FileOutputStream 分段写入文件的内容：

import java.io.*;

public class FileWriteExample {
    public static void main(String[] args) {
        try {
            File file = new File("output.txt");
            FileOutputStream fileOutput = new FileOutputStream(file);
            String data = "Hello, Output Stream!";
            byte[] bytes = data.getBytes(); // 将字符串转换为字节数组
            fileOutput.write(bytes); // 写入文件
            fileOutput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个 FileOutputStream 对象来写入文件内容，然后将字符串转换为字节数组，使用 write() 方法将字节数组写入文件中。

通过分段读取和写入文件，可以更加灵活地处理大文件或网络数据，避免一次性读取或写入大量数据导致内存溢出或性能问题。

要实现文件的分段复制，可以使用输入输出流来读取和写入文件的内容。以下是一个示例代码，演示了如何实现文件的分段复制：

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        try {
            File sourceFile = new File("source.txt");
            File targetFile = new File("target.txt");

            FileInputStream fileInput = new FileInputStream(sourceFile);
            FileOutputStream fileOutput = new FileOutputStream(targetFile);

            byte[] buffer = new byte[1024]; // 定义缓冲区
            int bytesRead;
            while ((bytesRead = fileInput.read(buffer)) != -1) {
                fileOutput.write(buffer, 0, bytesRead); // 写入目标文件
            }

            fileInput.close();
            fileOutput.close();

            System.out.println("文件复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个源文件和目标文件的 File 对象。然后使用 FileInputStream 从源文件中读取数据，使用 FileOutputStream 将数据写入目标文件中。通过循环读取和写入缓冲区的内容，实现了文件的分段复制。

请注意，上述示例代码中使用的缓冲区大小为 1024 字节，你可以根据实际需求调整缓冲区的大小。较大的缓冲区可以提高复制的效率，但也会占用更多的内存。

另外，还需要注意在使用完输入输出流后，及时关闭流资源，以释放系统资源和确保数据的完整性。

通过以上的示例代码，你可以实现文件的分段复制，并根据需要进行调整和优化。

Reader

Reader 是 Java 中用于读取字符流的抽象类，它是所有字符输入流的父类。Reader提供了一系列方法用于读取字符数据，常见的子类包括 FileReader、BufferedReader、StringReader 等。

示例代码

以下是一个使用 FileReader 读取文件内容的示例代码：

import java.io.*;

public class FileReaderExample {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("example.txt");
            int data = fileReader.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fileReader.read();
            }
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileReader 创建了一个字符输入流，然后通过 read() 方法逐个字符地读取文件中的内容，并将其打印出来。

Writer

Writer 是 Java 中用于写入字符流的抽象类，它是所有字符输出流的父类。Writer 提供了一系列方法用于写入字符数据，常见的子类包括 FileWriter、BufferedWriter、StringWriter 等。

示例代码

以下是一个使用 FileWriter 写入文件内容的示例代码：

import java.io.*;

public class FileWriterExample {
    public static void main(String[] args) {
        try {
            FileWriter fileWriter = new FileWriter("output.txt");
            String data = "Hello, Writer!";
            fileWriter.write(data);
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileWriter 创建了一个字符输出流，然后通过 write() 方法将字符串写入到文件中。

通过 Reader 和 Writer，可以实现对字符数据的读取和写入操作，是 Java 中处理字符流的重要机制。

分段读取字符数据

类似于输入输出流，可以使用字符输入流来分段读取字符数据。以下是一个示例代码，演示了如何使用 FileReader 分段读取文件的内容：

import java.io.*;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            FileReader fileReader = new FileReader(file);
            char[] buffer = new char[1024]; // 定义缓冲区
            int charsRead;
            while ((charsRead = fileReader.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, charsRead)); // 输出读取的内容
            }
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个 FileReader 对象来读取文件内容，然后定义了一个字符数组缓冲区 buffer，使用 read() 方法从文件中读取字符数据到缓冲区中，最后输出读取的内容。

分段写入字符数据

同样地，可以使用字符输出流来分段写入字符数据。以下是一个示例代码，演示了如何使用 FileWriter 分段写入文件的内容：

import java.io.*;

public class FileWriteExample {
    public static void main(String[] args) {
        try {
            File file = new File("output.txt");
            FileWriter fileWriter = new FileWriter(file);
            String data = "Hello, Writer!";
            char[] chars = data.toCharArray(); // 将字符串转换为字符数组
            fileWriter.write(chars); // 写入文件
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个 FileWriter 对象来写入文件内容，然后将字符串转换为字符数组，使用 write() 方法将字符数组写入文件中。

通过分段读取和写入字符数据，可以更加灵活地处理大文件或网络数据，避免一次性读取或写入大量数据导致内存溢出或性能问题。

文件复制

要实现文件的复制，可以使用字符输入输出流来读取和写入文件的内容。以下是一个示例代码，演示了如何实现文件的复制：

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        try {
            File sourceFile = new File("source.txt");
            File targetFile = new File("target.txt");

            FileReader fileReader = new FileReader(sourceFile);
            FileWriter fileWriter = new FileWriter(targetFile);

            char[] buffer = new char[1024]; // 定义缓冲区
            int charsRead;
            while ((charsRead = fileReader.read(buffer)) != -1) {
                fileWriter.write(buffer, 0, charsRead); // 写入目标文件
            }

            fileReader.close();
            fileWriter.close();

            System.out.println("文件复制成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，首先创建了一个源文件和目标文件的 File 对象。然后使用 FileReader 从源文件中读取字符数据，使用 FileWriter 将字符数据写入目标文件中。通过循环读取和写入缓冲区的内容，实现了文件的复制。

请注意，在使用完字符输入输出流后，及时关闭流资源，以释放系统资源和确保数据的完整性。

通过以上的示例代码，你可以实现文件的复制，并根据需要进行调整和优化。

通过输入输出流、字符输入输出流，你可以实现对文件的读取、写入、复制等操作，灵活处理文件数据。在实际开发中，根据具体需求选择合适的输入输出流类，并注意及时关闭流资源，确保程序的健壮性和性能。

MultipartFile 详解

MultipartFile 是 Spring 框架中用于处理文件上传的接口，它提供了一系列方法用于获取上传文件的信息和内容。MultipartFile 接口通常用于在 Spring MVC 中处理文件上传的场景。

常用方法

1. `String getOriginalFilename()`

返回上传文件的原始文件名。

2. `String getName()`

返回表单中文件组件的名称。

3. `String getContentType()`

返回上传文件的内容类型（MIME 类型）。

4. `boolean isEmpty()`

判断上传文件是否为空。

5. `long getSize()`

返回上传文件的大小，单位为字节。

6. `byte[] getBytes()`

将上传文件的内容以字节数组的形式返回。

7. `InputStream getInputStream()`

返回一个 InputStream 对象，用于读取上传文件的内容。

8. `void transferTo(File dest)`

将上传文件保存到指定的目标文件中。

示例代码

import org.springframework.web.multipart.MultipartFile;
import org.springframework.util.FileCopyUtils;

public class FileUploadService {

    public void handleFileUpload(MultipartFile file) {
        if (!file.isEmpty()) {
            try {
                // 获取上传文件的原始文件名
                String originalFilename = file.getOriginalFilename();
                System.out.println("原始文件名：" + originalFilename);

                // 获取上传文件的内容类型
                String contentType = file.getContentType();
                System.out.println("文件类型：" + contentType);

                // 获取上传文件的大小
                long fileSize = file.getSize();
                System.out.println("文件大小：" + fileSize + " 字节");

                // 将上传文件保存到指定目录
                String uploadPath = "/path/to/upload/directory/" + originalFilename;
                file.transferTo(new File(uploadPath));
                System.out.println("文件保存成功");
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("上传文件为空");
        }
    }
}

在上面的示例代码中，定义了一个 FileUploadService 类，其中的 handleFileUpload 方法用于处理文件上传。通过传入 MultipartFile 对象，可以获取上传文件的原始文件名、内容类型、大小等信息，并将文件保存到指定目标文件中。

通过使用 MultipartFile 接口提供的方法，可以方便地处理文件上传的相关操作，如获取文件信息、读取文件内容和保存文件等。

字节流

字节流是 Java 中用于处理字节数据的输入输出流。在 Java 中，字节流主要由 InputStream 和 OutputStream 组成，用于读取和写入字节数据。常见的字节流包括 FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream 等。

示例代码：

import java.io.*;

public class ByteStreamExample {
    public static void main(String[] args) {
        try {
            // 使用 FileInputStream 读取文件
            InputStream input = new FileInputStream("input.txt");
            int data = input.read();
            while (data != -1) {
                System.out.print((char) data);
                data = input.read();
            }
            input.close();

            // 使用 FileOutputStream 写入文件
            OutputStream output = new FileOutputStream("output.txt");
            String content = "Hello, Byte Stream!";
            output.write(content.getBytes());
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileInputStream 读取文件内容，然后使用 FileOutputStream 写入文件内容。

字符流

字符流是 Java 中用于处理字符数据的输入输出流。在 Java 中，字符流主要由 Reader 和 Writer 组成，用于读取和写入字符数据。常见的字符流包括 FileReader、FileWriter、BufferedReader、BufferedWriter 等。

示例代码：

import java.io.*;

public class CharacterStreamExample {
    public static void main(String[] args) {
        try {
            // 使用 FileReader 读取文件
            Reader reader = new FileReader("input.txt");
            int data = reader.read();
            while (data != -1) {
                System.out.print((char) data);
                data = reader.read();
            }
            reader.close();

            // 使用 FileWriter 写入文件
            Writer writer = new FileWriter("output.txt");
            String content = "Hello, Character Stream!";
            writer.write(content);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 FileReader 读取文件内容，然后使用 FileWriter 写入文件内容。

缓冲流

缓冲流是 Java 中用于提高输入输出效率的流。缓冲流通过在内存中设置缓冲区来减少对底层输入输出流的访问次数，从而提高读写效率。常见的缓冲流包括 BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter 等。

示例代码：

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try {
            // 使用 BufferedInputStream 读取文件
            InputStream input = new BufferedInputStream(new FileInputStream("input.txt"));
            int data = input.read();
            while (data != -1) {
                System.out.print((char) data);
                data = input.read();
            }
            input.close();

            // 使用 BufferedOutputStream 写入文件
            OutputStream output = new BufferedOutputStream(new FileOutputStream("output.txt"));
            String content = "Hello, Buffered Stream!";
            output.write(content.getBytes());
            output.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 BufferedInputStream 读取文件内容，然后使用 BufferedOutputStream 写入文件内容。

二进制流

二进制流是 Java 中用于处理二进制数据的输入输出流。二进制流可以用于读取和写入二进制数据，如图像、音频、视频等文件。常见的二进制流包括 DataInputStream、DataOutputStream 等。

示例代码：

import java.io.*;

public class BinaryStreamExample {
    public static void main(String[] args) {
        try {
            // 使用 DataInputStream 读取二进制数据
            DataInputStream dataInput = new DataInputStream(new FileInputStream("data.bin"));
            int data = dataInput.readInt();
            System.out.println("Read data: " + data);
            dataInput.close();

            // 使用 DataOutputStream 写入二进制数据
            DataOutputStream dataOutput = new DataOutputStream(new FileOutputStream("data.bin"));
            int value = 12345;
            dataOutput.writeInt(value);
            dataOutput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，使用 DataInputStream 读取二进制数据，然后使用 DataOutputStream 写入二进制数据。

通过以上示例代码，你可以了解到如何使用字节流、字符流、缓冲流和二进制流进行文件的读取和写入操作。根据实际需求，选择合适的流来处理输入输出操作，可以提高程序的效率和性能。

If you find the article useful, feel free to appreciate

Java基础（十）

https://blog.mykele.asia/archives/javaji-chu-shi

Author

kele

Published on

2024-09-10

Updated on

2024-09-12

License

CC BY 4.0

Java基础（十）

Java 注解详解

常用注解

1. @Override

2. @Deprecated

3. @SuppressWarnings

4. @FunctionalInterface

5. 自定义注解

元注解详解

常用的元注解

示例代码

File类

Java File 类详解

常用方法

示例代码

流

输入流

输出流

分段读取文件

分段写入文件

Reader

示例代码

Writer

示例代码

分段读取字符数据

分段写入字符数据

文件复制

MultipartFile 详解

常用方法

1. String getOriginalFilename()

2. String getName()

3. String getContentType()

4. boolean isEmpty()

5. long getSize()

6. byte[] getBytes()

7. InputStream getInputStream()

8. void transferTo(File dest)

示例代码

字节流

字符流

缓冲流

二进制流

Author

Published on

Updated on

License

Comments

1. `@Override`

2. `@Deprecated`

3. `@SuppressWarnings`

4. `@FunctionalInterface`

1. `String getOriginalFilename()`

2. `String getName()`

3. `String getContentType()`

4. `boolean isEmpty()`

5. `long getSize()`

6. `byte[] getBytes()`

7. `InputStream getInputStream()`

8. `void transferTo(File dest)`