Java常用的API_02（正则表达式、爬虫）

Java正则表达式

  • 七、正则表达式
    • 7.1 格式
      • 7.1.1 字符类
        • 注意
        • 字符类示例代码1
        • 例2
      • 7.1.2 预定义字符
        • 预定义字符示例代码
        • 例2
      • 7.1.3 区别总结
    • 7.2 使用`Pattern`和`Matcher`类与直接使用`String`类的`matches`方法的区别。
      • （1） 使用`Pattern`和`Matcher`类
        • 示例代码
      • （2）直接使用`String`类的`matches`方法
        • 示例代码
      • （3）区别总结
      • （4）示例对比
          • 使用`Pattern`和`Matcher`类
        • 直接使用`String`类的`matches`方法
    • 7.3 数量词
    • 7.4这是一个正则表达式符号的总结表。
      • 7.4.1 各个符号
        • 解释
      • 7.4.2 量词总结表。
        • 解释
  • 八、爬虫
    • 8.1 条件爬取
      • 8.1.1 正向预查
      • 8.1.2 其他的
    • 8.2贪婪爬取
    • 8.3 正则表达式中的方法
    • 8.4 分组
      • 8.4.1 首尾相同单字符 abc123cba
      • 8.4.2 首尾相同多字符abc123abc
      • 8.4.3 开始的样式和结束的样式一样aaa12aaa

七、正则表达式

正则表达式是一种强大的文本匹配工具，用于在字符串中搜索和匹配特定模式的文本。
在Java中，正则表达式由java.util.regex包提供支持。它可以用于验证输入的格式、提取文本中的特定部分、替换文本等操作。

7.1 格式

7.1.1 字符类

字符类用于匹配一组字符中的任意一个字符。字符类用方括号[]括起来，表示在这些字符中匹配一个字符。

  • [abc]：匹配字符a、b或c。
  • [^abc]：匹配除a、b、c之外的任何字符。
  • [a-zA-Z]：匹配从a到z或从A到Z的任意一个字符。
  • [a-d[m-p]]：匹配a到d或m到p的任意一个字符。
  • [a-z&&[def]]：匹配a到z和def的交集，即d、e、f。
  • [a-z&&[^bc]]：匹配a到z并且不包括b和c的字符(即[ad-z])。
  • [a-z&&[^m-p]]：匹配a到z并且不包括m到p的字符（即[a-lq-z]）。
注意
  • [a-z&&[def]]：匹配a到z和def的交集，即d、e、f。
  • 像这样的&&，必须是两个，如果是一个&，就只是说明其是一个‘&’字符符号
字符类示例代码1
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class CharClassExample {public static void main(String[] args) {// 匹配a、b或c中的任意一个字符String regex1 = "[abc]";String input1 = "apple";System.out.println(matchesPattern(regex1, input1)); // true// 匹配除a、b、c之外的任何字符String regex2 = "[^abc]";String input2 = "def";System.out.println(matchesPattern(regex2, input2)); // true// 匹配从a到z或从A到Z的任意一个字符String regex3 = "[a-zA-Z]";String input3 = "Hello";System.out.println(matchesPattern(regex3, input3)); // true// 匹配a到d或m到p的任意一个字符String regex4 = "[a-d[m-p]]";String input4 = "cat";System.out.println(matchesPattern(regex4, input4)); // true// 匹配a到z和def的交集，即d、e、fString regex5 = "[a-z&&[def]]";String input5 = "dog";System.out.println(matchesPattern(regex5, input5)); // true// 匹配a到z并且不包括b和c的字符String regex6 = "[a-z&&[^bc]]";String input6 = "apple";System.out.println(matchesPattern(regex6, input6)); // true// 匹配a到z并且不包括m到p的字符String regex7 = "[a-z&&[^m-p]]";String input7 = "hello";System.out.println(matchesPattern(regex7, input7)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);return matcher.find();}
}
例2
public class CharClassExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println("----------1----------");System.out.println("a".matches("[abc]")); // trueSystem.out.println("k".matches("[abc]")); // false// 不能出现 a b cSystem.out.println("----------2----------");System.out.println("a".matches("[^abc]")); // falseSystem.out.println("z".matches("[^abc]")); // trueSystem.out.println("zz".matches("[^abc]")); // falseSystem.out.println("zz".matches("[^abc][^abc]")); // true// a到z A到Z (包括头尾的范围)System.out.println("----------3----------");System.out.println("a".matches("[a-zA-Z]")); // trueSystem.out.println("Z".matches("[a-zA-Z]")); // trueSystem.out.println("aa".matches("[a-zA-Z]")); // falseSystem.out.println("zz".matches("[a-zA-Z]")); // falseSystem.out.println("0".matches("[a-zA-Z]")); // false}
}

7.1.2 预定义字符

匹配一组字符中的任意一个字符，其用于简化正则表达式的书写。

  • .：匹配任意字符。
  • \d：匹配一个数字字符，相当于[0-9]。
  • \D：匹配一个非数字字符，相当于[^0-9]。
  • \s：匹配一个空白字符，包括空格、制表符、换行符等，相当于[\t\n\x0B\f\r]。
  • \S：匹配一个非空白字符，相当于[^\s]。
  • \w：匹配一个单词字符，包括字母、数字和下划线，相当于[a-zA-Z_0-9]。
  • \W：匹配一个非单词字符，相当于[^\w]。

通过使用这些字符类和预定义字符，可以构建出复杂的正则表达式来匹配特定的文本模式。

预定义字符示例代码
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PredefinedCharExample {public static void main(String[] args) {// 匹配任意字符String regex1 = ".";String input1 = "a";System.out.println(matchesPattern(regex1, input1)); // true// 匹配一个数字字符String regex2 = "\\d";String input2 = "5";System.out.println(matchesPattern(regex2, input2)); // true// 匹配一个非数字字符String regex3 = "\\D";String input3 = "a";System.out.println(matchesPattern(regex3, input3)); // true// 匹配一个空白字符String regex4 = "\\s";String input4 = " ";System.out.println(matchesPattern(regex4, input4)); // true// 匹配一个非空白字符String regex5 = "\\S";String input5 = "a";System.out.println(matchesPattern(regex5, input5)); // true// 匹配一个单词字符String regex6 = "\\w";String input6 = "a";System.out.println(matchesPattern(regex6, input6)); // true// 匹配一个非单词字符String regex7 = "\\W";String input7 = "!";System.out.println(matchesPattern(regex7, input7)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);return matcher.find();}
}
例2
public class PredefinedCharExample {public static void main(String[] args) {// 匹配任意字符System.out.println("----------1----------");System.out.println("a".matches(".")); // trueSystem.out.println("1".matches(".")); // trueSystem.out.println(" ".matches(".")); // trueSystem.out.println("\n".matches(".")); // false// 匹配一个数字字符System.out.println("----------2----------");System.out.println("5".matches("\\d")); // trueSystem.out.println("a".matches("\\d")); // false// 匹配一个非数字字符System.out.println("----------3----------");System.out.println("a".matches("\\D")); // trueSystem.out.println("5".matches("\\D")); // false// 匹配一个空白字符System.out.println("----------4----------");System.out.println(" ".matches("\\s")); // trueSystem.out.println("\t".matches("\\s")); // trueSystem.out.println("a".matches("\\s")); // false// 匹配一个非空白字符System.out.println("----------5----------");System.out.println("a".matches("\\S")); // trueSystem.out.println(" ".matches("\\S")); // false// 匹配一个单词字符System.out.println("----------6----------");System.out.println("a".matches("\\w")); // trueSystem.out.println("1".matches("\\w")); // trueSystem.out.println("_".matches("\\w")); // trueSystem.out.println("!".matches("\\w")); // false// 匹配一个非单词字符System.out.println("----------7----------");System.out.println("!".matches("\\W")); // trueSystem.out.println("a".matches("\\W")); // false}
}

在Java中，使用正则表达式进行字符串匹配时，字符类和预定义字符的写法有一些区别。以下是两种写法的主要区别：

7.1.3 区别总结

  1. 字符类：

    • 使用方括号[]定义。
    • 可以包含单个字符、字符范围或字符集的交集和补集。
    • 适用于需要匹配特定字符集合的情况。

  2. 预定义字符：

    • 使用反斜杠\加特定字符定义。
    • 是常用字符类的简写形式。
    • 适用于匹配常见字符类型（如数字、字母、空白字符等）的情况。

7.2 使用Pattern和Matcher类与直接使用String类的matches方法的区别。

（1） 使用Pattern和Matcher类

这种方法适用于需要多次复用同一个正则表达式的情况。通过编译正则表达式为Pattern对象，然后使用Matcher对象进行匹配，可以提高效率。

示例代码
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PatternMatcherExample {public static void main(String[] args) {String regex1 = "[abc]";String input1 = "apple";System.out.println(matchesPattern(regex1, input1)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);return matcher.find();}
}

（2）直接使用String类的matches方法

这种方法适用于简单的、一次性的正则表达式匹配。String类的matches方法会在内部编译正则表达式并进行匹配，适合于不需要复用正则表达式的情况。

示例代码
public class StringMatchesExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println("----------1----------");System.out.println("a".matches("[abc]")); // trueSystem.out.println("k".matches("[abc]")); // false}
}

（3）区别总结

  1. 使用Pattern和Matcher类：

    • 适用于需要多次复用同一个正则表达式的情况。
    • 通过编译正则表达式为Pattern对象，然后使用Matcher对象进行匹配。
    • 提高了效率，特别是在需要多次匹配的情况下。

  2. 直接使用String类的matches方法：

    • 适用于简单的、一次性的正则表达式匹配。
    • 每次调用matches方法时，都会编译正则表达式并进行匹配。
    • 适合于不需要复用正则表达式的情况。

（4）示例对比

使用Pattern和Matcher类
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class PatternMatcherExample {public static void main(String[] args) {String regex1 = "[abc]";String input1 = "apple";System.out.println(matchesPattern(regex1, input1)); // true}private static boolean matchesPattern(String regex, String input) {Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);return matcher.find();}
}
直接使用String类的matches方法
public class StringMatchesExample {public static void main(String[] args) {// 只能是 a b cSystem.out.println("----------1----------");System.out.println("a".matches("[abc]")); // trueSystem.out.println("k".matches("[abc]")); // false}
}

7.3 数量词

  • X?：X，一次或0次
  • X*：X，零次或多次
  • X+：X，一次或多次
  • X{n}：X，正好n次
  • X{n,}：X，至少n次
  • X{n,m}：X，至少n但不超过m次

这些量词用于正则表达式中来指定字符或子模式的重复次数。

public class RegexExample {public static void main(String[] args) {// 示例1: X?System.out.println("aaab".matches("a?")); // falseSystem.out.println("a".matches("a?"));    // trueSystem.out.println("".matches("a?"));     // true// 示例2: X*System.out.println("aaab".matches("a*")); // falseSystem.out.println("aaa".matches("a*"));  // trueSystem.out.println("".matches("a*"));     // true// 示例3: X+System.out.println("aaab".matches("a+")); // falseSystem.out.println("aaa".matches("a+"));  // trueSystem.out.println("a".matches("a+"));    // true// 示例4: X{n}System.out.println("aaab".matches("a{2}")); // falseSystem.out.println("aa".matches("a{2}"));   // true// 示例5: X{n,}System.out.println("aaab".matches("a{2,}")); // falseSystem.out.println("aaa".matches("a{2,}"));  // true// 示例6: X{n,m}System.out.println("aaab".matches("a{1,2}")); // falseSystem.out.println("aa".matches("a{1,2}"));   // trueSystem.out.println("a".matches("a{1,2}"));    // true}
}

在这里插入图片描述

  • (?i)：这是一个正则表达式的模式修饰符，用于忽略大小写。
public class RegexExample {public static void main(String[] args) {// 忽略大小写的书写方式// 在匹配的时候忽略abc的大小写String regex = "a(?i)bc";System.out.println("----------------------------");System.out.println("abc".matches(regex)); // trueSystem.out.println("ABC".matches(regex)); // trueSystem.out.println("aBC".matches(regex)); // true}
}

同样的忽略
（X|x）与 [Xx]

注意（）的使用
（）立大功

public class RegexExample {public static void main(String[] args) {// 忽略大小写的书写方式// 在匹配的时候忽略b的大小写String regex = "a((?i)b)c";System.out.println("----------------------------");System.out.println("abc".matches(regex)); // trueSystem.out.println("ABC".matches(regex)); // falseSystem.out.println("aBc".matches(regex)); // true}
}

7.4这是一个正则表达式符号的总结表。

7.4.1 各个符号

符号含义示例
[]里面的内容出现一次[0-9] [a-zA-Z0-9]
()分组a(bc)+
^取反[^abc]
&&交集，不能写单个的&[a-z&&m-p]
``写在方括号外面表示并集
.任意字符\n 回车符号不匹配
\转义字符\\d
\d0-9\\d+
\D非0-9\\D+
\s空白字符[ \t\n\x0B\f\r]
\S非空白字符[^\\s]
\w单词字符[a-zA-Z_0-9]
\W非单词字符[^\\w]
解释
  • []：匹配方括号内的任意一个字符。例如，[0-9]匹配任何一个数字。
  • ()：用于分组。例如，a(bc)+匹配a后面跟一个或多个bc。
  • ^：在方括号内表示取反。例如，[^abc]匹配任何不是a、b或c的字符。
  • &&：表示交集。例如，[a-z&&m-p]匹配m到p之间的字符。
  • |：表示并集。例如，x|X匹配x或X。
  • .：匹配任意字符（除了换行符）。
  • \：转义字符，用于转义特殊字符。
  • \d：匹配任何一个数字（0-9）。
  • \D：匹配任何一个非数字字符。
  • \s：匹配任何一个空白字符（包括空格、制表符、换行符等）。
  • \S：匹配任何一个非空白字符。
  • \w：匹配任何一个单词字符（包括字母、数字和下划线）。
  • \W：匹配任何一个非单词字符。

这些符号和示例可以帮助你更好地理解和使用正则表达式。

7.4.2 量词总结表。

符号含义示例
?0次或1次\\d?
*0次或多次\\d* (abc)*
+1次或多次\\d+ (abc)+
{}具体次数a{7} \\d{7,19}
(?i)忽略后面字符的大小写(?i)abc
a((?i)b)c只忽略b的大小写a((?i)b)c
解释
  • ?：匹配前面的字符0次或1次。例如，\\d?匹配0个或1个数字。
  • *：匹配前面的字符0次或多次。例如，\\d*匹配0个或多个数字，(abc)*匹配0个或多个abc。
  • +：匹配前面的字符1次或多次。例如，\\d+匹配1个或多个数字，(abc)+匹配1个或多个abc。
  • {}：匹配前面的字符具体的次数。例如，a{7}匹配7个a，\\d{7,19}匹配7到19个数字。
  • (?i)：忽略后面字符的大小写。例如，(?i)abc匹配abc、ABC、aBc等。
  • a((?i)b)c：只忽略b的大小写。例如，a((?i)b)c匹配abc、aBc，但不匹配ABC。

八、爬虫

8.1 条件爬取

8.1.1 正向预查

要匹配的内容后面加上一个正向预查，指定后面的数据需要存在但不包含在匹配结果中。

String text = "前面的数据后面的数据";
String pattern = "前面的数据(?=后面的数据)";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);if (m.find()) {System.out.println(m.group());
}

在这里插入图片描述

在这个示例中，正则表达式(?=后面的数据)表示匹配"前面的数据"后面紧跟着"后面的数据"，但只返回"前面的数据"部分。

8.1.2 其他的

String text = "前面的数据后面的数据";
String pattern = "前面的数据(?:后面的数据)";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);if (m.find()) {System.out.println(m.group());
}

在这里插入图片描述
非捕获分组不需要再用本组数据，仅仅把数据括起来，不占组号。
（?:）(?=)（？！）

符号含义
?:正则获取所有
?=正则获取前面
?! 正则 获取不是指定内容的前面的部分

8.2贪婪爬取

只写+或者·*·就是贪婪爬取
+？非贪婪爬取
*？非贪婪爬取
在这里插入图片描述

以下是使用贪婪匹配和非贪婪匹配的正则表达式示例：

  1. 使用贪婪匹配+：
String text = "aaaaaab";
String pattern = "a+";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);while (m.find()) {System.out.println("贪婪匹配结果：" + m.group());
}
  1. 使用非贪婪匹配+?：
String text = "aaaaaab";
String pattern = "a+?";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);while (m.find()) {System.out.println("非贪婪匹配结果：" + m.group());
}
  1. 使用贪婪匹配*：
String text = "aaaaaab";
String pattern = "a*";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);while (m.find()) {System.out.println("贪婪匹配结果：" + m.group());
}
  1. 使用非贪婪匹配*?：
String text = "aaaaaab";
String pattern = "a*?";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);while (m.find()) {System.out.println("非贪婪匹配结果：" + m.group());
}

这些示例演示了贪婪匹配和非贪婪匹配在正则表达式中的应用。

8.3 正则表达式中的方法

在Java中，正则表达式的常用方法包括matches、replaceAll和split。下面是它们的简要介绍：

  • matches：用于检查整个字符串是否匹配正则表达式。返回一个布尔值，表示是否完全匹配。
String text = "Hello, World!";
boolean isMatch = text.matches("Hello.*");
System.out.println(isMatch); // true
  • replaceAll：用于替换字符串中匹配正则表达式的部分。可以用指定的字符串替换匹配的部分。
String text = "apple, orange, banana";
String replacedText = text.replaceAll("\\b\\w+\\b", "fruit");
System.out.println(replacedText); // fruit, fruit, fruit
  • split：根据正则表达式将字符串拆分为子字符串数组。返回一个字符串数组，包含根据正则表达式拆分的子字符串。
String text = "apple,orange,banana";
String[] fruits = text.split("a");
for (String fruit : fruits) {System.out.println(fruit);
}
//pple,or
//nge,b
//n
//n

这些方法可以帮助你在Java中使用正则表达式进行匹配、替换和拆分字符串。

8.4 分组

在Java中，可以使用圆括号()来创建一个分组。

在正则表达式中，分组可以对匹配的部分进行逻辑分组，以便后续引用或操作。
组号是连续的，从1开始不间断的。以左括号为基准。
非捕获分组不需要再用本组数据，仅仅把数据括起来，不占组号。

（?:）(?=)（？！）
在这里插入图片描述

public class SimplifyString {public static void main(String[] args) {// 定义原始字符串String s = "aabbbbbbcccc";// 使用正则表达式替换重复的字符// (.) 捕获组匹配任意字符// \\1+ 量词匹配捕获组1的一次或多次出现// $1 引用捕获组1的内容（即匹配的单个字符）进行替换String simplified = s.replaceAll("(.)\\1+", "$1");// 输出简化后的字符串System.out.println(simplified);  // 输出: abc}
}

8.4.1 首尾相同单字符 abc123cba

\\组号意味着吧X组的东西在拿来用一次

String regex1="(.).+\\1";

在这里插入图片描述

8.4.2 首尾相同多字符abc123abc

String regex1="(.+).+\\1";

在这里插入图片描述

8.4.3 开始的样式和结束的样式一样aaa12aaa

(.)是把字母看做一组
\\2是把首字母重复
*是把\\2, ——— 0次或者多次

String regex1="((.)\\2*).+\\1";

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/871046.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

分布式系统—Ceph块存储系统（RBD接口）

分布式系统—Ceph块存储系统（RBD接口）

目录 一、服务端操作 1 创建一个名为 rbd-xy101 的专门用于 RBD 的存储池 2 将存储池转换为 RBD 模式 3 初始化存储池 4 创建镜像 5 管理镜像 6.Linux客户端使用 在管理节点创建并授权一个用户可访问指定的 RBD 存储池 ​编辑修改RBD镜像特性，CentOS7默认情…
阅读更多...
Matlab结合ChatGPT—如何计算置信区间？

Matlab结合ChatGPT—如何计算置信区间？

​前面分享了带置信区间的折线图和带置信区间的折线散点图的绘图教程： 很多人表示，昆哥，图是很好看啦，但咱不会求置信区间啊，咋办嘞？ 说实话，这种事情属于数据处理，一般都是在画图前…
阅读更多...
家政服务小程序：提高家政服务，新商机！

家政服务小程序：提高家政服务，新商机！

当下，社会生活的节奏非常快，人们忙于工作，在日常生活家务清洁中面临着时间、精力不足的问题，因此对家政服务的需求日益增加，这也推动了家政行业的迅速发展。目前不少年轻人都开始涌入到了家政行业中，市场的…
阅读更多...
HTTP协议。（HTTP-概述和特点、HTTP-请求协议、HTTP-请求数据格式、浏览器访问服务器的几种方式）

HTTP协议。（HTTP-概述和特点、HTTP-请求协议、HTTP-请求数据格式、浏览器访问服务器的几种方式）

2.1 HTTP-概述 HTTP协议又分为：请求协议和响应协议 请求协议：浏览器将数据以请求格式发送到服务器 包括：请求行、请求头 、请求体 响应协议：服务器将数据以响应格式返回给浏览器 包括：响应行 、响应头 、响应体 2.…
阅读更多...
重要！！！MySQL 9.0存在重大BUG！！

重要！！！MySQL 9.0存在重大BUG！！

7/11日开源数据库软件服务商percona发布重要警告，最新的mysql版本存在重大bug，原文如下 Do Not Upgrade to Any Version of MySQL After 8.0.37 Warning! Recently, Jean-Franois Gagn opened a bug on bug.mysql.com #115517; unfortunately, the bug…
阅读更多...
CT金属伪影去除的去噪扩散概率模型| 文献速递-基于深度学习的多模态数据分析与生存分析

CT金属伪影去除的去噪扩散概率模型| 文献速递-基于深度学习的多模态数据分析与生存分析

Title 题目 A denoising diffusion probabilistic model for metal artifact reduction in CT CT金属伪影去除的去噪扩散概率模型 01 文献速递介绍 CT图像中的金属伪影是在CT扫描视野内存在金属物体（如牙科填充物、骨科假体、支架、手术器械等）时出…
阅读更多...
探索Java网络编程精髓：UDP与TCP的实战魔法！

探索Java网络编程精髓：UDP与TCP的实战魔法！

Java 中提供了专门的网络编程程序包 java.net，提供了两种通信协议：UDP（数据报协议）和 TCP（传输控制协议），本文对两种通信协议的开发进行详细介绍。 1 UDP 介绍 UDP：User Datagram Pr…
阅读更多...
css横向滚动条支持鼠标滚轮

css横向滚动条支持鼠标滚轮

在做视频会议的时候&#xff0c;标准模式视图会有顶部收缩的一种交互方式&#xff0c;用到了横向滚动&#xff1b;一般情况下鼠标滚轮只支持竖向滚动&#xff0c;这次写个demo是适配横向滚动&#xff1b; 效果图展示 实现横向滚动条顶部显示 <div className{style.remote_u…
阅读更多...
【YOLO格式的数据标签，目标检测】

【YOLO格式的数据标签，目标检测】

标签为 YOLO 格式&#xff0c;每幅图像一个 *.txt 文件&#xff08;如果图像中没有对象&#xff0c;则不需要 *.txt 文件&#xff09;。*.txt 文件规格如下: 每个对象一行 每一行都是 class x_center y_center width height 格式。 边框坐标必须是 归一化的 xywh 格式&#x…
阅读更多...
nginx正向代理和反向代理

nginx正向代理和反向代理

nginx正向代理和反向代理 正向代理以及缓存配置 代理&#xff1a;客户端不再是直接访问服务器&#xff0c;通过代理服务器访问服务端。 正向代理&#xff1a;面向客户端&#xff0c;我们通过代理服务器的IP地址访问目标服务端。 服务端只知道代理服务器的地址&#xff0c;真…
阅读更多...
每日一练 - OSPF邻居关系建立故障排查

每日一练 - OSPF邻居关系建立故障排查

01 真题题目 OSPF邻居关系建立出现故障&#xff0c;通过display ospf error命令查看&#xff0c;显示如下信息&#xff0c;则邻居建立失败的原因可能是&#xff1a; A. Router ID冲突 B.区域ID不匹配 C.网络掩码不一致 D.MTU不一致 02 真题答案 B 03 答案解析 从图片中可以…
阅读更多...
数据丢失？不存在的！

数据丢失？不存在的！

今年3月份&#xff0c;AT&T遭遇了严重的数据泄露事件&#xff0c;导致7300万客户账户信息被泄露。泄露的信息包括客户的姓名、电话号码、邮寄地址等敏感资料&#xff0c;甚至部分客户的加密密码也被泄露&#xff0c;使得约760万AT&T用户的账户面临被劫持的风险。 此次…
阅读更多...
博客文章多平台发布工具

博客文章多平台发布工具

做过博客分享和自媒体的同学应该都知道&#xff0c;在多个平台上同步发布、更新自己的原创内容&#xff0c;是快速传播知识、提高用户触达率的有效方式。 然而&#xff0c;一篇文章要在N个平台上重复进行编辑、排版、图片/视频上传的苦恼&#xff0c;你一定经历过吧&#xff1…
阅读更多...
从汇编层看64位程序运行——静态分析和动态分析入门

从汇编层看64位程序运行——静态分析和动态分析入门

大纲 GDBIDA总结参考资料 之前一直谈各种相对宏观的工具怎么使用&#xff0c;比如Flink、RabbitMQ等。最近想聊聊比较微观的技术&#xff0c;用各种“显微镜”去看看运行在系统层的二进制码是什么样子。当然二进制码比较难以记忆&#xff0c;于是我会从二进制码的助记符——汇编…
阅读更多...
408数据结构-图的应用2-最短路径 自学知识点整理

408数据结构-图的应用2-最短路径 自学知识点整理

前置知识&#xff1a;最小生成树&#xff0c;图的遍历 最短路径 当图是带权图时&#xff0c;把从一个顶点 v 0 v_0 v0​到图中其余任意一个顶点 v i v_i vi​的一条路径所经过边上的权值之和&#xff0c;定位为该路径的带权路径长度&#xff0c;把带权路径长度最短的那条路径&…
阅读更多...
centOS79中安装redis7.0

centOS79中安装redis7.0

##red## &#x1f534; 大家好&#xff0c;我是雄雄&#xff0c;欢迎关注微信公众号&#xff0c;雄雄的小课堂。 一、前言 新服务器&#xff0c;一些环境是少不了要安装的&#xff0c;比如常见的redis&#xff0c;mysql&#xff0c;nginx等&#xff0c;今天&#xff0c;上次&a…
阅读更多...
【Golang】map的使用

【Golang】map的使用

map声明的方式 //声明var m map[string]string//在使用map之前&#xff0c;先make&#xff0c;make的作用就是给map分配空间m make(map[string]string)m["lover"] "Yzx"m["friend1"] "Zxw"m["friend2"] "Zzc"…
阅读更多...
C语言-gcc编译四步

C语言-gcc编译四步

gcc -E hello.c -o hello.i 预处理 gcc -S hello.i -o hello.s 编译 gcc -c hello.s -o hello.o 汇编 gcc hello.o -o hello.exe 链接
阅读更多...
springboot增加过滤器后中文乱码

springboot增加过滤器后中文乱码

记录一下小问题 public class RepeatableHttpServletWrapper extends HttpServletRequestWrapper {private byte[] body;public RepeatableHttpServletWrapper(HttpServletRequest request) throws IOException {super(request);request.setCharacterEncoding("UTF-8&q…
阅读更多...
泛微E-Cology WorkflowServiceXml SQL注入漏洞复现

泛微E-Cology WorkflowServiceXml SQL注入漏洞复现

0x01 产品简介 泛微e-cology是一款由泛微网络科技开发的协同管理平台，支持人力资源、财务、行政等多功能管理和移动办公。 0x02 漏洞概述 2024年7月，泛微官方发布了新补丁，修复了一处SQL注入漏洞。经分析，攻击者无需认证即可利用该漏洞，建议受影响的客户尽快修复漏洞。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023