Appendable:[https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html](https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html)，接口，允许append。





CharSequence：[https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html](https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html)，接口，字符list操作。

String：[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html)，实现接口CharSequence，String是可哈希的，创建后就无法再改变。

StringBuilder：[https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html)，本质通过字符数组实现，非线程安全的！其他操作和StringBuffer没大的区别。

StringBuffer：[https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html)，本质通过字符数组实现，线程安全！

![在这里插入图片描述](/static/img/images/04813.png)


![在这里插入图片描述](/static/img/images/04814.png)

【Java】java字符串操作，Appendable，CharSequence，String，StringBuilder，StringBuffer

# jar包下载





使用这个jar包：[https://github.com/stleary/JSON-java](https://github.com/stleary/JSON-java)

然后下载这个jar包操作读写文件更方便：[https://commons.apache.org/proper/commons-io/](https://commons.apache.org/proper/commons-io/)

![在这里插入图片描述](/static/img/images/04815.png)


# json对象写入到json文件

```java
package com.item1.hello;
import org.apache.commons.io.FileUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.IOException;
public class test1 {
    // 测试json对象写入到文件
    public static void testJsonWriteFile() throws IOException {
        JSONArray ja = new JSONArray(); //json列表
        JSONObject jo = new JSONObject(); //json字典
        jo.put("filename", "test");
        jo.put("value1", 123);
        jo.put("value2", 12.34);
        jo.put("value2", true);
        ja.put(jo);  //字典推入列表
        File file = new File("json1.json");
        FileUtils.write(file, ja.toString(), "utf-8", false);
    }
    public static void main(String[] args) throws IOException {
        testJsonWriteFile();
    }
}
```

# 读取json文件成json对象



```java
package com.item1.hello;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
public class test1 {
    public static void testJsonReadFile() throws IOException {
        File file=new File("json1.json");
        String content= FileUtils.readFileToString(file,"UTF-8");
        System.out.println(content);
        JSONArray ja=new JSONArray(content);
        System.out.println(ja);
    }
    public static void main(String[] args) throws IOException {
        testJsonReadFile();
    }
}
```

# 更多例子

[https://github.com/stleary/JSON-java/blob/master/Examples.md](https://github.com/stleary/JSON-java/blob/master/Examples.md)

【Java】java 读写 json文件，java读写文件

[https://mp.weixin.qq.com/s/6V5FZ8qepuOshFaFBAmn5w](https://mp.weixin.qq.com/s/6V5FZ8qepuOshFaFBAmn5w)

【java】java的命名规范

# 1 下载 





下载安装包：[链接](https://www.oracle.com/java/technologies/downloads/#java8)

![在这里插入图片描述](/static/img/images/04853.png)

# 2 安装

安装就默认安装在C盘最好，安装在其他盘JDK和JRE需要同一路径设置起来有点烦：

![在这里插入图片描述](/static/img/images/04854.png)

# 3 配置环境变量

变量名：`JAVA_HOME`

变量值：`C:\Program Files\Java\jdk1.8.0_333`

变量名：`CLASSPATH`

变量值：`.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;`

变量名：`Path`

变量值：`%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;`

注意！！！！windows10好像需要绝对路径，而不能使用`%JAVA_HOME%`这样的相对路径。javac 命令不可用的话需要重启一下电脑。

![在这里插入图片描述](/static/img/images/04855.png)

![在这里插入图片描述](/static/img/images/04856.png)

# 4 测试

win+R cmd

![在这里插入图片描述](/static/img/images/04857.png)

![在这里插入图片描述](/static/img/images/04858.png)

【Windows 安装JDK8】如何安装java JDK8

1 下载安装包：[链接](https://www.oracle.com/java/technologies/downloads/#java8)





压缩包解压配置比较麻烦，直接下载RPM包。

![在这里插入图片描述](/static/img/images/04859.png)

2 CentOS7执行：

```bash
rpm -ivh jdk-8u333-linux-x64.rpm
```

【CentOS7 安装JDK8】如何安装java JDK8

三种创建方式





1 Thread Class  继承Thread类

2 Runnable接口  实现Runnable接口

3 Callable接口 实现Callable接口


# 方法一 继承Thread类

步骤：

- 自定义线程类继承Thread类。

- 重写run()方法，编写线程执行体。

- 创建线程对象，调用start()方法启动线程。


注意点：是调用start()方法，而不是run()方法。

![在这里插入图片描述](/static/img/images/00229.png)

举例：
```java
class MyThread1 extends Thread{
    private int breakfast=10;
    private String name;
    public MyThread1(String name){
        this.name=name;
    }
    public void run(){
        for(int i =0;i<500;i++){
            if(this.breakfast>0){
                System.out.println(this.name+"卖早餐---->"+(this.breakfast--));
            }
        }
    }
    public static void main(String[] args) {
        MyThread1 mt1= new MyThread1("一号窗口");
        MyThread1 mt2= new MyThread1("二号窗口");
        MyThread1 mt3= new MyThread1("三号窗口");
        mt1.start();
        mt2.start();
        mt3.start();
    }
}
```

# 方法二  实现Runnable接口

步骤：

- 自定义线程类继承实现Runnable接口。

- 实现run()方法，编写线程执行体。

- 创建线程对象，调用start()方法启动线程。

与  继承Thread类 的区别：[参考1](https://blog.csdn.net/zhaojianting/article/details/97664370)

Runnable的实现方式是实现其接口即可；

Thread的实现方式是继承其类；

Runnable接口支持多继承；

Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。

推荐：

Runnable接口支持多继承，较为灵活，单个对象可以被多个线程调用，建议平时使用Runnable接口实现多线程。

```java
class MyThread implements Runnable{
 private int ticket = 5;
 public void run(){
  for (int i=0;i<10;i++)
  {
   if(ticket > 0){
    System.out.println("ticket = " + ticket--);
   }
  }
 }
}
public class RunnableDemo{
 public static void main(String[] args){
  MyThread my = new MyThread();
  new Thread(my).start();
  new Thread(my).start();
  new Thread(my).start();
 }
}
```

# 方法三 实现Callable接口

[参考1](http://www.monkey1024.com/javase/653)

步骤：

1.自定义一个类实现java.util.concurrent包下的Callable接口

2.重写call方法

3.将要在线程中执行的代码编写在call方法中

4.创建FutureTask对象

5.将自定义类的对象传入FutureTask构造方法里面

6.创建Thread线程对象

7.将FutureTask对象传入Thread构造方法中

创建Callable的实现类，其中的泛型Integer是call方法的返回值类型：

```java
import java.util.Random;
import java.util.concurrent.Callable;
/**
 * 多线程实现的第三种方法，实现Callable接口 优点： 可以获取返回值 可以抛出异常
 */
//1.定义一个类实现Callable<V>接口
public class MyCallable implements Callable<Integer> {
    // 2.重写call方法
    @Override
    public Integer call() throws Exception {
        // 3.将要执行的代码写在call方法中
        //返回一个随机数
        Random r = new Random();
        int num = r.nextInt(100);
        return num;
    }
}
```

测试类：

```java
MyCallable mc = new MyCallable();
//这里的泛型要跟MyCallable中的泛型一致
FutureTask<Integer> task = new FutureTask<>(mc);
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);
```

lambda写法：

```java
FutureTask<Integer> task = new FutureTask<>(() -> {
    Random r = new Random();
    int num = r.nextInt(100);
    return num;
});
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);
```

Java 多线程编程 Java实现多线程的三种方式

# 下载安装obs studio





[https://obsproject.com/download](https://obsproject.com/download)

# 打开obs studio

在来源处添加桌面视频源，点击开始录制。

![在这里插入图片描述](/static/img/images/04540.png)

![在这里插入图片描述](/static/img/images/04541.png)

![在这里插入图片描述](/static/img/images/04542.png)

# 录制分辨率设置

![在这里插入图片描述](/static/img/images/04543.png)

基础画布分辨率一定要与桌面分辨率一样，这样能全屏录制。

![在这里插入图片描述](/static/img/images/04544.png)

# mkv转mp4文件

录制后的文件是mkv文件，转为mp4：

![在这里插入图片描述](/static/img/images/04545.png)

![在这里插入图片描述](/static/img/images/04546.png)

【obs studio】教程，如何录制屏幕和声音成为一个视频

[https://jishuin.proginn.com/p/763bfbd2fb27](https://jishuin.proginn.com/p/763bfbd2fb27)





ClickHouse 是一个用于联机分析（OLAP）的列式数据库管理系统（DBMS）。

最近很火的 ClickHouse 是什么？

# 读取具体哪一帧





这个方法可以获取某一帧：

```python
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
```

# 等待按钮

这个方法可以显示当前帧，然后等待你的按钮：

```python
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
```

这个标志打开可以让你存储一个mp4视频：

```
FLAG_SAVE_VIDEOS = False
```

# 写入解码方式与文件格式对应

不同的视频文件格式通常需要使用不同的编解码器，因此你需要根据你要创建的视频文件格式来选择合适的四字符编码标识。以下是一些常见的视频文件格式和相应的四字符编码标识示例：

1. **H.264 编码**（通常用于.mp4文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'H264')
   ```

2. **XVID 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   ```

3. **MJPG 编码**（通常用于.avi文件，适用于每帧图像质量高的场景）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'MJPG')
   ```

4. **DIVX 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'DIVX')
   ```

5. **VP8 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP80')
   ```

6. **VP9 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP90')
   ```

这些是一些常见的视频文件格式和相应的四字符编码标识示例。根据你的需求和所使用的视频文件格式，选择适合的编码标识以确保视频文件可以正确编码和解码。不同的视频编辑软件和播放器也支持不同的编解码器，因此你可能需要根据最终使用情况进行调整。

# 全部代码


```python
import logging
import time
import cv2
import json
# 读取JSON文件
with open('../inoutdir/long.json', 'r') as f:
    json_data = json.load(f)
# 打开视频文件
cap = cv2.VideoCapture('../inoutdir/long.mp4')
current_frame = 0
# 配置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s [Frame %(frame)d / %(frame_all)d] %(message)s')
logger = logging.getLogger()
FLAG_SAVE_VIDEOS = False
if FLAG_SAVE_VIDEOS:
    output_file = '../output/long_draw.mp4'
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    frame_width = int(cap.get(3))
    frame_height = int(cap.get(4))
    out = cv2.VideoWriter(output_file, fourcc, 30, (frame_width, frame_height))
# 初始化时间统计
start_time = time.time()
total_frames = len(json_data)
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
    # 记录时间戳
    frame_timestamp = time.time()
    # 从JSON中获取当前帧的检测结果
    if current_frame < len(json_data):
        detections = json_data[current_frame]['dets']
        # 在每个检测上绘制边界框
        for det in detections:
            x1, y1, x2, y2, score, class_id = det
            color = (0, 255, 0)  # 绿色边界框
            label = f'{int(class_id)},{score:.2f}'
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), color, 2)
            # 计算文本位置以确保在框内
            text_x = int(x1)
            text_y = int(y1) - 10
            if text_y - 10 < 0:
                text_y = int(y1) + 20  # 如果文本位置超出了帧的上边界，则将其放在边界框的下方
            cv2.putText(frame, label, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
    if FLAG_SAVE_VIDEOS:
        out.write(frame)  # 将当前帧写入输出视频
        current_frame += 1
    else:
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
    # 计算每一帧消耗的时间并记录到日志中
    frame_processing_time = time.time() - frame_timestamp
    logger.info(f'Frame processed in {frame_processing_time:.4f} seconds',extra={'frame': current_frame, 'frame_all': total_frames})
# 计算总共消耗的时间
total_processing_time = time.time() - start_time
average_frame_time = total_processing_time / total_frames if total_frames > 0 else 0
print(total_processing_time)
print(average_frame_time)
# 释放视频文件、关闭窗口和输出视频文件
cap.release()
if FLAG_SAVE_VIDEOS:
    out.release()
cv2.destroyAllWindows()
```

【Opencv】Pyhton 播放上一帧，下一帧，存video，逐帧分析

# 亮度判断





比如：

![在这里插入图片描述](/static/img/images/04393.jpeg)

直方图：

![在这里插入图片描述](/static/img/images/04394.png)

代码：

这段代码是一个用于判断图像亮度是否过暗的函数is_dark，并对输入的图像进行可视化直方图展示。

首先，通过import语句导入了cv2和matplotlib.pyplot模块，用于图像处理和可视化。

is_dark函数的作用是判断输入图像的平均亮度是否低于设定的阈值。函数接受两个参数：image_path表示图像文件的路径，threshold表示亮度阈值，默认为100。函数内部的步骤如下：

使用cv2.imread函数读取图像文件，将图像存储在变量img中。

使用cv2.cvtColor函数将图像转换为灰度图像，存储在变量gray中。

使用cv2.mean函数计算灰度图像的平均亮度，存储在变量average_brightness中。

判断average_brightness是否低于设定的阈值threshold，如果是，则返回True表示图像光线过暗；否则返回False表示图像光线正常。

接下来是测试代码部分：

定义了一个图像文件的路径image_path，这里是一个示例路径，请根据实际情况修改。

调用is_dark函数判断图像光线是否过暗，如果返回True，说明图像光线过暗，输出"图片光线过暗"；如果返回False，说明图像光线正常，输出"图片光线正常"。

最后，使用cv2.imread函数再次读取图像文件，将图像存储在变量img中。然后使用plt.hist函数绘制灰度图像的直方图，并通过plt.xlabel和plt.ylabel设置横轴和纵轴的标签。最后使用plt.show显示直方图。这样可以直观地查看图像的亮度分布情况。

```python
import cv2
import matplotlib.pyplot as plt
def is_dark(image_path, threshold=100):
    # 读取图像
    img = cv2.imread(image_path)
    # 转换为灰度图像
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 计算灰度图像的平均亮度
    average_brightness = cv2.mean(gray)[0]
    # 判断亮度是否低于阈值
    if average_brightness < threshold:
        return True
    else:
        return False
# 测试代码
image_path = r'E:\facedata\img_data_new\10001normal_face\10001normal_face_0.5893__041430.jpg'
if is_dark(image_path):
    print("图片光线过暗")
else:
    print("图片光线正常")
# 可视化直方图
img = cv2.imread(image_path)
plt.hist(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).ravel(), bins=256, color='gray')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.show()
```


# 模糊判断

```python
import os
import cv2
from tqdm import tqdm
def is_blurry(image_path):
    image = cv2.imread(image_path)
    if image is None:
        raise Exception("无法读取图片")
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
    return str(round(blur_score * 100)).rjust(10, "0")
def listPathAllfiles(dirname):
    result = []
    for maindir, subdir, file_name_list in os.walk(dirname):
        for filename in file_name_list:
            apath = os.path.join(maindir, filename)
            result.append(apath)
    return result
windowspath = r"E:\facedata\img_data_new"
files = listPathAllfiles(windowspath)
for filename in tqdm(files):
    try:
        num = is_blurry(filename)
    except:
        num = str(round(0 * 100)).rjust(10, "0")
    new_file_name = num + "____" + os.path.basename(filename)
    new_file_name = os.path.join(os.path.dirname(filename), new_file_name)
    os.rename(filename, new_file_name)
```