Java学习笔记(四)——正则表达式

news2024/9/24 23:29:02

文章目录

  • 正则表达式
    • 基本规则
      • 字符类(只匹配一个字符)
      • 预定义字符(只匹配一个字符)
      • 数量词
      • 练习
      • 正则表达式插件
    • 爬虫
      • 利用正则表达式获取想要的内容
      • 爬取网络信息
      • 练习
      • 有条件的爬取
      • 贪婪爬取
      • 非贪婪爬取
      • 正则表达式在字符串中的使用
    • 分组
      • 捕获分组
      • 正则表达式外部使用
      • 非捕获分组
      • 正则表达式忽略大小写

正则表达式

正则表达式的作用：

  • 校验字符串是否满足规则
  • 在一段文本中查找满足要求的内容

基本规则

字符类(只匹配一个字符)

表达式说明
[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

在这里插入图片描述

public class test57 {
    public static void main(String[] args) {
        System.out.println("ab".matches("[abc]"));  //false
        System.out.println("ab".matches("[abc][abc]"));  //true

        //一个&在正则表达式中是一个符号
        System.out.println("&".matches("[a-z&[abc]]"));  //true

        System.out.println("0".matches("a-z&&[abc]"));  //false 0不在a-z与abc的交集里面
    }
}

预定义字符(只匹配一个字符)

表达式说明
.任何字符
\d一个数字[0-9]
\D非数字
\s一个空白字符[\t\n\x0B\f\r]
\S非空白字符
\w[a-zA-Z_0-9]英文、数字、下划线
\W[^\w]

在这里插入图片描述

\ 转义字符，改变后面字符的含义

\ 前面的\是一个转义字符，把后面的\变成一个普通的无含义字符(路径)

public class test57 {
    public static void main(String[] args) {
      
        //  \   转义字符，改变后面字符的含义
        //  \\  前面的\是一个转义字符，把后面的\变成一个普通的无含义字符(路径)
        System.out.println("\"");  //"

        System.out.println("3".matches("\\d"));  //true
        System.out.println("2333".matches("\\d\\d\\d\\d"));  //true
    }
}

数量词

表达式说明
X?X，1次或0次
X*X，0次或多次
X+X，1次或多次
X{n}X，正好n次
X{n，}X，至少n次
X{n，m}X，至少n但不超过m次

在这里插入图片描述

练习

需求1：

请编写正则表达式验证用户输入的手机号码是否满足要求

请编写正则表达式验证用户输入的邮箱号是否满足要求

请编写正则表达式验证用户输入的电话号码是否满足要求

验证手机号码 13112345678 13712345667 13945679027 139456790271

验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434

验证邮箱号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test9 {
    public static void main(String[] args) {
        while(true){
            System.out.println("-----------请输入手机号/邮箱号/电话号-----------");
            Scanner sc=new Scanner(System.in);
            String str=sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            System.out.println("-------------------验证中--------------------");
            System.out.println("-----------------验证结果为-------------------");

            //手机号：1[3-9]\\d{9}
            //第一部分:1 表示手机号码只能以1开头
        	//第二部分:[3-9] 表示手机号码第二位只能是3-9之间的
       	 	//第三部分:\\d{9} 表示任意数字可以出现9次，也只能出现9次
            
            //邮箱号：\\w+@[\\w&&[^_]]{2,6}(\\.[A-Za-z]{2,3}){1,2}
            //第一部分:@的左边 \\w+
        	//      任意的字母数字下划线，至少出现一次就可以了
        	//第二部分:@ 只能出现一次
        	//第三部分:
        	//      3.1         .的左边[\\w&&[^_]]{2,6}
        	//                  任意的字母加数字，总共出现2-6次(此时不能出现下划线)
        	//      3.2         . \\.
        	//      3.3         大写字母，小写字母都可以，只能出现2-3次[a-zA-Z]{2,3}
        	//      我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次
            
            //电话号：0\\d{2,3}-?[1-9]\\d{4,9}
            //一:区号@\\d{2,3}
        	//      0:表示区号一定是以0开头的
        	//      \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。
        	//二:- ?表示次数，日次或一次
        	//三:号码 号码的第一位也不能以日开头，从第二位开始可以是任意的数字，号码的总长度:5-10位
            String regex="(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[A-Za-z]{2,3}){1,2})|(0\\d{2,3}-?[1-9]\\d{4,9})";
            Pattern pattern=Pattern.compile(regex);
            Matcher matcher=pattern.matcher(str);
            if(matcher.find()){
                System.out.println("-----------------验证成功！-------------------");
            }else{
                System.out.println("-----------验证失败！提示：输入错误！------------");
            }
        }

    }
}

需求2：

请编写正则表达式验证用户名是否满足要求。要求:大小写字母，数字，下划线一共4-16位

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test10 {
    public static void main(String[] args) {
        //大小写字母，数字，下划线一共4-16位
        Scanner sc=new Scanner(System.in);
        String regex="\\w{4,16}";
        Pattern pattern= Pattern.compile(regex);
        while(true){
            String str=sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            Matcher matcher=pattern.matcher(str);
            System.out.println(matcher.find());
        }

    }
}

需求3：

请编写正则表达式验证身份证号码是否满足要求。

简单要求：18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test11 {
    public static void main(String[] args) {
        //18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
        Scanner sc=new Scanner(System.in);
        String regex="\\d{17}(\\d|X|x)";
        Pattern pattern=Pattern.compile(regex);
        while (true){
            String str=sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            Matcher matcher=pattern.matcher(str);
            System.out.println(matcher.find());
        }
    }
}


import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test11 {
    public static void main(String[] args) {
        //18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
        Scanner sc=new Scanner(System.in);
        String regex="\\d{17}[\\dXx]";
        Pattern pattern=Pattern.compile(regex);
        while (true){
            String str=sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            Matcher matcher=pattern.matcher(str);
            System.out.println(matcher.find());
        }
    }
}


import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test11 {
    public static void main(String[] args) {
        //18位，前17位任意数字，最后一位可以是数字可以是大写或小写的x
        Scanner sc=new Scanner(System.in);
        String regex="(?i)\\d{17}[\\dx]";
        Pattern pattern=Pattern.compile(regex);
        while (true){
            String str=sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            Matcher matcher=pattern.matcher(str);
            System.out.println(matcher.find());
        }
    }
}

复杂要求：按照身份证号码的格式严格要求。

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test12 {
    public static void main(String[] args) {
        //410801 1993 02 28 457x
        //前面6位:省份，市区，派出所等信息，第一位不能是0，后面5位是任意数字 [1-9]\\d{5}
        //年的前半段: 18 19 20 (18|19|20)
        //年的后半段: 任意数字出现两次 \\d{2}
        //月份: 01~ 09 10 11 12 0[1-9]|1[0-2]
        //日期: 01~09 10~19 20~29 30 31     0[1-9]|[12]\\d|[3][01]
        //后面四位: 任意数字出现3次 最后一位可以是数字也可以是大写x或者小写x \\d{3}[\\dXx]
        Scanner sc=new Scanner(System.in);
        String regex="[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|[3][01])\\d{3}[\\dXx]";
        Pattern pattern= Pattern.compile(regex);
        while(true){
            String str= sc.nextLine();
            if(str.equals("exit")){
                break;
            }
            Matcher matcher=pattern.matcher(str);
            System.out.println(matcher.find());
        }
    }
}

正则表达式插件

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

爬虫

利用正则表达式获取想要的内容

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test1 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，"
                + "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        Pattern pattern=Pattern.compile("Java\\d{0,2}");  //正则表达式对象
        Matcher matcher=pattern.matcher(str);  //文本匹配器对象
        while(matcher.find()){  //是否有满足规则的子串，如果为true，底层会记录子串的起始索引和结束索引+1
            System.out.println(matcher.group());  //返回满足规则的子串
        }
    }
}

爬取网络信息

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test2 {
    public static void main(String[] args) throws IOException {
        URL url=new URL("https://520zuowens.com/xiaoxue/1122109.html");  // 爬取信息的网址

        URLConnection urlConnection= url.openConnection();  // 建立连接

        BufferedReader br=new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));

        Pattern pattern=Pattern.compile("[1-9]\\d{17}");  // 正则表达式对象

        String str;
        
        while((str= br.readLine())!=null){
            Matcher matcher=pattern.matcher(str);
            while (matcher.find()){
                System.out.println(matcher.group());
            }
        }
        
        br.close();
    }
}

练习

需求：

​ 把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。

来学习Java，

手机号:18512516758，18512508907，

联系邮箱:boniu@itcast.cn，

座机电话:01036517895，010-98951256

邮箱:bozai@itcast.cn，

热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090。

import java.io.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test3 {
    public static void main(String[] args) throws IOException {
        String str="来学习Java，\n" +
                "手机号:18512516758，18512508907.\n" +
                "联系邮箱:boniu@itcast.cn，\n" +
                "座机电话:01036517895，010-98951256\n" +
                "邮箱:bozai@itcast.cn，\n" +
                "热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090。\n";
        
        byte[] bytes=str.getBytes();
        InputStream inputStream=new ByteArrayInputStream(bytes);
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        // 手机号的正则表达式：1[3-9]\\d{9}
        // 邮箱的正则表达式：\\w+@[\\w&&[^_]]{2,6}.[A-Za-z]{2,3}
        // 座机电话的正则表达式：0\\d{2,3}-?[1-9]\\d{4,9}
        // 热线电话正则表达式：400-?\\d{3}-?\\d{4}
        
        String regex="(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}.[A-Za-z]{2,3})|(0\\d{2,3}-?[1-9]\\d{4,9})|(400-?\\d{3}-?\\d{4})";

        Pattern pattern=Pattern.compile(regex);

        String str1;
        while((str1=br.readLine())!=null){
            Matcher matcher=pattern.matcher(str1);
            while (matcher.find()){
                System.out.println(matcher.group().toString());
            }
        }

    }
}

有条件的爬取

需求：

​ 有如下文本，按要求爬取数据。

​ Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。

需求1：

​ 爬取版本号为8，11.17的Java文本，但是只要Java，不显示版本号。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test4 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="Java(?=8|11|17)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

忽略java大小写：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test4 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是JAva8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是JaVa17，相信在未来不久JavA17也会逐渐登上历史舞台";
        String regex="((?i)Java)(?=8|11|17)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

需求2：

​ 爬取版本号为8，11，17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test4 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="Java(8|11|17)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test4 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="Java(?:8|11|17)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

需求3：

​ 爬取除了版本号为8，11，17的Java文本。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test4 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和Java11，" +
                "因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";
        String regex="Java(?!8|11|17)";
        Pattern pattern=Pattern.compile(regex);
        Matcher matcher=pattern.matcher(str);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
    }
}

贪婪爬取

只写+和表示贪婪匹配，如果在+和后面加问号表示非贪婪爬取

+? 非贪婪匹配

*? 非贪婪匹配

贪婪爬取:在爬取数据的时候尽可能的多获取数据

非贪婪爬取:在爬取数据的时候尽可能的少获取数据

举例：

如果获取数据：ab+

贪婪爬取获取结果:abbbbbbbbbbbb

如果获取数据：ab+?

非贪婪爬取获取结果:ab

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test5 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "经历了很多版木，目前企业中用的最多的是]ava8和]ava11，因为这两个是长期支持版木。" +
                "下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        String regex = "ab+";  // 贪婪爬取
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

非贪婪爬取

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class test5 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "经历了很多版木，目前企业中用的最多的是]ava8和]ava11，因为这两个是长期支持版木。" +
                "下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台";

        String regex = "ab+?";  // 非贪婪爬取
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
}

正则表达式在字符串中的使用

在这里插入图片描述

public class test6 {
   public static void main(String[] args) {
       String str="cjm是猪dqwefqwfqwfwq12312cjm是猪dqwefqwfqwfwq12312cjm是猪";

       // 方法底层也会创建文本解析器的对象
       // 从头开始读，满足条件的用第二个参数替换
       String result=str.replaceAll("[\\w&&[^_]&&[^cjm]]+","  !!!cjm是sqd的猪!!!  ");

       System.out.println(result);
   }
}

运行结果：cjm是猪 !!!cjm是sqd的猪!!! cjm是猪 !!!cjm是sqd的猪!!! cjm是猪

public class test6 {
    public static void main(String[] args) {
        String str="cjm是猪dqwefqwfqwfwq12312cjm是猪dqwefqwfqwfwq12312cjm是猪";

        String[] result=str.split("[\\w&&[^_]&&[^cjm]]+");

        for(int i=0;i<result.length;i++){
            System.out.println(result[i]);
        }
    }
}

运行结果：

cjm是猪
cjm是猪
cjm是猪

分组

捕获分组

可以获取每组中的内容反复使用。

在这里插入图片描述

需求1：判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符

举例：a123a b456b 17891 &abc& a123b(false)

public class test7 {
    public static void main(String[] args) {
        // \\1表示第一个分组
        String regex="(.).+\\1";
        System.out.println("a123a".matches(regex));
        System.out.println("b456b".matches(regex));
        System.out.println("17891".matches(regex));
        System.out.println("&abc&".matches(regex));
        System.out.println("a123b".matches(regex));
    }
}

需求2：判断一个字符串的开始部分和结束部分是否一致?可以有多个字符

举例：abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)

public class test7 {
    public static void main(String[] args) {
        // \\1表示第一个分组
        String regex="(.+).+\\1";
        System.out.println("abc123abc".matches(regex));
        System.out.println("b456b".matches(regex));
        System.out.println("123789123".matches(regex));
        System.out.println("&!@abc&!@".matches(regex));
        System.out.println("abc123abd".matches(regex));
    }
}

需求3：判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致

举例：aaa123aaa bbb456bbb 111789111 &&abc&&

public class test7 {
    public static void main(String[] args) {
        // (.):把首字母看做一组
        // \\2:把首字母拿出来再次使用
        // *:作用于\\2,表示后面重复的内容出现0次或多次
        String regex="((.)\\2*).+\\1";
        System.out.println("aaa123aaa".matches(regex));
        System.out.println("bbb456bbb".matches(regex));
        System.out.println("111789111".matches(regex));
        System.out.println("&&abc&&".matches(regex));
    }
}

正则表达式外部使用

在这里插入图片描述

需求:

​ 将字符串：我要学学编编编编程程程程程程。

​ 替换为：我要学编程

public class test8 {
    public static void main(String[] args) {
        String str = "我要学学编编编编程程程程程程";
        
        //  (.)表示把重复内容的第一个字符看做一组
		//  \\1表示第一字符再次出现
		//  + 至少一次
		//  $1 表示把正则表达式中第一组的内容，再拿出来用
        String result=str.replaceAll("(.)\\1+","$1");
        System.out.println(result);
    }
}

非捕获分组

使用非捕获分组的数据不占组号。

在这里插入图片描述

正则表达式忽略大小写

(?i) ：表示忽略后面数据的大小写

//忽略abc的大小写
String regex = "(?i)abc";
//a需要一模一样，忽略bc的大小写
String regex = "a(?i)bc";
//ac需要一模一样，忽略b的大小写
String regex = "a((?i)b)c";

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

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

相关文章

公共用例库计划--个人版（二）主体界面设计

公共用例库计划--个人版（二）主体界面设计

1、任务概述 计划内容&#xff1a;完成公共用例库的开发实施工作&#xff0c;包括需求分析、系统设计、开发、测试、打包、运行维护等工作。 1.1、 已完成&#xff1a; 需求分析、数据库表的设计&#xff1a;公共用例库计划–个人版&#xff08;一&#xff09; 1.2、 本次待…
阅读更多...
神经网络-卷积层

神经网络-卷积层

卷积 输入通道数&#xff0c; 输出通道数&#xff0c;核大小 参数具体含义 直观理解各个参数的网站(gif) https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md大概长这样&#xff0c;cyan是青色的意思 channel数&#xff08;终于理解论文里图片放好多层的原因…
阅读更多...
VMware ESXI 8 安装ipmitool 调整戴尔服务器风扇转速

VMware ESXI 8 安装ipmitool 调整戴尔服务器风扇转速

本文内容适合ESXI 8版本安装ipmitool &#xff0c;进行管理&#xff0c;已知的是8.0以上版本无法安装社区的vib.所以需要自己编译文件&#xff0c;7.0及之前的版本可以安装vib版本的ipmtools。 一、编译好的适用于esxi8的ipmitool下载 ipmitool下载 二、安装ipmitool 1、开…
阅读更多...
铁塔基站数字化管理监测解决方案

铁塔基站数字化管理监测解决方案

截至2023年10月&#xff0c;我国5G基站总数达321.5万个&#xff0c;占全国通信基站总数的28.1%。然而&#xff0c;随着5G基站数量的快速增长&#xff0c;基站的能耗问题也逐渐日益凸显&#xff0c;基站的用电给运营商带来了巨大的电费开支压力&#xff0c;降低5G基站的能耗成为…
阅读更多...
new FormData 同时发送表单 json 以及文件二进制流

new FormData 同时发送表单 json 以及文件二进制流

需要新增时同时发送表单 json 以及对应的文件即可使用以下方法传参 let formDataParams new FormData(); 首先通过 new FormData&#xff08;&#xff09; 创建你需要最后发送的表单 接着将你的对象 json 存储&#xff0c;注意使用 new Blob 创建大表单转换成 json 格式。以…
阅读更多...
根据MySql的表名，自动生成实体类，模仿ORM框架

根据MySql的表名，自动生成实体类，模仿ORM框架

ORM框架可以根据数据库的表自动生成实体类&#xff0c;以及相应CRUD操作 本文是一个自动生成实体类的工具&#xff0c;用于生成Mysql表对应的实体类。 新建Winform窗体应用程序AutoGenerateForm&#xff0c;框架(.net framework 4.5)&#xff0c; 添加对System.Configuration的…
阅读更多...
了解nginx

了解nginx

1&#xff0c;概念 nginx是一个轻量级、高性能的HTTP和反向代理web服务器&#xff0c;同时也是一个通用代理服务器&#xff08;TCP、UDP、IMAP、POP3、SMTP&#xff09;。 2&#xff0c;优势 轻量级&#xff0c;占用内存少&#xff0c;启动极快采用事件驱动的异步非阻塞处理方…
阅读更多...
linux中的系统安全

linux中的系统安全

一.账号安全 将非登录用户的shell设为/sbin/nologin 系统中用户有三种&#xff1a;超级管理员 普通用户 程序用户 前两种用户可以登录系统&#xff0c;程序用户不给登录 所以称为非登录用户 命令格式&#xff1a; usermod -s /sbin/nologin&#xff08;改已有用户&#…
阅读更多...
亲测表白网制作源码，在线制作表白，无数据库上传就能用

亲测表白网制作源码，在线制作表白，无数据库上传就能用

在线制作表白网源码 没有数据库上传就能用 后台/admin 账号密码都是admin
阅读更多...
【mars3d】批量关闭矢量数据的startFlicker()闪烁或者全部关闭startFlicker()

【mars3d】批量关闭矢量数据的startFlicker()闪烁或者全部关闭startFlicker()

问题 1.graphic/entity/billboard怎么能够批量关闭startFlicker()闪烁或者 全部关闭startFlicker()呢&#xff1f; 相关链接 1.http://mars3d.cn/editor-vue.html?idgraphic/entity/billboard 2.http://mars3d.cn/apidoc.html#FlickerEntity 期望效果 1.graphic.stopFlic…
阅读更多...
Java：爬虫htmlunit

Java：爬虫htmlunit

为什么htmlunit与HttpClient两者都可以爬虫、网页采集、通过网页自动写入数据&#xff0c;我们会推荐使用htmlunit呢? 一、网页的模拟化 首先说说HtmlUnit相对于HttpClient的最明显的一个好处&#xff0c;HtmlUnit更好的将一个网页封装成了一个对象&#xff0c;如果你非要说H…
阅读更多...
数字后端设计实现 | 数字后端PR工具Innovus中如何创建不同高度的row？

数字后端设计实现 | 数字后端PR工具Innovus中如何创建不同高度的row？

吾爱IC社区星球学员问题&#xff1a;Innovus后端实现时两种种不同高度的site能做在一个pr里面吗&#xff1f; 答案是可以的。 Innovus支持在同一个设计中中使用不同的row&#xff0c;但需要给各自子模块创建power domain。这里所说的不同高度的row&#xff0c;有两种情况。 1…
阅读更多...
数据库高可用mha

数据库高可用mha

MHA搭建的步骤 一.配置主从复制 1.初始化环境 #在四台服务器上初始化环境 systemctl stop firewalld systemctl disable firewalld setenforce 0 2.修改 Master、Slave1、Slave2 节点的主机名 #在Master上 hostnamectl set-hostname mysql1 su#在Slave1 hostnamectl set-h…
阅读更多...
102、X^3 : Large-Scale 3D Generative Modeling using Sparse Voxel Hierarchies

102、X^3 : Large-Scale 3D Generative Modeling using Sparse Voxel Hierarchies

简介 官网  Nvidia2023提出的一种新的生成模型&#xff0c;可生成具有任意属性的高分辨率稀疏3D体素网格&#xff0c;以前馈方式生成数百万体素&#xff0c;最细有效分辨率高达 102 4 3 1024^3 10243&#xff0c;而无需耗时的 test-time 优化&#xff0c;使用一种分层体素潜…
阅读更多...
LeetCode 2125. 银行中的激光束数量【数组,遍历】1280

LeetCode 2125. 银行中的激光束数量【数组,遍历】1280

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
1.3进制，码（8421），化简规则、卡诺图化简、性质，触发器（转换与设计、应用），电路图，电路设计

1.3进制，码（8421），化简规则、卡诺图化简、性质，触发器（转换与设计、应用），电路图，电路设计

十进制与原码、反码、补码之间的转换 正数的原码、反码、补码相同&#xff0c;符号位为0 负数的原码为、符号位1&#xff0c;二进制数 反码&#xff0c;符号位不变、其它取反&#xff0c; 补码为&#xff1a;反码最低有效位1 运算 卡诺图化简 奇偶校验码 检查1的个数&…
阅读更多...
C语言编译器（C语言编程软件）完全攻略（第二十四部分：Turbo C 2.0使用教程（使用Turbo C 2.0编写C语言程序））

C语言编译器（C语言编程软件）完全攻略（第二十四部分：Turbo C 2.0使用教程（使用Turbo C 2.0编写C语言程序））

介绍常用C语言编译器的安装、配置和使用。 二十四、Turbo C 2.0使用教程&#xff08;使用Turbo C 2.0编写C语言程序&#xff09; 首先&#xff0c;我们给出一段完整的C语言代码&#xff1a; #include <stdio.h> int main() { puts("hello&#xff0c;world!"…
阅读更多...
【mars3d】new mars3d.layer.GeoJsonLayer({实现多孔面遮罩mask: true,

【mars3d】new mars3d.layer.GeoJsonLayer({实现多孔面遮罩mask: true,

【mars3d】new mars3d.layer.GeoJsonLayer({实现多孔面遮罩 官网测试示例&#xff1a; 1.功能示例(Vue版) | Mars3D三维可视化平台 | 火星科技 测试代码&#xff1a; export function showDraw(isFlyTo) { removeLayer() const geoJsonLayer new mars3d.layer.GeoJsonLaye…
阅读更多...
【Spring实战】22 Spring Actuator 入门

【Spring实战】22 Spring Actuator 入门

文章目录 1. 定义2. 功能3. 依赖4. 配置5. 常用的应用场景1&#xff09;环境监控2&#xff09;运维管理3&#xff09;性能优化 结论 Spring Actuator 是 Spring 框架的一个模块&#xff0c;为开发人员提供了一套强大的监控和管理功能。本文将深入探讨 Spring Actuator 的定义、…
阅读更多...
【AI视野·今日NLP 自然语言处理论文速览 第六十八期】Tue, 2 Jan 2024

【AI视野·今日NLP 自然语言处理论文速览 第六十八期】Tue, 2 Jan 2024

AI视野今日CS.NLP 自然语言处理论文速览 Tue, 2 Jan 2024 Totally 48 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computation and Language Papers A Computational Framework for Behavioral Assessment of LLM Therapists Authors Yu Ying Chiu, Ashish Shar…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023