跳到主要内容

2024/Java字符串和16进制数转换

· 阅读需 2 分钟


import java.io.IOException;

public class HeStrTest {

public static void main(String[] args) throws IOException {
String he = string2Unicode("汉字123abcAb!@slc");
System.out.println(he);
System.out.println("=====16进制========");
he =strTo16(he);
System.out.println(he);


System.out.println("-------------------------");
System.out.println("16转字符串");
he = hexStringToString(he);
System.out.println(he);
System.out.println("unicode转文字11111111111111111");
he =unicode2String(he);
System.out.println(he);
}

public static String hexStringToString(String s) {
if (s == null || s.equals("")) {
return null;
}
s = s.replace(" ", "");
byte[] baKeyword = new byte[s.length() / 2];
for (int i = 0; i < baKeyword.length; i++) {
try {
baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
} catch (Exception e) {
e.printStackTrace();
}
}
try {
s = new String(baKeyword, "UTF-8");

} catch (Exception e1) {
e1.printStackTrace();
}
return s;
}

/**
* 字符串转换unicode
*/
public static String string2Unicode(String string) {
StringBuffer unicode = new StringBuffer();
for (int i = 0; i < string.length(); i++) {
// 取出每一个字符
char c = string.charAt(i);
// 转换为unicode
unicode.append("\\u" + Integer.toHexString(c));
}
return unicode.toString();
}

/**
* unicode 转字符串
*/
public static String unicode2String(String unicode) {
StringBuffer string = new StringBuffer();
String[] hex = unicode.split("\\\\u");
for (int i = 1; i < hex.length; i++) {
// 转换出每一个代码点
int data = Integer.parseInt(hex[i], 16);
// 追加成string
string.append((char) data);
}
return string.toString();
}


/**
* 字符串转化成为16进制字符串
* @param s
* @return
*/
public static String strTo16(String s) {
String str = "";
for (int i = 0; i < s.length(); i++) {
int ch = (int) s.charAt(i);
String s4 = Integer.toHexString(ch);
str = str + s4;
}
return str;
}


}


2024/Java密封类

· 阅读需 1 分钟
  • 定义密封类 SealedParent , 子类A、B、C,同时继承List接口
import java.util.List;

public sealed interface SealedParent extends List permits A, B, C {

void test();
}

密封类子类


public final class A implements SealedParent {

}
~~~




# Java模式匹配


~~~
public static void main(String[] args) {
Object a = 1;
switch (a){
//如果是Integer 匹配Integer
case Integer i-> System.out.println(i);
case String s->{
//字符串匹配
System.out.println("多行");
System.out.println("多行");
}
//支持null
case null-> System.out.println("null");
//默认
default -> System.out.println("default");
}
}

~~~


~~~
int a = 3;
switch (a){
case 1-> System.out.println(1);
case 2->{
System.out.println("多行");
System.out.println("多行");
}
default -> System.out.println("default");
}

~~~

2024/Java读取文件内容的六种方式

· 阅读需 4 分钟





import org.junit.Test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Stream;

public class FileReadTest {


/**
* 第一种方式是Scanner,从JDK1.5开始提供的API,特点是可以按行读取、按分割符去读取文件数据,既可以读取String类型,也可以读取Int类型、Long类型等基础数据类型的数据。
*
* @throws IOException
*/

@Test
public void testReadFile1() throws IOException {
//文件内容:
String fileName = "D:\\1111.txt";

try (Scanner sc = new Scanner(new FileReader(fileName))) {
while (sc.hasNextLine()) { //按行读取字符串
String line = sc.nextLine();
System.out.println(line);
}
}

try (Scanner sc = new Scanner(new FileReader(fileName))) {
sc.useDelimiter("\\|"); //分隔符
while (sc.hasNext()) { //按分隔符读取字符串
String str = sc.next();
System.out.println(str);
}
}

//sc.hasNextInt() 、hasNextFloat() 、基础数据类型等等等等。
//文件内容:1|2
fileName = "D:\\1111.txt";
try (Scanner sc = new Scanner(new FileReader(fileName))) {
sc.useDelimiter("\\|"); //分隔符
while (sc.hasNextInt()) { //按分隔符读取Int
int intValue = sc.nextInt();
System.out.println(intValue);
}
}
}


/**
* 如果你是需要按行去处理数据文件的内容,这种方式是我推荐大家去使用的一种方式,代码简洁,使用java 8的Stream流将文件读取与文件处理有机融合。
*
* @throws IOException
*/
@Test
public void testReadFile2() throws IOException {
String fileName = "D:\\1111.txt";

// 读取文件内容到Stream流中,按行读取
Stream<String> lines = Files.lines(Paths.get(fileName));

// 随机行顺序进行数据处理
lines.forEach(ele -> {
System.out.println(ele);
});
}

/*
forEach获取Stream流中的行数据不能保证顺序,但速度快。如果你想按顺序去处理文件中的行数据,可以使用forEachOrdered,但处理效率会下降。

// 按文件行顺序进行处理
lines.forEachOrdered(System.out::println);
或者利用CPU多和的能力,进行数据的并行处理parallel(),适合比较大的文件。

// 按文件行顺序进行处理
lines.parallel().forEachOrdered(System.out::println);
也可以把Stream<String>转换成List<String>,但是要注意这意味着你要将所有的数据一次性加载到内存,要注意java.lang.OutOfMemoryError

// 转换成List<String>, 要注意java.lang.OutOfMemoryError: Java heap space
List<String> collect = lines.collect(Collectors.toList());

*/


/**
* 这种方法仍然是java8 为我们提供的,如果我们不需要Stream<String>,我们想直接按行读取文件获取到一个List<String>,就采用下面的方法。同样的问题:这意味着你要将所有的数据一次性加载到内存,要注意java.lang.OutOfMemoryError
*
* @throws IOException
*/

@Test
public void testReadFile3() throws IOException {
String fileName = "D:\\1111.txt";

// 转换成List<String>, 要注意java.lang.OutOfMemoryError: Java heap space
List<String> lines = Files.readAllLines(Paths.get(fileName),
StandardCharsets.UTF_8);
lines.forEach(System.out::println);

}


/**
* 从 java11开始,为我们提供了一次性读取一个文件的方法。文件不能超过2G,同时要注意你的服务器及JVM内存。这种方法适合快速读取小文本文件。
*
* @throws IOException
*/

@Test
public void testReadFile4() throws IOException {
String fileName = "D:\\1111.txt";

// java 11 开始提供的方法,读取文件不能超过2G,与你的内存息息相关
String s = Files.readString(Paths.get(fileName));
System.out.println(s);
}


/**
* 如果你没有JDK11(readAllBytes()始于JDK7),仍然想一次性的快速读取一个文件的内容转为String,该怎么办?先将数据读取为二进制数组,然后转换成String内容。这种方法适合在没有JDK11的请开给你下,快速读取小文本文件。
*
* @throws IOException
*/

@Test
public void testReadFile5() throws IOException {
String fileName = "D:\\1111.txt";

//如果是JDK11用上面的方法,如果不是用这个方法也很容易
byte[] bytes = Files.readAllBytes(Paths.get(fileName));

String content = new String(bytes, StandardCharsets.UTF_8);
System.out.println(content);
}


/**
* 最后一种就是经典的管道流的方式
*
* @throws IOException
*/
@Test
public void testReadFile6() throws IOException {
String fileName = "D:\\1111.txt";

// 带缓冲的流读取,默认缓冲区8k
try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}

//java 8中这样写也可以
try (BufferedReader br = Files.newBufferedReader(Paths.get(fileName))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}

}


/*
这种方式可以通过管道流嵌套的方式,组合使用,比较灵活。比如我们
想从文件中读取java Object就可以使用下面的代码,前提是文件中的数据是ObjectOutputStream写入的数据,才可以用ObjectInputStream来读取。

try (FileInputStream fis = new FileInputStream(fileName);
ObjectInputStream ois = new ObjectInputStream(fis)){
ois.readObject();
}

*/

}



2024/Jenkins

· 阅读需 3 分钟

Jenkins 安装启动问题

JVM 设置

查看管理员密码

cat /var/lib/jenkins/secrets/initialAdminPassword

安装Jenkins插件配置

1.找到jenkins安装路径C:\ProgramData\Jenkins.jenkins,

  • 或者 /var/lib/jenkins

然后更改hudson.model.UpdateCenter.xml文件中的url为

https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

2.找到jenkins安装路径,C:\ProgramData\Jenkins.jenkins\updates

/var/lib/jenkins/updates

  • 然后更改default.json文件中的url
`安装好jenkins后,输完页面密码,这时候jenkins需要的文件目录已经生成完毕了.default.json 是下载安装插件时调用的配置文件,其中的下载地址还是updates.jenkins.io,我们需要将其更改为国内的清华源。   default.json的具体路劲是:{jenkins的工作路径}/updates/default.json   使用sed -i命令将其更换   `


å~~~



sed -i 's/http://updates.jenkins-ci.org/download/https://mirrors.tuna.tsinghua.edu.cn/jenkins/g' default.json && sed -i 's/http://www.google.com/https://www.baidu.com/g' default.json


### 二、替换国内插件更新地址

选择:系统管理–>[插件管理](https://so.csdn.net/so/search?q=%E6%8F%92%E4%BB%B6%E7%AE%A1%E7%90%86&spm=1001.2101.3001.7020)–>Advanced settings



修改替换1
https://www.google.com 替换成 https://www.baidu.com
修改替换2
https://updates.jenkins.io/download 替换成

https://mirrors.tuna.tsinghua.edu.cn/jenkins

**hudson.model.UpdateCenter.xml和default.json都必须更换,不然不生效**

然后根据需求安装git,allure等插件


# 修改启动用户
/lib/systemd/system/jenkins.service
vim /usr/lib/systemd/system/jenkins.service

User=root Group=root

systemctl daemon-reload


### log
cd /var/log

chmod 777 -R jenkins/


# 自己设置记录
# 下载插件 Jenkins control

server address http://192.168.3.5:8080/ username 登门名 pwd 登录密码 crumb data http://192.168.3.5:8080//crumbIssuer/api/xml?tree=crumb# jenkins version 选择ver 2.x

# 修改配置文件
/usr/lib/systemd/system
sudo vim jenkins.service
找到下面这行

Arguments for the Jenkins JVM

Environment="JAVA_OPTS=-Djava.awt.headless=true -Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true"


# 重启

sudo systemctl daemon-reload
sudo systemctl restart jenkins


------------


# 博客

参考 https://blog.csdn.net/xundh/article/details/110221975


#



# Jenkins设置
### Jenkins开启CSRF
- 已不适用: 低版本的Jenkins到Jenkins-Configure Global Security,取消”防止跨站点请求伪造“复选框。

如果需要开启此功能,则访问: http://jenkins地址/crumbIssuer/api/xml?tree=crumb# 来获取crumb值,填写到Idea的Jenkins插件设置里。



高版本的Jenkins要到配置文件设置取消CSRF:

vim /etc/sysconfig/jenkins

修改下面的行 JENKINS_JAVA_OPTIONS="-Djava.awt.headless=true -Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true"

对于使用service命令启动的情况来说,要把参数加到下面文件:

cd /usr/lib/systemd/system sudo vim jenkins.service sudo systemctl daemon-reload sudo service jenkins restart

添加用户

· 阅读需 1 分钟

sudo adduser xxx

添加到sudo 组

sudo adduser xxx sudo

  • 另外一种方式
添加sudo权限
sudo vim /etc/sudoer
1
修改前:
# User privilege specification
root ALL=(ALL:ALL) ALL

修改后
# User privilege specification
root ALL=(ALL:ALL) ALL
xxx ALL=(ALL:ALL) ALL



查看是否在用户组

id xxx

校验sudo

sudo ls -l /root

  • 如果主机名不存在
  • 添加主机名 sudo vi /etc/hosts 把报错的主机名加进去,如下
  • 127.0.0.1 xxxx

配置SSH

sudo vim /etc/ssh/sshd_config


修改前:
#LoginGraceTime 2m
#PermitRootLogin prohibit-password
PermitRootLogin yes
#StrictModes yes
#MaxAuthTries 6
#MaxSessions 10

修改后:
#LoginGraceTime 2m
#PermitRootLogin prohibit-password
PermitRootLogin yes
StrictModes yes
#MaxAuthTries 6
#MaxSessions 10


2024/javascript

· 阅读需 1 分钟

let 和 const 命令

var 之前,我们写js定义变量的时候,只有一个关键字: var var 有一个问题,就是定义的变量有时会莫名奇妙的成为全局变量。

例如这样的一段代码: 运行打印的结果是如下: 可以看出,在循环外部也可以获取到变量i的值,显然变量i的作用域范围太大了,在做复杂页面时,会带来很大的问 题。

 let for(var i = 0; i < 5; i++){ console.log(i); } console.log("循环外:" + i) 1 2 3 4 

let 所声明的变量,只在 let 命令所在的代码块内有效。 我们把刚才的 var 改成 let 试试: 结果: 这样,就把变量的i的作用域控制在了循环内部。 const const 声明的变量是常量,不能被修改,类似于java中final关键字。 可以看到,变量a的值是不能修改的。

2024/jvm 参数

· 阅读需 2 分钟

-XX:MetaspaceSize=1536m -XX:MaxMetaspaceSize=1536m

Metaspace 区域位于堆外,所以它的最大内存大小取决于系统内存,而不是堆大小,我们可以指定 MaxMetaspaceSize 参数来限定它的最大内存。

Metaspace 是用来存放 class metadata 的,class metadata 用于记录一个 Java 类在 JVM 中的信息,包括但不限于 JVM class file format 的运行时数据:

1、Class 结构,这个非常重要,把它理解为一个 Java 类在虚拟机内部的表示吧;

2、method metadata,包括方法的字节码、局部变量表、异常表、参数信息等;

3、常量池;

4、注解;

5、方法计数器,记录方法被执行的次数,用来辅助 JIT 决策;

6、 其他

虽然每个 Java 类都关联了一个 java.lang.Class 的实例,而且它是一个贮存在堆中的 Java 对象。但是类的 class metadata 不是一个 Java 对象,它不在堆中,而是在 Metaspace 中。

-Xlog:gc*=debug:file=C:\Users\duan\Desktop\gclogs/gc%t.log:utctime,level,tags:filecount=50,filesize=100M -Xlog:jit+compilation=info:file=C:\Users\duan\Desktop\gclogs/jit_compile%t.log:utctime,level,tags:filecount=10,filesize=10M -Xlog:safepoint=debug:file=C:\Users\duan\Desktop\gclogs/safepoint%t.log:utctime,level,tags:filecount=10,filesize=10M

2024/smart原则

· 阅读需 1 分钟

构建自己的学习树,可以帮助我们系统地输入,系统地输出,自上而下地规划,自下而上地修葺,同时我们还可以随时调用以解决遇到的问题,如图1-6所示。

SMART的具体释意为, Specific——具体的, Measurable——可度量的, Attainable——可实现的, Relevant——(和其他目标)有相关性的, Time-bound——有时限的。

追踪目标是否完成,那就是OKR工作法。OKR(Objectives and Key Results)即目标与关键成果法,是一套明确目标、跟踪目标及其完成情况的管理工具和方法,由英特尔公司创始人之一安迪·葛洛夫(Andy Grove)发明。目标是设定一个确定的时间段内要达成的任务(

学习方式主要分为视、听、说、想、写、画。为了保证学习效率,我们需要采用多种感官联合学习的方式,即同时刺激多个感官,这样记忆会比较深刻。

2024/弱引用

· 阅读需 1 分钟
 WeakReference<String> weakCar = new WeakReference<String>("abc");
log.error(weakCar.get());