File类和 IO流

File类和 IO流

1.文件(file类)

文件在程序中是以流的形式来操作的

创建文件对象相关构造器和方法

• 相关方法

  • new File(String pathname) // 根据路径构建一个File对象

  • new File(File parent,String child) // 根据父目录文件+子路径构建

  • new File(String parent,String child) // 根据父目录+子路径构建

  • createNewFile 创建新文件

创建文件的三种方法

 package com.file;
 ​
 import org.junit.Test;
 ​
 import java.io.File;
 import java.io.IOException;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/30 10:52
  **/
 public class FileCreate {
     public static void main(String[] args) {
 ​
     }
 ​
     //  new file
     @Test
     public void ctreat() {
         String filePath = "D:\\news1.txt";
         File file = new File(filePath);
         System.out.println(file.exists());
 ​
         try {
             file.createNewFile();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 @Test
     public void creat() {
         File paratFile = new File("D:\\");
         String filename = "NEW2.txt";
         File file = new File(paratFile, filename);
         try {
             file.createNewFile();
             System.out.println(file.exists());
         } catch (IOException e) {
             e.printStackTrace();
         }
 ​
     }
     @Test
     public void ctreat2() {
         String parentPath = "D:/";
         String fileName = "new3.txt";
         File file = new File(parentPath, fileName);
 ​
         try {
             file.createNewFile();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }
 ​
 ​
 ​

常用的文件操作

常见方法

• getName：获取文件名或目录名。

• getAbsolutePath：获取文件或目录的绝对路径。

• getParent：获取文件或目录的父目录路径。

• length：获取文件的大小（以字节为单位）。

• exists：检查文件或目录是否存在。

• isFile：判断该 File 对象是否为文件。

• .isDirectory：判断该 File 对象是否为目录。

目录操作

mkdir 创建一级目录

mkdirs 创建多级目录

delete 删除

2.IO流原理及分类

对于数据的输入和输出操作以"流(stream)"的方式进行,可以看做是一种数据流动.

输入input:读取外部数据

输出onput:将程序内容输出

IO流的原理:

1. I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输，例如读/写文件，网络通讯等。

2. 在Java程序中，对于数据的输入/输出操作是以“流(stream)”的方式进行的。

3. java.io 包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。

4. 输入(input)：读取外部数据（如磁盘、光盘等存储设备的数据）到程序（内存）中。

5. 输出(output)：将程序（内存）中的数据输出到磁盘、光盘等存储设备中。

流的分类

• 按操作数据单位不同：

  • 字节流（8 bit）二进制文件

  • 字符流（按字符）文本文件

• 按数据流的流向不同：

  • 输入流

  • 输出流

• 按流的角色的不同：

  • 字节流

  • 处理/包装流

(抽象基类)	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Write

1.Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。

2.由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

常用类

InputStream: 字节输入流，是所有字节输入流的超类。 常用的 InputStream 子类包括： FileInputStream: 用于从文件中读取字节。 BufferedInputStream: 提供缓冲功能，可以提高读取效率。 ObjectInputStream: 用于反序列化对象，即从字节流中恢复Java对象。

outputstream:字符输出流

基础I/O流的框架：

抽象基类

• 4个节点流（也称为文件流）

InputStream

• FileInputStream

OutputStream

• FileOutputStream

Reader

• FileReader

Writer

• FileWriter

执行步骤：

1. 1.创建读取或写出的 File 类的对象。

2. 2.创建输入流或输出流。

3. 3.具体的读入或写出的过程。读入：read(char[]) buffer写出：write(String str) 或 write(char[]) buffer, 0, len)

4. 4.关闭流资源，避免内存泄漏。

注意点：

1. 1.在进行文件操作时，由于需要关闭流资源，因此应当使用 try-catch-finally 结构来确保异常得到妥善处理。

2. 2.对于输入流：必须确保 File 类的对象所指向的物理磁盘上的文件存在，否则会抛出 FileNotFoundException。

3. 3.对于输出流：如果文件不存在，输出操作会自动创建文件，并将数据写入该文件。如果文件已存在：使用 FileWriter(File file) 或 FileWriter(File file, false) 时，输出数据会覆盖原有文件内容。使用 FileWriter(File file, true) 时，输出数据会在现有文件末尾追加内容，而不是覆盖。

字符流不适合处理非文本文件,

FileInputStream \ FileOutputStream 的使用

1.创建读取或写出的 File 类的对象。

2.创建输入流或输出流。

3.具体的读入或写出的过程。读入：read(byte[] buffer)写出：write(byte[] buffer, 0, len)

4.关闭流资源，避免内存泄漏。

注意点：

• 在3.2 注意点的基础上，进一步了解文件类型相关的注意点。

• 字符流（如 Reader 和 Writer 类）主要用于处理文本文件，不适合处理非文本文件。

• 字节流（如 InputStream 和 OutputStream 类）通常用于处理非文本文件，但也可以用于文本文件的复制操作。

说明：

• 文本文件：通常包括 .txt、.java 等文件，这些文件主要包含文本内容。

• 非文本文件：如 .doc、.xls``.avi 等文件，这些文件通常包含二进制数据，如文档、表格、图片等。

处理流:

缓存流:

类型	抽象基类	节点流（文件流）	缓冲流（处理流的一种）
字节流	InputStream	FileInputStream	BufferedInputStream
	OutputStream	FileOutputStream	BufferedOutputStream
字符流	Reader	FileReader	BufferedReader
	Writer	FileWriter	BufferedWriter

缓冲流的作用:

提升文件读写的效率

• 处理非文本文件的字节流

  • BufferedInputStream

  • BufferedInputStream

• 处理文本文件的字符流

  • BufferedReader

  • BufferedWriter

缓冲流步骤：

第1步：创建File的对象、流的对象（包括文件流、缓冲流） 创建 File 类的对象，用于指定操作的文件。 创建输入流或输出流对象，以及相应的缓冲流对象。 第2步：使用缓冲流实现读取数据或写出数据的过程（重点） 读取： int read(char[] cbuf) 或 int read(byte[] buffer)：每次将数据读入到 cbuf 或 byte 数组中，并返回读入到数组中的字符或字节的数量。如果到达文件末尾，则返回 -1。 写出： void write(String str) 或 void write(char[] cbuf)：将字符串 str 或字符数组 cbuf 写出到文件中。 void write(byte[] buffer)：将字节数组 buffer 写出到文件中。 第3步：关闭资源 在文件操作完成后，确保关闭所有打开的流资源，以释放系统资源并避免内存泄漏。 这些步骤

 import org.junit.Test;
 ​
 import java.io.*;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/30 15:50
  **/
 ​
 public class BufferedStreamTest {
     public static void main(String[] args) {
 ​
     }
     @Test
     public void test1 ()throws Exception {
         File srcFile = new File("img.png");
         File desFile = new File("img_copy.png");
 ​
 ​
         FileInputStream fis = new FileInputStream(srcFile);
         FileOutputStream fos = new FileOutputStream(desFile);
 ​
         BufferedInputStream bis = new BufferedInputStream(fis);
         BufferedOutputStream bos = new BufferedOutputStream(fos);
 ​
         byte[] buf = new byte[1024];
         int len;
          while((len = bis.read(buf)) != -1){
              bos.write(buf, 0, len );
          }
         System.out.println("success");
 ​
          bos.close();
          bis.close();
 ​
     }
 }
 ​

 import org.junit.Test;
 ​
 import java.io.*;
 import java.util.Arrays;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/30 16:08
  **/
 public class BufferedStream02 {
     @Test
     public void test() throws IOException {
         File f1 = new File("des.txt");
         File f2 = new File("f2.txt");
 ​
         FileReader fr1 = new FileReader(f1);
         FileWriter fr2 = new FileWriter(f2);
 ​
         BufferedReader br1 = new BufferedReader(fr1);
         BufferedWriter bw1 = new BufferedWriter(fr2);
 ​
         char[] buf = new char[1024 * 33];
         int len;
         while((len = br1.read(buf)) != -1){
             bw1.write(buf,0,len);
         }
         System.out.println("success");
 ​
         br1.close();
         bw1.close();
 ​
     }
 }
 ​

装换流

字符流转换

• 作用：实现字符串与字符之间的转换，即在字节流和字符流之间进行转换。

• API：

  • InputStreamReader：这个类用于将输入型的字节流（InputStream）转换为字符流（Reader）。它在读取字节时会使用指定的字符集将字节解码为字符。如果没有指定字符集，它会使用平台默认的字符集。

  • OutputStreamWriter：这个类用于将字符流（Writer）转换为输出型的字节流（OutputStream）。它将字符编码为字节，并写入输出流。同样地，如果没有指定字符集，它会使用平台默认的字符集。

字符集

字符集是字符到字节的映射规则，它定义了如何将字符编码为字节，以及如何将字节解码为字符。

• ASCII：美国信息交换标准代码，是最早的字符编码标准之一，主要用于英文字符和一些控制字符，只使用7位二进制数表示字符。

• GBK：中文扩展编码，用于简体中文字符，是中文Windows操作系统的默认编码之一。

• UTF-8：一种广泛使用的字符编码，支持世界上几乎所有的字符，是互联网上使用最广泛的编码。

字符编码：字符、字符串、字符数组 --- 字节、字节数组（从我们能看得懂的 --- 我们看不懂的） 字符解码：字节、字节数组 --- 字符、字符串、字符数组（从我们看不懂的 --- 我们能看得懂的）

如果希望程序在读取文本文件时，不出现乱码，需要注意什么？

解码时使用的字符集必须与初始编码时使用的字符集相同

 import org.junit.jupiter.api.Test;
 ​
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/30 16:43
  **/
 public class InputStreamReaderTest {
     @Test
     public void test1() throws IOException {
        File file1 = new File("f2.txt");
 ​
         FileInputStream fis = new FileInputStream(file1);
 ​
         InputStreamReader isr = new InputStreamReader(fis);
 ​
         InputStreamReader isr2 = new InputStreamReader(fis, "GBK");
 ​
         char[] buf = new char[1024];
         int len = 0;
         while((len = isr2.read(buf)) != -1) {;
          String str = new String(buf, 0, len);
             System.out.println(str);
         }
 ​
         isr.close();
     }
 }
 ​

字符集的理解

4.1 在存储的文件中的字符: asci1:主要用来存储a、b、c等英文字符和1、2、3、常用的标点符号。每个字符占用1个字节。 is0-8859-1:了解，每个字符占用1个字节。向下兼容ascii。 gbk:用来存储中文简体繁体、a、b、c等英文字符和1、2、3、常用的标点符号等字符。中文字符使明2个字节存储心意味着英文字符、1、2、3、标点符号仍使用1个字节。、向下兼客ascii utf-8:可以用来存储世界范围内主要的语言的所有的字符。使用1-4个不等的字节表示一个字符。 中文字符使用3个字节存储的。向下兼容ascii，意味着英文字符、1、2、3、标点符号仍使用1个字节。 4.2 在内存中的字符: 一个字符(char)占用2个字节,内存中使用的字符集称为unicode字符集

数据流

Data0utputstream:可以将内存中的基本数据类型的变量、String类型的变量写出到具体的文件中。 DataInputstream:将文件中保存的数据还原为内存中的基本数据类型的变量、String类型的变量。

对象流及其作用

2.1 API: 0bjectInputSteam 0bjectOutputStream 2.2 作用: 可以读写基本数据类型的变量、引用数据类型的变量。 3.对象的序列化机制是什么[ Iib eG Hierarchy Notificitions 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。

4.如下两个过程使用的流:

序列化过程,使用ObjectOutputSream 实现,将内存中的Java对象保存在文件中或通过网络传输出去

反序列化过程,使用ObjectInputStream实现,将文件中的数据或网络传输过来的数据还原为内存的Java对象

5.自定义类要想实现序列化机制，需要满足: ① 自定义类需要实现接口:Serirlizable ② 要求自定义人，明一个全局第量static.allong serialVersionUID=42234234L; 6.注童点: ① 如果不声明全局常量serialVersionUID，系统会自动声明生成一个针对于当前类的serialVersionUID。如果修改此类的话，会导致serialVersionUID变化，进而导致反序列化时，出现InvalidclassException异常

实例

 import sun.plugin2.message.Serializer;
 ​
 import java.io.Serializable;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/31 11:20
  **/
 public class Person implements Serializable {
     private String name;
     private int age;
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     @Override
     public String toString() {
         return "Person{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 }
 ​

 import org.junit.Test;
 ​
 import java.io.*;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/31 11:09
  **/
 public class ObjectInputOutputStream {
 ​
 //    序列化过程
     public void test1() throws IOException {
         File file = new File("test.txt");
         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
 ​
         oos.writeUTF("nihao");
         oos.flush();
 ​
         oos.close();
 ​
 ​
     }
 ​
     public void test2() throws IOException {
         File file = new File("object.txt");
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
 ​
         String str1 = ois.readUTF();
         System.out.println(str1);
     }
 ​
 ​
     @Test
     public void test3() throws IOException {
         File file = new File("object.txt");
         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
 ​
         Person p1 = new Person("tom",12);
 ​
         oos.writeObject(p1);
         oos.flush();
 ​
         oos.close();
     }
     @Test
     public void test4() throws IOException, ClassNotFoundException {
         File file = new File("object.txt");
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
 ​
         Person person = (Person) ois.readObject();
         System.out.println(person);
 ​
         ois.close();
     }
 }
 ​

其他流

1.标准的输入输出流

System.in:标准的输入流,默认从键盘输入

system.out:标准的输出流,默认从显示器显示

通过调用方法,修改输入流,输出流的位置

setIn(inputstream is)

setOut(printstream ps)

 Javafliter
 avatar
 Javafliter
 看起来你可能是想询问关于 Java Filter 的信息，Java Filter 是 Java Web 编程中用于请求和响应处理的一种技术。它允许你在服务器处理请求之前或之后修改请求或响应。Java Filter 是 Java Servlet API 的一部分，通常用于实现跨站请求伪造（CSRF）防护、日志记录、数据压缩、加密解密、图片转换等功能。
 ​
 一个基本的 Filter 包括以下几个主要部分：
 ​
 1.
 Filter 接口实现：实现 javax.servlet.Filter 接口，需要重写 init, doFilter, 和 destroy 方法。
 init: 在 Filter 实例化后，初始化方法会被调用一次，可以在这里加载资源或初始化参数。
 doFilter: 这是核心方法，每次请求到达时都会调用。你可以在这个方法中处理请求和响应。
 destroy: 当 Filter 实例被销毁前，此方法会被调用，可以在这里释放资源。
 2.
 web.xml 配置：在传统的 web.xml 文件中配置 Filter，指定 Filter 的名称、类名以及需要拦截的 URL 模式。
 xml
 <filter>
     <filter-name>MyFilter</filter-name>
     <filter-class>com.example.MyFilter</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>MyFilter</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>
 3.
 注解配置（Java EE 6 及以上版本）：使用 @WebFilter 注解直接在 Filter 类上声明配置信息。
 java
 @WebFilter("/*")
 public class MyFilter implements Filter {
     // ...
 }
 回答已停止
 Java web fliter\
 在 Java Web 开发中，Filter（过滤器）是一种用于拦截和处理请求和响应的组件。它主要用于在 Servlet 处理请求之前或之后执行一些操作，比如进行权限检查、日志记录、数据格式化等。下面是一个简单的 Java Web Filter 的例子，以及如何在 web.xml 中配置它。
 ​
 Java Web Filter 示例
 首先，创建一个实现了 javax.servlet.Filter 接口的类：
 ​
 java
 import javax.servlet.*;
 import java.io.IOException;
 ​
 public class MyFilter implements Filter {
 ​
     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
         // 在 Filter 初始化时调用，可以用来加载资源
     }
 ​
     @Override
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
             throws IOException, ServletException {
         // 在请求到达目标 Servlet 之前执行的代码
         System.out.println("Request is being filtered...");
 ​
         // 继续传递请求到下一个过滤器或 Servlet
         chain.doFilter(request, response);
 ​
         // 在请求从 Servlet 返回后执行的代码
         System.out.println("Request has been processed by the target Servlet");
 回答已停止
 基本原理
 Java Web Filter 的基本原理是基于拦截器模式，它允许开发者在请求到达目标资源（如 Servlet）之前或之后执行特定的代码。Filter 通过一系列的回调方法来实现其功能，其工作流程大致如下：
 ​
 1.
 初始化（init）:
 当 Web 应用启动或 Filter 被部署时，Servlet 容器会创建 Filter 实例，并调用其 init 方法。
 在这个方法中，你可以进行初始化操作，比如加载配置文件、初始化资源等。
 init 方法只会被调用一次。
 2.
 过滤（doFilter）:
 对于每一个经过 Filter 的请求，容器都会调用 doFilter 方法。
 在 doFilter 方法中，你可以执行请求处理前的逻辑，比如验证用户权限、日志记录、修改请求头等。
 通过调用 FilterChain 对象的 doFilter 方法，请求会被传递到下一个过滤器或最终的目标资源（如 Servlet）。
 在请求处理完毕后，doFilter 方法还可以执行一些后处理逻辑，比如再次修改响应、记录日志等。
 3.
 销毁（destroy）:
 当 Web 应用关闭或 Filter 被移除时，Servlet 容器会调用 destroy 方法。
 在这个方法中，你可以进行资源清理工作，比如关闭文件、释放数据库连接等。
 destroy 方法也只会被调用一次。
 过滤器链（Filter Chain）
 当一个请求到达时，Servlet 容器会根据配置决定哪些 Filter 应用到这个请求上，并按照配置的顺序执行它们的 doFilter 方法。
 在 doFilter 方法中，开发者需要调用 FilterChain 的 doFilter 方法来传递请求到下一个 Filter 或目标资源。
 这种机制允许开发者在请求到达目标资源之前和之后执行代码，而不需要修改目标资源本身的代码。
 配置 Filter
 Filter 可以通过两种方式配置：
 ​
 web.xml 配置:
 在传统的 web.xml 文件中配置 Filter，指定 Filter 的名称、类名以及需要拦截的 URL 模式。
 ​
 xml
 <filter>
     <filter-name>MyFilter</filter-name>
     <filter-class>com.example.MyFilter</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>MyFilter</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>
 注解配置 (Java EE 6 及以上版本):
 使用 @WebFilter 注解直接在 Filter 类上声明配置信息。
 ​
 java
 @WebFilter("/*")
 public class MyFilter implements Filter {
     // ...
 }
 通过这种方式，Filter 为 Java Web 应用提供了一种灵活且强大的机制来处理请求和响应，而无需修改实际的业务逻辑代码。
 ​
 基本原理
 Java Web Filter 的基本原理是基于拦截器模式，它允许开发者在请求到达目标资源（如 Servlet）之前或之后执行特定的代码。Filter 通过一系列的回调方法来实现其功能，其工作流程大致如下：
 ​
 1.
 初始化（init）:
 当 Web 应用启动或 Filter 被部署时，Servlet 容器会创建 Filter 实例，并调用其 init 方法。
 在这个方法中，你可以进行初始化操作，比如加载配置文件、初始化资源等。
 init 方法只会被调用一次。
 2.
 过滤（doFilter）:
 对于每一个经过 Filter 的请求，容器都会调用 doFilter 方法。
 在 doFilter 方法中，你可以执行请求处理前的逻辑，比如验证用户权限、日志记录、修改请求头等。
 通过调用 FilterChain 对象的 doFilter 方法，请求会被传递到下一个过滤器或最终的目标资源（如 Servlet）。
 在请求处理完毕后，doFilter 方法还可以执行一些后处理逻辑，比如再次修改响应、记录日志等。
 3.
 销毁（destroy）:
 当 Web 应用关闭或 Filter 被移除时，Servlet 容器会调用 destroy 方法。
 在这个方法中，你可以进行资源清理工作，比如关闭文件、释放数据库连接等。
 destroy 方法也只会被调用一次。
 过滤器链（Filter Chain）
 当一个请求到达时，Servlet 容器会根据配置决定哪些 Filter 应用到这个请求上，并按照配置的顺序执行它们的 doFilter 方法。
 在 doFilter 方法中，开发者需要调用 FilterChain 的 doFilter 方法来传递请求到下一个 Filter 或目标资源。
 这种机制允许开发者在请求到达目标资源之前和之后执行代码，而不需要修改目标资源本身的代码。
 配置 Filter
 Filter 可以通过两种方式配置：
 ​
 web.xml 配置:
 在传统的 web.xml 文件中配置 Filter，指定 Filter 的名称、类名以及需要拦截的 URL 模式。
 ​
 xml
 <filter>
     <filter-name>MyFilter</filter-name>
     <filter-class>com.example.MyFilter</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>MyFilter</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>
 注解配置 (Java EE 6 及以上版本):
 使用 @WebFilter 注解直接在 Filter 类上声明配置信息。
 ​
 java
 @WebFilter("/*")
 public class MyFilter implements Filter {
     // ...
 }
 通过这种方式，Filter 为 Java Web 应用提供了一种灵活且强大的机制来处理请求和响应，而无需修改实际的业务逻辑代码。
 ​
    String value() default "";
     String description() default "";
 The code snippet you've provided appears to be Java annotations, specifically the default values for parameters within an annotation definition. Here's a breakdown of what each part means:
 ​
 java
 String value() default "";
 String description() default "";
 String value() default "";: This defines a parameter named value for the annotation. If a user of this annotation doesn't specify a value for this parameter, it will default to an empty string (""). This parameter is often used as a shorthand when applying the annotation, allowing users to omit the parameter name when the value is provided.
 String description() default "";: This defines another parameter named description for the annotation. It also defaults to an empty string if not explicitly provided by the user of the annotation.
 Annotations in Java are a form of metadata that can be added to Java code. They don't directly affect the operation of the code they are annotating but can be used by various tools, frameworks, or libraries to perform actions or checks at compile time or runtime
 ​
 回答已停止
 代码解析
 The code snippet you've provided is part of an annotation definition in Java. Annotations are special markers that can be applied to code elements like classes, methods, variables, parameters, etc., to provide metadata. Here's a detailed explanation of the code:
 ​
 java
 String value() default "";
 String description() default "";
 Explanation:
 1.
 String value() default "";
 String: This indicates that the parameter value is of type String.
 value(): This is the name of the parameter that can be passed when using the annotation. It's a common convention to have a value parameter because it allows for a shorthand syntax when applying the annotation.
 default "": This specifies that if no value is provided for the value parameter when the annotation is used, it will default to an empty string (""). The default keyword is used to provide a default value for an annotation parameter.
 2.
 String description() default "";
 Similar to the first parameter, description is another parameter of the annotation that can hold a String value.
 It also has a default value of an empty string (""), meaning if a user does not specify a value for description when applying the annotation, it will automatically be set to an empty string.
 Example Usage:
 Here's how you might use this annotation in Java code:
 ​
 java
 @MyAnnotation(value = "Example Value", description = "This is an example description.")
 public class MyClass {
     // ...
 }
 However, because value is a common parameter name for annotations, you can use a shorthand syntax:
 ​
 java
 @MyAnnotation("Example Value")
 public class MyClass {
     // ...
 }
 In this shorthand version, the compiler automatically assigns the provided string to the value parameter.
 ​
 Annotation Definition:
 The full annotation definition might look something like this:
 ​
 java
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.ANNOTATION_TYPE
 回答已停止
 中文
 您提供的代码片段是Java注解定义的一部分。注解是Java中一种特殊的标记，可以添加到代码元素（如类、方法、变量、参数等）上，以提供元数据。下面是对代码的详细解释：
 ​
 java
 String value() default "";
 String description() default "";
 解释：
 1.
 String value() default "";
 String：这表示参数value的类型是String。
 value()：这是注解中参数的名称，可以在使用注解时指定。通常，value参数是一个约定俗成的名称，因为它允许在使用注解时使用简写语法。
 default ""：这指定了如果没有为value参数提供值时的默认值是空字符串（""）。default关键字用于为注解参数提供默认值。
 2.
 String description() default "";
 类似于第一个参数，description是注解的另一个可以持有String值的参数。
 它也有一个默认值，即空字符串（""），意味着如果用户在使用注解时没有指定description的值，它将自动设置为空字符串。
 使用示例：
 下面是注解在Java代码中的使用方式：
 ​
 java
 @MyAnnotation(value = "示例值", description = "这是一个示例描述。")
 public class MyClass {
      // ...
 }
 然而，由于value是注解中常用的参数名称，你可以使用简写语法：
 ​
 java
 @MyAnnotation("示例值")
 public class MyClass {
      // ...
 }
 在这个简写版本中，编译器会自动将提供的字符串赋值给value参数。
 ​
 注解定义：
 完整的注解定义可能看起来像这样：
 ​
 java
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.ANNOTATION_TYPE)
 public @interface MyAnnotation {
     String value() default "";
     String description() default "";
 }
 在这里，@Retention和@Target是元注解，分别用于指定注解的保留策略和目标类型。@interface关键字用于声明注解类型。
 ​
 演示一种注解的方式配置filter
 在Java中，使用注解配置Filter是一种简洁且现代的方式。下面我将演示如何定义一个带有注解的Filter，并展示如何在web.xml中配置它（尽管使用注解后，web.xml配置变得可选）。
 ​
 步骤 1: 定义带有注解的Filter
 首先，创建一个Filter类，并使用@WebFilter注解来指定它应该拦截的URL模式。
 ​
 java
 import javax.servlet.*;
 import javax.servlet.annotation.WebFilter;
 import java.io.IOException;
 ​
 @WebFilter(urlPatterns = "/*") // 拦截所有请求
 public class MyFilter implements Filter {
 ​
     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
         // 初始化代码
     }
 ​
     @Override
     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
             throws IOException, ServletException {
         // 在请求到达目标资源之前执行的代码
         System.out.println("Filter is processing the request.");
 ​
         // 继续传递请求到下一个过滤器或目标资源
         chain.doFilter(request, response);
 ​
         // 在请求处理完毕后执行的代码
         System.out.println("Request has been processed by the target resource.");
     }
 ​
     @Override
     public void destroy() {
         // 清理代码
     }
 }
 步骤 2: 配置web.xml（可选）
 如果你使用的是传统的web.xml配置方式，你仍然可以配置Filter，但使用@WebFilter注解后，这一步骤变得可选。如果你选择使用web.xml，你的Filter配置可能如下所示：
 ​
 xml
 <filter>
     <filter-name>MyFilter</filter-name>
     <filter-class>com.example.MyFilter</filter-class>
 </filter>
 <filter-mapping>
     <filter-name>MyFilter</filter-name>
     <url-pattern>/*</url-pattern>
 </filter-mapping>
 注意事项
 使用@WebFilter注解后，通常不需要在web.xml中配置Filter，因为注解已经足够告诉Servlet容器如何处理Filter。
 urlPatterns属性定义了Filter拦截的URL模式。在这个例子中，"/*"表示拦截所有请求。
 init方法在Filter初始化时调用一次，可以用来加载资源或执行初始化代码。
 doFilter方法是Filter的核心，每次请求到达时都会调用。在这个方法中，你可以修改请求和响应，或者决定是否继续传递请求到下一个Filter或目标资源。
 destroy方法在Filter被销毁前调用，可以用来执行清理工作。
 通过这种方式，你可以非常灵活地使用注解来配置和管理你的Filter，使得代码更加简洁和易于维护。
 ​
 import org.junit.jupiter.api.Test;
 ​
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/31 12:21
  **/
 public class OtherStream {
 @Test
     public void test1() {
         System.out.println("请输入信息(退出输入e/exit)");
 //        把标准输入流包装成字符流,在包装成缓冲流
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         String s = null;
         try{
            while((s = br.readLine()) != null) {
               if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
                     System.out.println("安全退出");
                   break;
               }
              //将读取到的整行字符串转成大写输出
 ​
              System.out.println("----->" + s.toUpperCase());
              System.out.println("继续输入");
 ​
           }
         }catch(IOException e){
             e.printStackTrace();
         }finally{
             try{
                 if(br != null) {
                     br.close();
                 }
             }catch(IOException e){
                 e.printStackTrace();
             }
         }
     }
 }
 您提供的代码是一个简单的Java程序，它使用JUnit 5进行测试，并包含一个读取标准输入并将其转换为大写的功能。程序会持续读取用户输入直到用户输入 "e" 或 "exit"。下面是代码的详细解释：
 ​
 导入的包
 java
 import org.junit.jupiter.api.Test;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 org.junit.jupiter.api.Test：导入JUnit 5的测试注解，用于标记测试方法。
 java.io.BufferedReader：用于读取文本数据。
 java.io.IOException：异常类，用于处理输入输出异常。
 java.io.InputStreamReader：将字节流转换为字符流。
 类定义
 java
 public class OtherStream {
     // 测试方法
     @Test
     public void test1() {
         // 提示用户输入信息
         System.out.println("请输入信息(退出输入e/exit)");
 ​
         // 创建BufferedReader对象，包装System.in
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 ​
         String s = null;
         try {
             // 循环读取输入直到用户输入"e"或"exit"
             while ((s = br.readLine()) != null) {
                 if ("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)) {
                     System.out.println("安全退出");
                     break;
                 }
                 // 将读取到的字符串转换为大写并输出
                 System.out.println("----->" + s.toUpperCase());
                 System.out.println("继续输入");
             }
         } catch (IOException e) {
             // 捕获并打印异常信息
             e.printStackTrace();
         } finally {
             // 关闭BufferedReader对象
             try {
                 if (br != null) {
                     br.close();
                 }
             } catch (IOException e) {
                 // 再次捕获并打印异常信息
                 e.printStackTrace();
             }
         }
     }
 }
 代码逻辑
 1.
 创建BufferedReader对象：通过包装System.in（标准输入流），创建一个BufferedReader对象，以便逐行读取用户输入。
 2.
 循环读取输入：使用while循环和readLine()方法读取用户输入的每一行，直到输入为null（通常不会发生，除非发生I/O错误）。
 3.
 检查退出条件：如果用户输入"e"或"exit"（不区分大小写），则打印退出信息并退出循环。
 4.
 转换并输出大写字符串：将用户输入的字符串转换为大写，并在前面加上箭头标记输出。
 5.
 异常处理：使用try-catch块捕获并处理可能发生的IOException。
 6.
 资源清理：使用finally块确保BufferedReader对象在使用完毕后被关闭，即使发生异常也是如此。
 测试注解
 @Test注解标记了test1方法为JUnit测试方法。这意味着你可以使用JUnit框架来运行这个方法作为测试。
 ​
 注意事项
 代码中没有实际的JUnit测试逻辑，因为test1方法只是简单地读取和处理输入，并没有断言或验证预期结果。
 在实际的测试中，你可能需要添加断言来验证程序的输出是否符合预期。
 希望这能帮助你更好地理解代码的功能和结构！如果你有任何问题或需要进一步的帮助，请随时告诉我。
 ​
 idea的Java控制台为只读不能输入
 在 IntelliJ IDEA 中，Java控制台默认是用于显示程序输出的，而不是用于输入。如果你需要在IDEA中运行需要用户输入的Java程序，你可以使用以下几种方法：
 ​
 1. 使用Run窗口
 对于简单的程序，你可以直接在IDEA的Run窗口中运行程序。程序运行后，它会显示在Run窗口中，但你不能直接在该窗口中输入。如果你的程序需要交互式输入，你可能需要使用外部终端或命令提示符。
 ​
 2. 使用外部终端
 对于需要输入的Java程序，推荐的方法是使用外部终端（如命令提示符、PowerShell或终端应用）来运行你的Java程序。这样，你可以直接在终端中与程序交互。
 ​
 步骤：
 1.
 编译Java程序：在终端中，导航到包含你的.java文件的目录，并使用javac命令编译你的程序。
 sh
 javac YourProgram.java
 2.
 运行编译后的类：使用java命令运行编译后的.class文件。
 sh
 java OtherStream
 （注意：确保你的类名和文件名相匹配）
 3.
 输入数据：程序运行后，你可以在IDEA的Run窗口中看到输出，并直接在外部终端中输入数据。
 3. 使用IDEA的Run/Debug配置
 如果你希望在IDEA内部进行交互式
 ​
 回答已停止
 上述代码运行之后无法输入
 您提供的代码是一个简单的Java程序，它使用BufferedReader从标准输入（键盘）读取数据，并在用户输入特定的退出命令（"e" 或 "exit"）之前，将输入的字符串转换为大写并输出。如果您在运行此程序时遇到无法输入的情况，可能是因为程序没有正确编译或运行，或者IDEA的控制台设置有误。
 ​
 确保程序正确编译和运行
 1.
 编译程序：确保您的Java源代码文件（例如OtherStream.java）没有编译错误。在IDEA中，通常您只需要点击运行按钮，IDEA会自动编译并运行您的程序。
 2.
 运行程序：在IDEA中，运行程序后，控制台窗口应该显示提示信息“请输入信息(退出输入e/exit)”。此时，您应该能够在控制台中输入文本。
 确保IDEA控制台设置正确
 1.
 检查控制台焦点：确保IDEA的控制台窗口是活动的，即它应该有焦点，这样您才能在其中输入文本。
 2.
 使用外部终端：如之前所述，您也可以选择在外部终端（如命令提示符、PowerShell或终端应用）中运行您的Java程序，这样可以确保输入和输出的交互性。
 程序运行时的注意事项
 程序在等待输入时，控制台窗口应该处于活动状态，以便您可以直接在其中输入文本。
 如果您在IDEA的Run窗口中看到程序输出，但无法输入，可能是因为Run窗口没有获得焦点。尝试点击Run窗口，确保它成为活动窗口。
 如果问题依旧存在
 如果以上步骤都无法解决问题，可能需要检查IDEA的设置或尝试重启IDEA。在极少数情况下，IDEA的某些插件或配置可能导致控制台行为异常，这时可以尝试禁用插件或重置IDEA的设置。
 ​
 希望这些建议能帮助您解决问题。如果您还有其他疑问或需要进一步的帮助，请随时告诉我！
 ​
 ​
 看起来你描述的错误提示窗口是由于尝试在一个只读视图中运行测试导致的。在IntelliJ IDEA或其他类似的集成开发环境（IDE）中，如果你尝试在一个只读文件或视图上执行操作（比如运行测试），可能会遇到这样的提示。
 ​
 要解决这个问题，你可以尝试以下步骤：
 ​
 1.
 检查文件是否只读：确保你正在编辑的文件test1()不是只读的。在Windows系统中，文件属性中有一个“只读”选项，你需要确保它没有被勾选。在Linux或Mac系统中，文件权限可能需要调整。
 2.
 重新打开文件：尝试关闭当前的文件编辑器标签页，然后重新打开test1()文件。有时候IDE可能因为某些原因将文件设置为只读。
 3.
 检查项目设置：在IDE的设置中检查是否有任何配置导致文件或视图被设置为只读。这可能涉及到版本控制系统的配置，比如Git。
 4.
 重启IDE：如果上述步骤都不起作用，尝试重启你的IDE。有时候重启可以解决临时的文件或权限问题。
 5.
 检查版本控制系统：如果你的项目处于版本控制之下（如Git），确保你没有错误地将文件标记为只读，或者在.gitignore文件中错误地排除了文件。
 如果上述步骤都不能解决问题，可能需要更详细地检查你的IDE设置或项目配置。如果需要，可以提供更多的信息，比如你使用的IDE版本，或者你是否在使用版本控制系统等，这样我可以提供更具体的帮助。
 ​
 键盘输入代码
 如果你在使用IntelliJ IDEA或其他IDE运行Java程序时遇到无法输入的问题，这通常与IDE的控制台设置有关。在你描述的场景中，似乎存在一个误解：错误提示窗口显示“此视图因为只读1个测试”，这可能意味着你尝试在一个只读视图中运行测试，而不是在控制台中输入数据。
 ​
 解决方法：
 1.
 确保程序正确运行：
 确保你的Java程序已经正确编译。在IDEA中，通常点击运行按钮会自动编译并运行程序。
 确保程序运行后，控制台窗口是活动的，这样你才能在其中输入数据。
 2.
 使用IDEA的Run窗口：
 在IDEA中，运行Java程序后，程序的输出会显示在Run窗口中。如果你的程序需要交互式输入（如你的OtherStream类），你可以在Run窗口中看到提示信息，并直接在该窗口中输入数据。
 3.
 检查Run窗口焦点：
 如果Run窗口没有获得焦点，你可能无法在其中输入数据。确保点击Run窗口，使其成为活动窗口。
 4.
 使用外部终端：
 如果IDE的Run窗口仍然无法输入，你可以尝试在外部终端（如命令提示符、PowerShell或终端应用）中运行你的Java程序。这样，你可以直接在终端中与程序交互。
 5.
 检查IDE设置：
 如果以上方法都不起作用，可能需要检查IDE的设置。确保没有插件或配置错误地改变了Run窗口的行为。
 如果问题依旧存在：
 尝试重启IDE。
 检查是否有版本控制系统（如Git）的配置导致文件或视图被设置为只读。
 如果你使用的是版本控制系统，确保没有错误地将文件标记为只读，或者在.gitignore文件中错误地排除了文件。
 希望这些建议能帮助你解决问题。如果你需要进一步的帮助，请提供更多信息，比如你使用的IDE版本，或者你是否在使用版本控制系统等。
 ​
 写一个键盘输入字符的代码
 如果你想要一个简单的Java程序来读取键盘输入的字符，下面是一个基本的示例代码。这个程序会持续读取用户输入直到用户输入特定的退出命令（比如 "e" 或 "exit"），并将其转换为大写输出。
 ​
 java
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 ​
 public class KeyboardInputExample {
     public static void main(String[] args) {
         // 把标准输入流包装成字符流,在包装成缓冲流
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 ​
         String input;
         try {
             System.out.println("请输入信息(退出输入e/exit)");
             while ((input = br.readLine()) != null) {
                 if ("e".equalsIgnoreCase(input) || "exit".equalsIgnoreCase(input)) {
                     System.out.println("安全退出");
                     break;
                 }
                 // 将读取到的整行字符串转成大写输出
                 System.out.println("----->" + input.toUpperCase());
                 System.out.println("继续输入");
             }
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if (br != null) {
                     br.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 }

idea24版遇到测试类没有办法输入,显示只读的问题:

解决方法:点击help--->编辑自定义虚拟机选项---->输入-Deditable.java.test.console=true 后重启idea

2.打印流

 import org.testng.annotations.Test;
 ​
 import java.io.FileNotFoundException;
 import java.io.PrintStream;
 ​
 /**
  * @Author: 姚宗硕
  * @Description: TODO
  * @DateTime: 2024/8/31 13:05
  **/
 public class OtherStream {
     @Test
     public void test() throws FileNotFoundException {
         PrintStream ps = new PrintStream("test.txt");
 ​
          ps.println("Hello World");
 ​
 ​
         System.out.println(ps);
         System.out.println("hello");
 ​
         ps.close();
     }
 }