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.rhkb.cn/news/375755.html

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

相关文章

传输层协议之UDP

传输层协议之UDP

1、端口号 我们在应用层创建的套接字，是需要通过bind()接口绑定我们的IP地址与端口号的，这是因为数据从传输层向上交付到应用层时，需要用端口号来查找特定的服务进程。一般在网络通信时，用IP地址标识一台主机，用端口号…
阅读更多...
el-table 动态添加删除 -- 鼠标移入移出显隐删除图标

el-table 动态添加删除 -- 鼠标移入移出显隐删除图标

<el-table class"list-box" :data"replaceDataList" border><el-table-column label"原始值" prop"original" align"center" ><template slot-scope"scope"><div mouseenter"showClick…
阅读更多...
Kubelet 认证

Kubelet 认证

当我们执行kubectl exec -it pod [podName] sh命令时&#xff0c;apiserver会向kubelet发起API请求。也就是说&#xff0c;kubelet会提供HTTP服务&#xff0c;而为了安全&#xff0c;kubelet必须提供HTTPS服务&#xff0c;且还要提供一定的认证与授权机制&#xff0c;防止任何知…
阅读更多...
Bertopic环境安装与文本主题聚类

Bertopic环境安装与文本主题聚类

文章目录 1.环境配置（一）安装：anaconda1. 理解：为什么需要anaconda2. 下载anaconda3. 启动anaconda（二）安装：python环境（三）安装：依赖包hdbscan的安装问题解决方案1. 安装build-tools-for-visual-studio2. 安装hdbscan（四）安装transformers、BERTopic等重要依赖包2…
阅读更多...
FlinkModule加载HiveModule异常

FlinkModule加载HiveModule异常

HiveModule这个模块加载不出来 加在不出来这个模块&#xff0c;网上查说是要加下面这个依赖 <dependency><groupId>org.apache.flink</groupId><artifactId>flink-connector-hive_${scala.binary.version}</artifactId><version>${flink.…
阅读更多...
GPIO通用输入输出口

GPIO通用输入输出口

可配置八种输入输出模式&#xff1b; 引脚电平&#xff1a;0~3.3V&#xff0c;部分引脚可容忍5V&#xff1b;&#xff08;可以输入5V&#xff0c;输出最大只能是3.3V&#xff09; 带FT的是可以容忍5V的不带FT的就只能接入3.3V的电压。 输出模式下可以控制端口输出高低电平&am…
阅读更多...
【算法】代码随想录之链表（更新中）

【算法】代码随想录之链表（更新中）

文章目录 前言 一、移除链表元素&#xff08;LeetCode--203&#xff09; 前言 跟随代码随想录&#xff0c;学习链表相关的算法题目&#xff0c;记录学习过程中的tips。 一、移除链表元素&#xff08;LeetCode--203&#xff09; 【1】题目描述&#xff1a; 【2】解决思想&am…
阅读更多...
自动驾驶中，实现三维点旋转原理

自动驾驶中，实现三维点旋转原理

文章目录 1. 三维点旋转的方案2. 使用复数表示二维点的旋转2.1. 复数的概念2.2. 复数的三种形式及相互转换2.3. 复数概念扩展&#xff1a;实数、虚数、复数 3. 四元数旋转三维点原理4. 使用四元数进行旋转的公式5. 旋转叠加6. 四元数转换为三维点7. 代码实现 1. 三维点旋转的方…
阅读更多...
13 协程设计原理与汇编实现

13 协程设计原理与汇编实现

协程的问题 为什么要有协程?协程的原语操作?协程的切换?协程的struct如何定义?协程的scheduler(调度)如何定义?调度策略如何实现?协程如何与posix,api兼容?协程多核模式?协程的性能如何测试?为什么要有协程 同步的编程方式，异步的性能。同步编程时，我们需要等待io就…
阅读更多...
14-47 剑和诗人21 - 2024年如何打造AI创业公司

14-47 剑和诗人21 - 2024年如何打造AI创业公司

​​​​​ 2024 年&#xff0c;随着人工智能继续快速发展并融入几乎所有行业&#xff0c;创建一家人工智能初创公司将带来巨大的机遇。然而&#xff0c;在吸引资金、招聘人才、开发专有技术以及将产品推向市场方面&#xff0c;人工智能初创公司也面临着相当大的挑战。 让我来…
阅读更多...
ant design form动态增减表单项Form.List如何进行动态校验规则

ant design form动态增减表单项Form.List如何进行动态校验规则

项目需求&#xff1a; 在使用ant design form动态增减表单项Form.List时&#xff0c;Form.List中有多组表单项&#xff0c;一组中的最后一个表单项的校验规则是动态的&#xff0c;该组为最后一组时&#xff0c;最后一个表单项是非必填项&#xff0c;其他时候为必填项。假设动态…
阅读更多...
SQL，python，knime将数据混合的文字数字拆出来，合并计算实战

SQL，python，knime将数据混合的文字数字拆出来，合并计算实战

将下面将数据混合的文字数字拆出来&#xff0c;合并计算 一、SQL解决&#xff1a; ---创建表插入数据 CREATE TABLE original_data (id INT AUTO_INCREMENT PRIMARY KEY,city VARCHAR(255),value DECIMAL(10, 2) );INSERT INTO original_data (city, value) VALUES (上海0.5…
阅读更多...
对照ui图进行大屏幕适配，echerts适配

对照ui图进行大屏幕适配，echerts适配

1.先找到ui图&#xff0c;我这边是1920*1080的屏幕进行的设计 2.在界面找到跟样式的字体大小&#xff0c;进行设置&#xff0c;一般ui设置字体大小便可 3.在js中写入原生js代码 function adapter() {//获取布局视口宽度&#xff0c;布局视口设备横向独立像素值const dpWidth…
阅读更多...
Stable Diffusion 深度探索：从入门到精通的全方位教程

Stable Diffusion 深度探索：从入门到精通的全方位教程

在人工智能艺术创作的浪潮中&#xff0c;Stable Diffusion 作为一股不可忽视的力量&#xff0c;正以其独特的魅力吸引着无数创作者和科技爱好者的目光。本文旨在为大家提供一份详尽的 Stable Diffusion 教程&#xff0c;从基础概念到高级应用&#xff0c;带领你一步步走进这个充…
阅读更多...
paddla模型转gguf

paddla模型转gguf

在使用ollama配置本地模型时&#xff0c;只支持gguf格式的模型&#xff0c;所以我们首先需要把自己的模型转化为bin格式&#xff0c;本文为paddle&#xff0c;onnx&#xff0c;pytorch格式的模型提供说明&#xff0c;safetensors格式比较简单请参考官方文档&#xff0c;或其它教…
阅读更多...
【eNSP模拟实验】单臂路由实现VLAN间通信

【eNSP模拟实验】单臂路由实现VLAN间通信

实验需求 如下图所示&#xff0c;辅导员办公室需要访问处在不同vlan的学生管理服务器的文件&#xff0c;那么如何实现两台终端相互通信呢&#xff1f;我们可以使用单臂路由的方式来实现。 单臂路由&#xff08;router-on-a-stick&#xff09;是指在路由器的一个接口上通过配置…
阅读更多...
数据结构：链表详解 (c++实现)

数据结构：链表详解 (c++实现)

前言 对于数据结构的线性表&#xff0c;其元素在逻辑结构上都是序列关系&#xff0c;即数据元素之间有前驱和后继关系。 但在物理结构上有两种存储方式&#xff1a; 顺序存储结构&#xff1a; 使用此结构的线性表也叫 顺序表物理存储上是连续的&#xff0c;因此可以随机访问…
阅读更多...
CAS详解

CAS详解

文章目录 CAS使用示例Unsafe类实现原理CAS问题 CAS CAS全称为Compare and Swap被译为比较并交换&#xff0c;是一种无锁算法。用于实现并发编程中的原子操作。CAS操作检查某个变量是否与预期的值相同&#xff0c;如果相同则将其更新为新值。CAS操作是原子的&#xff0c;这意味…
阅读更多...
美团收银Android一面凉经(2024)

美团收银Android一面凉经(2024)

美团收银Android一面凉经(2024) 笔者作为一名双非二本毕业7年老Android, 最近面试了不少公司, 目前已告一段落, 整理一下各家的面试问题, 打算陆续发布出来, 供有缘人参考。今天给大家带来的是《美团收银Android一面凉经(2024)》。 应聘岗位: 美团餐饮PaaS平台Android开发工程师…
阅读更多...
使用offset explorer 3.0连接单机版kafka

使用offset explorer 3.0连接单机版kafka

一、目标 使用kafka图形化工具offset explorer 3.0连接单机版的kafka 二、windows下载安装offset explorer 3.0 1、kafka tool工具官方下载页面 Offset Explorer https://www.kafkatool.com/download.html 2、安装offset explorer 3.0 下一步&#xff0c;下一步&#xff0…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发