public class Main {
    public static void main(String[] args) {
        // 示例1：字符串反转
        String str = "Hello, World!";
        String reversedStr = new StringBuilder(str).reverse().toString();
        System.out.println(reversedStr); // 输出：!dlroW ,olleH
 
        // 示例2：字符串移位
        String shiftedStr = shiftString("Hello", 2); // 输出："lloHe"
        System.out.println(shiftedStr);
 
        // 示例3：字符串中单词的逆序
        String wordReversedStr = reverseWords("Hello World"); // 输出："olleH dlroW"
        System.out.println(wordReversedStr);
    }
 
    // 字符串反转函数
    public static String reverseString(String s) {
        return new StringBuilder(s).reverse().toString();
    }
 
    // 字符串移位函数
    public static String shiftString(String s, int n) {
        char[] charArray = s.toCharArray();
        for (int i = 0; i < n % s.length(); i++) {
            char temp = charArray[0];
            System.arraycopy(charArray, 1, charArray, 0, charArray.length - 1);
            charArray[charArray.length - 1] = temp;
        }
        return new String(charArray);
    }
 
    // 字符串中单词的逆序函数
    public static String reverseWords(String s) {
        return String.join(" ", reverseWordsArray(s.split(" ")));
    }
 
    // 辅助函数：将单词数组逆序并返回
    public static String[] reverseWordsArray(String[] words) {
        for (int i = 0; i < words.length / 2; i++) {
            String temp = words[i];
            words[i] = words[words.length - 1 - i];
            words[words.length - 1 - i] = temp;
        }
        return words;
    }
}

这段代码首先定义了一个主类Main，在其主方法中演示了字符串反转、字符串移位以及字符串中单词的逆序。代码中使用了StringBuilder来构建字符串，并通过String.join和String.split方法来处理带有空格的字符串。这些操作是常见的字符串处理任务，对于刷题来说是有参考价值的。

在Java中读取Word内容，可以使用Apache POI库。下面是两种不同的实现方法：

方法1：使用XWPF读取器

import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFRun;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
 
public class WordReader {
    public static void main(String[] args) {
        try {
            InputStream fis = new FileInputStream("path/to/your/word/document.docx");
            XWPFDocument document = new XWPFDocument(fis);
 
            for (XWPFParagraph paragraph : document.getParagraphs()) {
                String text = paragraph.getText();
                System.out.println(text);
            }
 
            document.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

方法2：使用HWPF读取器

import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
 
public class WordReader {
    public static void main(String[] args) {
        try {
            InputStream fis = new FileInputStream("path/to/your/word/document.doc");
            HWPFDocument document = new HWPFDocument(fis);
            WordExtractor extractor = new WordExtractor(document);
            
            String[] paragraphs = extractor.getParagraphText();
 
            for (String paragraph : paragraphs) {
                System.out.println(paragraph);
            }
 
            extractor.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：方法1适用于读取.docx格式的Word文档，需要导入poi-ooxml依赖；方法2适用于读取.doc格式的Word文档，需要导入poi依赖。

JAVE（Java Video Encoder）是一个用于处理视频编码的Java库。它基于FFmpeg，这是一个用于处理多媒体的开源工具集。以下是一个简单的例子，展示如何使用JAVE将一个视频文件转换为另一种格式。

首先，确保你的系统上安装了FFmpeg。你可以从FFmpeg官网下载并安装，或者使用包管理器（如apt-get或brew）。

然后，在Java项目中，你需要添加JAVE的依赖。如果你使用Maven，可以在pom.xml中添加如下依赖：

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv</artifactId>
    <version>1.5.5</version>
</dependency>

下面是一个简单的Java程序，使用JAVE将一个视频文件转换为MP4格式：

import org.bytedeco.javacv.FFmpegFrameConverter;
import org.bytedeco.javacv.Frame;
 
import java.io.File;
 
public class VideoConverter {
    public static void convertVideo(String inputPath, String outputPath) throws Exception {
        // 创建FFmpegFrameGrabber来获取视频帧
        FFmpegFrameGrabber grabber = new FFmpegFrameGrabber(inputPath);
        grabber.start();
 
        // 创建FFmpegFrameRecorder来记录视频帧
        FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(outputPath, 
                                                              grabber.getImageWidth(), 
                                                              grabber.getImageHeight(), 
                                                              grabber.getAudioChannels());
        recorder.setFormat("mp4");
        recorder.start();
 
        Frame frame;
        // 循环抓取视频帧并记录
        while ((frame = grabber.grabFrame()) != null) {
            recorder.record(frame);
        }
 
        // 停止记录和抓取
        recorder.stop();
        grabber.stop();
    }
 
    public static void main(String[] args) {
        try {
            String inputPath = "input.avi"; // 输入视频文件路径
            String outputPath = "output.mp4"; // 输出视频文件路径
            convertVideo(inputPath, outputPath);
            System.out.println("转换完成.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

确保替换input.avi和output.mp4为你的输入和输出文件路径。运行这个程序，它会将指定的视频文件转换为MP4格式。

// 引入Frida的JavaScript API
var frida = require('frida');
var process = null;
 
// 连接到设备
frida.attach('com.example.app')
  .then(function(session) {
    process = session;
 
    // 加载需要的脚本
    return session.enable_debugger();
  })
  .then(function() {
    console.log('Debugger is enabled.');
 
    // 注入JavaScript代码
    return process.evaluate(
      'Java.perform(function() {' +
      '  var ActivityThread = Java.use("android.app.ActivityThread");' +
      '  var method = ActivityThread.main.overload("java.lang.String[]");' +
      '  method.implementation = function(args) {' +
      '    console.log("Hooked into ActivityThread.main");' +
      '    return method.call(this, args);' +
      '  };' +
      '});',
      { timeout: 20000 }
    );
  })
  .then(function(result) {
    console.log(result);
    process.kill();
  })
  .catch(function(error) {
    console.error('Error:', error);
    if (process !== null) {
      process.kill();
    }
  });

这段代码使用Frida来连接到一个指定的Android应用程序，并注入JavaScript代码以Hook ActivityThread.main 方法的执行。它展示了如何使用Frida的API进行动态Hook，并在控制台打印出Hook成功的消息。

以下是一个简单的Java控制台应用程序，用于实现加减乘除运算的计算器功能。

import java.util.Scanner;
 
public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        double num1 = scanner.nextDouble();
        System.out.println("请输入运算符（+，-，*，/）：");
        String operator = scanner.next();
        System.out.println("请输入第二个数字：");
        double num2 = scanner.nextDouble();
 
        switch (operator) {
            case "+":
                System.out.println("结果是：" + (num1 + num2));
                break;
            case "-":
                System.out.println("结果是：" + (num1 - num2));
                break;
            case "*":
                System.out.println("结果是：" + (num1 * num2));
                break;
            case "/":
                if (num2 == 0) {
                    System.out.println("错误：除数不能为0");
                } else {
                    System.out.println("结果是：" + (num1 / num2));
                }
                break;
            default:
                System.out.println("错误：未识别的运算符");
        }
 
        scanner.close();
    }
}

这段代码使用了Scanner类来获取用户输入的数字和运算符，并使用switch语句来执行相应的数学运算。用户输入数字后，程序会输出运算结果。如果用户输入了一个未定义的运算符，程序会输出错误信息。

解释：

在Java中，当你使用BigDecimal类型来表示数值时，如果直接将其转换为字符串返回给前端，可能会遇到科学计数法的表示形式，例如"0E-8"。这表示原始数值是0，但由于数值非常小，所以被转换成了科学计数法的形式。同时，如果数值的小数点后面有多余的零，也会被省略掉，以精简字符串表示。

解决方法：

1. 使用BigDecimal的stripTrailingZeros()方法来移除末尾多余的0。
2. 使用toPlainString()方法来获取不带指数的字符串表示，即便是数值很小也不会用科学计数法表示。

示例代码：

BigDecimal bd = ...; // 假设这是你需要返回给前端的BigDecimal数值
bd = bd.stripTrailingZeros(); // 移除末尾多余的0
bd = bd.toPlainString(); // 转换为不带指数的字符串
 
// 然后将bd转换为字符串返回给前端

注意：如果数值本身就是0，使用stripTrailingZeros()后可能会变成"0"，如果你希望保留"0.000"这种形式，那么可以先判断是否为0，如果是0则不调用stripTrailingZeros()。

// 监听键盘按下事件
document.addEventListener('keydown', function(event) {
    const key = event.key; // 获取按下的键名
    console.log('键被按下:', key);
    // 根据按下的键做出相应的操作
    if (key === 'Enter') {
        console.log('确认键被按下');
    } else if (key === 'ArrowUp') {
        console.log('上箭头键被按下');
    } else if (key === 'ArrowDown') {
        console.log('下箭头键被按下');
    }
});
 
// 监听键盘抬起事件
document.addEventListener('keyup', function(event) {
    const key = event.key; // 获取抬起的键名
    console.log('键被抬起:', key);
    // 根据抬起的键做出相应的操作
    if (key === 'Escape') {
        console.log('取消键被松开');
    }
});

这段代码演示了如何在JavaScript中监听键盘按下和抬起的事件，并根据按键的不同执行相应的操作。使用event.key可以获取按键的名称，这样可以针对不同的按键进行逻辑处理。

JDK 11是Java Development Kit 11的简称，是Java编程语言的一个主要版本。它于2018年9月25日正式发布，是Java生命周期的一个重要版本。

JDK 11的主要特性包括：

• 局部变量类型推断（var）
• 新的Epsilon 增强建议（EdRP）
• 改进的GC（G1G）
• 内存区域
• 其他JVM的性能增强
• 模块系统
• 其他语言特性，如文本块（Text Blocks）和更多的语言和平台API

以下是如何安装和使用JDK 11的步骤：

1. 下载：访问Oracle官网或其他Java发行版本网站，下载JDK 11的安装包。
2. 安装：运行安装程序，按照提示完成安装。
3. 配置环境变量：设置JAVA_HOME环境变量指向JDK 11的安装目录，并确保PATH变量包含%JAVA_HOME%\bin（Windows）或$JAVA_HOME/bin（Unix/Linux）。
4. 验证安装：打开命令行或终端窗口，输入java -version。如果正确安装，应该显示Java 11的版本信息。

示例代码（HelloWorld.java）:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

编译和运行：

javac HelloWorld.java
java HelloWorld

以上步骤和代码展示了如何使用JDK 11进行简单的Java程序开发。

Lambda表达式是Java SE 8中的一个新特性，它允许我们将函数作为方法的参数，或者将代码像数据一样进行传递。这样可以使代码变得更加简洁和易读。

Lambda表达式的基本语法是：

(parameters) -> expression

或者

(parameters) -> { statements; }

下面是一些使用Lambda表达式的示例：

1. 使用Lambda表达式替换匿名内部类：

// 使用匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World!");
    }
};
r1.run();
 
// 使用Lambda表达式替换匿名内部类
Runnable r2 = () -> System.out.println("Hello World!");
r2.run();

2. 使用Lambda表达式进行事件处理：

// 使用匿名内部类
button.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("Button Clicked!");
    }
});
 
// 使用Lambda表达式
button.setOnAction(event -> System.out.println("Button Clicked!"));

3. 使用Lambda表达式进行列表的遍历：

// 使用匿名内部类
List<String> list = Arrays.asList("A", "B", "C");
for (String s : list) {
    System.out.println(s);
}
 
// 使用Lambda表达式
list.forEach(s -> System.out.println(s));

4. 使用Lambda表达式进行比较：

// 使用匿名内部类
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});
 
// 使用Lambda表达式
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));

以上示例展示了如何在Java SE 8中使用Lambda表达式来简化代码。Lambda表达式可以使代码更加简洁，易读，并且可以提高开发效率。

题目描述：

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，从左至右的顺序，逐层返回各层的节点值）。

示例：

输入：[3,9,20,null,null,15,7]

输出：[[15,7], [9,20], [3]]

解法1：广度优先搜索（BFS）

使用队列进行层次遍历，每一层的节点放在一个列表中，最后的结果再倒序。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
 
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
 
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
 
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int currentLevelSize = queue.size();
            for (int i = 0; i < currentLevelSize; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(level);
        }
 
        // 最后一步：倒序结果
        Collections.reverse(result);
        return result;
    }
}

这段代码首先定义了一个二叉树节点类TreeNode，然后在levelOrderBottom方法中，使用了一个队列来进行层次遍历，每次将当前层的节点值添加到列表中，最后将结果列表倒序。这样就得到了从底层到顶层的层次遍历结果。