首页 > 编程语言 >javase复习day18API

javase复习day18API

时间:2024-09-08 08:52:44浏览次数:12  
标签:复习 matches day18API System String println javase public out

游戏打包exe

Math

abs方法的小bug:

以int类型为例,取值范围: -2147483648~2147483647

如果没有正数与之对应,那么传递负数结果有误

-2147483648没有正数对应则结果还是 -2147483648

可以使用JDK15后的新方法 absExact 如果结果有误则会报错

package MathDemo1;

public class DEmo1 {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(-18));//18
        System.out.println(Math.abs(18));//18
        System.out.println(Math.abs(-18.2));//v18.2
        System.out.println(Math.abs(18.4));//18.4
        //超限代码/
//        System.out.println(Math.abs(-2147483648));
//        System.out.println(Math.absExact(-2147483648));
        System.out.println("=====================================");
        //向上取整(向数轴整方向找到最大的第一个数)
        System.out.println(Math.ceil(-18.64));//v-18.0
        System.out.println(Math.ceil(18.23));//19.0
        System.out.println(Math.ceil(-18.2));//-18.0
        System.out.println(Math.ceil(18.64));//v19.0
        System.out.println("=====================================");
        //向下取整
        System.out.println(Math.floor(-18.64));//-19.0
        System.out.println(Math.floor(18.23));//18.0
        System.out.println(Math.floor(-18.2));//-19.0
        System.out.println(Math.floor(18.64));//18.0
        System.out.println("=====================================");
        //四舍五入
        System.out.println(Math.round(-18.64));//-19
        System.out.println(Math.round(18.23));//18
        System.out.println(Math.round(-18.2));//-18
        System.out.println(Math.round(18.64));//19
        System.out.println("=====================================");
        //获取较大值
        System.out.println(Math.max(-18.64,-18.24));//-18.24
        System.out.println(Math.max(18.23,18.24));//18.24
        System.out.println(Math.max(-18.2,-18));//-18.0
        System.out.println(Math.max(18.64,18));//18.64
        System.out.println("=====================================");
        //较小值
        System.out.println(Math.min(1, 3));//1
        System.out.println(Math.min(-1, -3));//-3
        System.out.println("=====================================");
        //获取a的b次幂
        System.out.println(Math.pow(2, 3));//8.0
        //开方
        System.out.println(Math.pow(2, -2));//0.25
        System.out.println(Math.pow(4, 0.5));//2.0
        System.out.println("=====================================");
        //开方的工具方法
        System.out.println(Math.sqrt(4));//2.0
        //开立方
        System.out.println(Math.cbrt(8));//2.0
        //随机数
        System.out.println(Math.random()*100+1);//1-100的随机数 33.522290411168676


    }
}

练习一

package MathDemo1;

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(ismasd(16));
        System.out.println(ismasd(7));
    }
    //方法用以判断是否为质数、
    public static boolean ismasd(int n){
        for (int i = 2; i < Math.sqrt(n); i++) {
            if (n%i==0){
                return false;
            }
        }
        return true;
    }
}

练习二

要求一: 

package MathDemo1;

public class Demo3 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 100; i < 999; i++) {
            if (sui(i)){
                sum++;
            }
        }
        System.out.println("水仙花数的个数"+sum);
    }
    public static boolean sui(int ornubmer){
        int nubmer = ornubmer;
        //获取各个位的数字
        int[] arr = new int[3];
        int count = 0;
        while (nubmer!=0) {
            arr[count] = nubmer%10;
            nubmer = nubmer/10;
            count++;
        }

        //获取和数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
           sum += Math.pow(arr[i], arr.length );
        }
//        System.out.println(sum);
        if (ornubmer == sum){
            //是水仙花数
            System.out.println(sum);
            return true;
        }
        return false;
    }
}
public class Demo4 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1000; i < 9999; i++) {
            if (sui(i)){
                sum++;
            }
        }
        System.out.println("四叶草数的个数"+sum);
    }
    public static boolean sui(int ornubmer){
        int nubmer = ornubmer;
        //获取各个位的数字
        int[] arr = new int[4];
        int count = 0;
        while (nubmer!=0) {
            arr[count] = nubmer%10;
            nubmer = nubmer/10;
            count++;
        }

        //获取和数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += Math.pow(arr[i], arr.length );
        }
//        System.out.println(sum);
        if (ornubmer == sum){
            System.out.println(sum);
            return true;
        }
        return false;
    }
}
package MathDemo1;

public class Demo5 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 10000; i < 99999; i++) {
            if (sui(i)){
                sum++;
            }
        }
        System.out.println("五角星数的个数"+sum);
    }
    public static boolean sui(int ornubmer){
        int nubmer = ornubmer;
        //获取各个位的数字
        int[] arr = new int[5];
        int count = 0;
        while (nubmer!=0) {
            arr[count] = nubmer%10;
            nubmer = nubmer/10;
            count++;
        }

        //获取和数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += Math.pow(arr[i], arr.length );
        }
//        System.out.println(sum);
        if (ornubmer == sum){
            System.out.println(sum);
            return true;
        }
        return false;
    }
}
package MathDemo1;



public class Demo6 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 10; i < 99; i++) {
            if (sui(i)){
                sum++;
            }
        }
        System.out.println("两位的个数"+sum);
    }
    public static boolean sui(int ornubmer){
        int nubmer = ornubmer;
        //获取各个位的数字
        int[] arr = new int[2];
        int count = 0;
        while (nubmer!=0) {
            arr[count] = nubmer%10;
            nubmer = nubmer/10;
            count++;
        }

        //获取和数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += Math.pow(arr[i], arr.length );
        }
//        System.out.println(sum);
        if (ornubmer == sum){
            System.out.println(sum);
            return true;
        }
        return false;
    }
}

System

计算机的时间原点

arraycopy的小细节

  1. 如果数据源数组和目的数组都是基本数据类型,那么两者类型必须保持一致,否则报错
  2. 在拷贝数组时要注意考虑数组的长度,如果超出范围也会报错
  3. 如果数据原数组和目的数组都是引用数据类型,那么子类类型可以赋值给父类类型。
package SystemDemo;

public class Demo1 {
    public static void main(String[] args) {
        //exit 0表示正常关闭虚拟机
        // 其他值表示异常关闭虚拟机
//        System.exit(0);

        System.out.println(System.currentTimeMillis());
       double sum = 1;
        long statr = System.currentTimeMillis();
        for (int i = 1; i < 1000; i++) {
            sum = sum*i;
        }
        long end = System.currentTimeMillis();
        System.out.println(sum);
        System.out.println(end - statr);

        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];

        System.arraycopy(arr,0,arr2,0,10);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }

        //拷贝子类给父类
        student s1 = new student("xiaoli",18);
        student s2 = new student("sd",18);
        student s3 = new student("laowang",18);

        student[] students = {s1,s2,s3};
        Parson[] parsons = new Parson[3];
        System.arraycopy(students,0,parsons,0,3);
        //输出
        for (int i = 0; i < parsons.length; i++) {
            Parson parson = parsons[i];
            System.out.println(parson);
        }

    }
   static class Parson{
        String name;
        int age;

        public Parson() {
        }

        public Parson(String name, int age) {
            this.name = name;
            this.age = age;
        }

        /**
         * 获取
         * @return name
         */
        public String getName() {
            return name;
        }

        /**
         * 设置
         * @param name
         */
        public void setName(String name) {
            this.name = name;
        }

        /**
         * 获取
         * @return age
         */
        public int getAge() {
            return age;
        }

        /**
         * 设置
         * @param age
         */
        public void setAge(int age) {
            this.age = age;
        }

        public String toString() {
            return "Parson{name = " + name + ", age = " + age + "}";
        }
    }
    static class student extends Parson{
        public student() {
        }

        public student(String name, int age) {
            super(name, age);
        }
    }
}

Runtime

package Runtime;

import java.io.IOException;

public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        //获取当前的运行环境
        Runtime r1 = Runtime.getRuntime();
        //停止虚拟机,System中的方法就是调用的这里
//        r1.exit(0);
        //获取cpu线程数
        System.out.println(r1.availableProcessors());

        //获取jvm从系统获取的总内存大小,单位是byte
        System.out.println(r1.maxMemory()/1024/1024);//MB

        //获取已经获取的内存大小
        System.out.println(r1.totalMemory()/1024/1024);


        //获取jvm中剩余的内存大小
        System.out.println(r1.freeMemory()/1024/1024);

        //运行cmd命令
        /**
         * shutdown 关机
         * 需要加参数
         *  -s :默认在一分钟后关闭
         *  -s -t 指定时间关闭 (单位 秒)
         *  -a 取消关机计划
         *  -r 关机并重启
         *  shutdown -s -t 3600
         */
        r1.exec("shutdown -a");




    }
}

小练习

Object和Objects

System.out.println():

注意:

  • System : 类名
  • out :静态变量
  • System.out : 获取要打印的对象
  • printIn() : 方法
  • 参数:表示打印的内容

 核心逻辑:

当我们打印一个对象的时候底层会调用对象的toString方法,把对象变成字符串。然后在打印在控制台上。

思考:默认下对象的tostring方法获取的都是地址值,想要打印属性值需要重写toString方法

package ObjectDemo1;

public class Demo1 {
    public static void main(String[] args) {
        //重写了toString方法
        Student s1 = new Student("xiaoli",20);
        Student s2 = new Student("xiaoli",20);
        //重写了equle方法
        System.out.println(s1);
        System.out.println(s1.equals(s2));


    }

}

//克隆对象
//由于Object中的克隆方法受保护,所以必须在对象类中重写克隆方法
/**
 * 方法在底层会创建一个对象并把原对象拷贝过去
 */
/**
 * 细节
 * 1.重写Object中的克隆方法
 * 2.让javaBean类实现Cloneable接口
 * 3.创建对象并调用
 */
/**
 * Cloneable
 * 如果一个接口没有抽象方法
 * 表示是一个标记接口
 * Cloneable表示一旦实现了该接口那么当前类的对象就可以被克隆
 * 如果没有实现则不支持克隆
 */
package ObjectDemo1;

import java.util.Arrays;
import java.util.Objects;
import java.util.StringJoiner;

/**
 * Cloneable
 * 如果一个接口没有抽象方法
 * 表示是一个标记接口
 * Cloneable表示一旦实现了该接口那么当前类的对象就可以被克隆
 * 如果没有实现则不支持克隆
 */
public class User implements Cloneable{
    int id;
    String username;
    String password;
    String path;
    int[] data;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && Objects.equals(username, user.username) && Objects.equals(password, user.password) && Objects.equals(path, user.path) && Arrays.equals(data, user.data);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(id, username, password, path);
        result = 31 * result + Arrays.hashCode(data);
        return result;
    }

    public User() {
    }

    public User(int id, String username, String password, String path, int[] data) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.path = path;
        this.data = data;
    }

    /**
     * 获取
     * @return id
     */
    public int getId() {
        return id;
    }

    /**
     * 设置
     * @param id
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * 获取
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * 设置
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * 获取
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     * @return path
     */
    public String getPath() {
        return path;
    }

    /**
     * 设置
     * @param path
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * 获取
     * @return data
     */
    public int[] getData() {
        return data;
    }

    /**
     * 设置
     * @param data
     */
    public void setData(int[] data) {
        this.data = data;
    }

    public String toString() {
        return "User{用户id = " + id + ", 用户名称 = " + username + ", 用户密码 = " + password + ", 游戏图片 = " + path + ", 游戏进度 = " + datatoString() + "}";
    }

    public String datatoString(){
        //创建一个StringJioner对象用来存储数组的数据
        StringJoiner sj = new StringJoiner(",","[","]");
        for (int i = 0; i < data.length; i++) {
            sj.add(data[i]+"");
        }
       return sj.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类的克隆方法
        //相当于java帮我们克隆一个对象并把克隆对象返回出去
        return super.clone();
    }
}
package ObjectDemo1;

public class Demo3 {
    public static void main(String[] args) throws CloneNotSupportedException {
        //对象克隆
        //创建对象
        int[] data = {1,2,3,4,5,6,7,8,9,10,0};
        User u1 = new User(1,"zhangsan","123456","girl11",data);
        //克隆对象
        //由于Object中的克隆方法受保护,所以必须在对象类中重写克隆方法
        /**
         * 方法在底层会创建一个对象并把原对象拷贝过去
         */
        /**
         * 细节
         * 1.重写Object中的克隆方法
         * 2.让javaBean类实现Cloneable接口
         * 3.创建对象并调用
         */
        User u2 = (User) u1.clone();

        System.out.println(u1);
        System.out.println(u2);
    }

}

内存分析

进行深克隆所重写的克隆方法:

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //调用父类的克隆方法
        //相当于java帮我们克隆一个对象并把克隆对象返回出去

        //重写克隆方法使其为深克隆
        
        //创建一个GSON对象
        Gson gson = new Gson();
        //将被克隆的对象转换为json格式
        String json = gson.toJson(super.clone());
        //将json对象同过提供的转换方法转为USer类型的对象,将其作为返回值返回,即为深克隆
        User user = gson.fromJson(json, User.class);
        return user;
    }

OBjects

package ObjectDemo1;

import java.util.Objects;

public class Demo4 {
    public static void main(String[] args) {
        Student s1 = new Student("小康",19);
        Student s2 = new Student("小康",19);
        boolean equals = Objects.equals(s1, s2);
        System.out.println(equals);
        Student s3 = new Student("zsd",29);
        Student s4 = null;

        System.out.println(Objects.isNull(s3));
        System.out.println(Objects.isNull(s4));
        System.out.println(Objects.nonNull(s3));
        System.out.println(Objects.nonNull(s4));
    }
}

BigInteger

package BigInterger;

import java.math.BigInteger;
import java.util.Random;

public class Demo1 {
    public static void main(String[] args) {
        Random r = new Random();
        BigInteger b1 = new BigInteger(100,r);
        System.out.println(b1);

        //只能加入数字不可以加小数和字母
        BigInteger b2 = new BigInteger("199999999999999999999999999");
        System.out.println(b2);

        BigInteger b3 = new BigInteger("111",2);
        System.out.println(b3);

        //只能获取long类型的范围内的数
        System.out.println(BigInteger.valueOf(12121));

        //加法,生成一个新的对象

        BigInteger add = b1.add(b2);
        System.out.println(add);
        System.out.println(add==b1);
        System.out.println(add==b2);

    }
}

BigInteger的成员方法

package BigInterger;

import java.math.BigInteger;

public class Demo2 {
    public static void main(String[] args) {
        BigInteger b1 = BigInteger.valueOf(10);
        BigInteger b2 = BigInteger.valueOf(5);
        //加
        BigInteger add = b1.add(b2);
        System.out.println(add);
        //除法获取商和余数
        BigInteger[] bigIntegers = b1.divideAndRemainder(b2);
        for (int i = 0; i < bigIntegers.length; i++) {
            System.out.println(bigIntegers[i]);
        }
        //是否相同
        System.out.println(b1.equals(b2));

        //次幂,必须要是int类型
        BigInteger pow = b1.pow(2);
        System.out.println(pow);

        //比较,将符合的对象返回,并不创建新的对象
        BigInteger max = b1.max(b2);
        System.out.println(b1.equals(max));
        System.out.println(max);

        //转换
        BigInteger b3 = new BigInteger("11111111111111");
        int i = b3.intValue();
        System.out.println(i);

        long l = b3.longValue();
        System.out.println(l);

        double v = b3.doubleValue();
        System.out.println(v);


    }
}

BigInteger的底层存储

BigInteger的存储上限

BigInteger小结

BigDecimal

package BigDecima;

import java.math.BigDecimal;

public class Test1 {
    public static void main(String[] args) {
        //这种创建方式可能造成精度缺失
        BigDecimal bd1 = new BigDecimal(0.09);
        BigDecimal b2 = new BigDecimal(0.01);
        System.out.println(bd1.add(b2));

        BigDecimal b3 = new BigDecimal("0.01");
        BigDecimal b4 = new BigDecimal("0.09");
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b3.add(b4));

        //通过静态方法创建对象
        /**
         * 如果表示的数字不大没有超过double的范围,建议使用静态方法
         * 如果数字大,建议使用字符串的构造方法
         * 如果传入的数据是0-10之间的整数(包含0和10)那么方法会返回创建好的对象,且不会多次创建
         *
         */
        BigDecimal b5 = BigDecimal.valueOf(0.01);
        BigDecimal b6 = BigDecimal.valueOf(0.09);
        System.out.println(b5);
        System.out.println(b6);
        //也可以输入long类型
        BigDecimal b7 = BigDecimal.valueOf(10);
        BigDecimal b8 = BigDecimal.valueOf(10);

        System.out.println(b7==b8);

        BigDecimal b9= BigDecimal.valueOf(10.0);
        BigDecimal b10 = BigDecimal.valueOf(10.0);
        System.out.println(b9==b10);
    }
}

BigDecimal的使用

package BigDecima;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Test2 {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("10.0");
        BigDecimal b2 = new BigDecimal("3.0");

        System.out.println(b1.add(b2));

        System.out.println(b1.subtract(b2));

        System.out.println(b1.multiply(b2));

        //除法保留小数点后三位,采用四舍五入的逻辑
        BigDecimal divide = b1.divide(b2, 3, RoundingMode.HALF_UP);
        System.out.println(divide);

    }
}

BigDecimal的底层存储

小结

正则表达式

练习一:体验正则表达式

package RegexDemo;

public class Demo1 {
    public static void main(String[] args) {
        String qq = "2072454545";

        System.out.println(isqq(qq));

        //使用正则表达式
        System.out.println(qq.matches("[1-9]\\d{5,19}"));

    }
    //使用原来的方法写一个校验方法
    public static boolean isqq(String string){
        //校验位数
        if (string.length()<5 || string.length()>20){
            return false;
        }
        //校验开头是否为0
        if (string.charAt(0) == '0'){
            return false;
        }
        //是否全是数字
        for (int i = 0; i < string.length(); i++) {
            if (string.charAt(i)<'0'||string.charAt(i)>'9'){
                return false;
            }
        }
        return true;
    }
}

正则表达式作用

正则表达式的规则

注意事项

如果要表示两个范围的交集,需要写 &&

如果写成一个& 那么表示的就不是交集而是一个简简单单的&符号

忽略大小写: (?i)。

package com.itheima.a08regexdemo;

public class RegexDemo2 {
    public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配,匹配返回true
        // 只能是a b c
        System.out.println("-----------1-------------");
        System.out.println("a".matches("[abc]")); // true
        System.out.println("z".matches("[abc]")); // false

        // 不能出现a b c
        System.out.println("-----------2-------------");
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("z".matches("[^abc]")); // true
        System.out.println("zz".matches("[^abc]")); //false
        System.out.println("zz".matches("[^abc][^abc]")); //true

        // a到zA到Z(包括头尾的范围)
        System.out.println("-----------3-------------");
        System.out.println("a".matches("[a-zA-z]")); // true
        System.out.println("z".matches("[a-zA-z]")); // true
        System.out.println("aa".matches("[a-zA-z]"));//false
        System.out.println("zz".matches("[a-zA-Z]")); //false
        System.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //true
        System.out.println("0".matches("[a-zA-Z]"));//false
        System.out.println("0".matches("[a-zA-Z0-9]"));//true


        // [a-d[m-p]] a到d,或m到p
        System.out.println("-----------4-------------");
        System.out.println("a".matches("[a-d[m-p]]"));//true
        System.out.println("d".matches("[a-d[m-p]]")); //true
        System.out.println("m".matches("[a-d[m-p]]")); //true
        System.out.println("p".matches("[a-d[m-p]]")); //true
        System.out.println("e".matches("[a-d[m-p]]")); //false
        System.out.println("0".matches("[a-d[m-p]]")); //false

        // [a-z&&[def]] a-z和def的交集。为:d,e,f
        System.out.println("----------5------------");
        //这个有问题
        System.out.println("a".matches("[a-z&[def]]")); //true
        System.out.println("d".matches("[a-z&&[def]]")); //true
        System.out.println("0".matches("[a-z&&[def]]")); //false

        // [a-z&&[^bc]] a-z和非bc的交集。(等同于[ad-z])
        System.out.println("-----------6------------_");
        System.out.println("a".matches("[a-z&&[^bc]]"));//true
        System.out.println("b".matches("[a-z&&[^bc]]")); //false
        System.out.println("0".matches("[a-z&&[^bc]]")); //false

        // [a-z&&[^m-p]] a到z和除了m到p的交集。(等同于[a-1q-z])
        System.out.println("-----------7-------------");
        System.out.println("a".matches("[a-z&&[^m-p]]")); //true
        System.out.println("m".matches("[a-z&&[^m-p]]")); //false
        System.out.println("0".matches("[a-z&&[^m-p]]")); //false

    }
}

package com.itheima.a08regexdemo;

public class RegexDemo3 {
    public static void main(String[] args) {
        // \ 转义字符 改变后面那个字符原本的含义
        //练习:以字符串的形式打印一个双引号
        //"在Java中表示字符串的开头或者结尾

        //此时\表示转义字符,改变了后面那个双引号原本的含义
        //把他变成了一个普普通通的双引号而已。
        System.out.println("\"");

        // \表示转义字符
        //两个\的理解方式:前面的\是一个转义字符,改变了后面\原本的含义,把他变成一个普普通通的\而已。
        System.out.println("c:Users\\moon\\IdeaProjects\\basic-code\\myapi\\src\\com\\itheima\\a08regexdemo\\RegexDemo1.java");


        //.表示任意一个字符
        System.out.println("你".matches("..")); //false
        System.out.println("你".matches(".")); //true
        System.out.println("你a".matches(".."));//true

        // \\d 表示任意的一个数字
        // \\d只能是任意的一位数字
        // 简单来记:两个\表示一个\
        System.out.println("a".matches("\\d")); // false
        System.out.println("3".matches("\\d")); // true
        System.out.println("333".matches("\\d")); // false

        //\\w只能是一位单词字符[a-zA-Z_0-9]
        System.out.println("z".matches("\\w")); // true
        System.out.println("2".matches("\\w")); // true
        System.out.println("21".matches("\\w")); // false
        System.out.println("你".matches("\\w"));//false

        // 非单词字符
        System.out.println("你".matches("\\W")); // true
        System.out.println("---------------------------------------------");
        // 以上正则匹配只能校验单个字符。


        // 必须是数字 字母 下划线 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必须是数字和字符 必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false


    }
}

正则表达式练习一(完成下列需求)

package RegexDemo;

public class Demo2 {
    public static void main(String[] args) {
        /**
         * 1 表示手机号码1开头
         * [3-9] 第二位应该是3-9
         * \d{9} 后面9为只要是数字即可
         */
        String regex1 = "1[3-9]\\d{9}";
        System.out.println("18832193758".matches(regex1));
        /*
        座机号码 020-2324242
        区号 0\\d{2,3}
            0 表示第一个数一定是0
            \\d{2,3} 表示区号从第二位开始可以是任意的数,可以出现2到3次
         -  这个-可以出现一次也可以不出现 加? -?
         号码 第一位不能是0 其他为可以随便 总长度 5-10位
         */
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));
        System.out.println("02032324242".matches(regex2));

        //邮箱
        /**
         * [email protected]
         *
         */

        String pegex3= "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("[email protected]".matches(pegex3));
    }
}

正则表达式插件:any-rule

练习二:

package RegexDemo;

public class Demo3 {
    public static void main(String[] args) {
        //用户名校验的正则表达式
        String regex = "\\w{4,16}";
        System.out.println("zhangsan".matches(regex));
        System.out.println("wangwu".matches(regex));

        //简易的身份证校验
//        "[1-9]\\d{16}(\\d|X|x)"
//        "[1-9]\\d{16}[\\d|X|x]"
//        "[1-9]\\d{16}[\\d[X[x]]]";
        String regex2 = "[1-9]\\d{16}[\\d[X[x]]]";
        System.out.println("111111111111111111".matches(regex2));
        System.out.println("11111111111111111x".matches(regex2));
        System.out.println("11111111111111111X".matches(regex2));

        //复杂身份证校验
        /**
         * 前6位:省份,市区,派出所等信息 第一位不能为0,后面五位是任意数字
         * [1-9]\\d{5}
         * 年的前半段 18 19 20
         * (18|19|20)
         * 年的后半段 任意数字出现两次
         * \\d{2}
         * 月份 01~09 10 11 12
         * (0[1-9]|1[0-2])
         * 日期 01-31
         * (0[1-9]|[12]\\d|3[01])
         * 后四位 任意数字出现3次,最后一位可以是数字也可以是大写或小写x
         *  \\d{3}(\\d|(?i)x)
         */
        String regex3 = "[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}(\\d|(?i)x)";
        System.out.println("130121434324339044397".matches(regex3));//乱输入的
    }
}

小结

爬虫练习一:

package RegexDemo;

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

public class Demo4 {
    public static void main(String[] args) {
        String str = "Java哈哈哈哈Java7你嫩嫩嫩Java17的得到Java17";
        //编写正则表达式定义爬取的规则
        Pattern p = Pattern.compile("Java\\d{0,2}");
        
        //创建一个文本匹配器
        Matcher m = p.matcher(str);

        while (m.find()){
            String group = m.group();
            System.out.println(group);
        }
    }
}
package com.itheima.a08regexdemo;

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

public class RegexDemo6 {
    public static void main(String[] args) {
        /* 有如下文本,请按照要求爬取数据。
                Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11,
                因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台
                要求:找出里面所有的JavaXX
         */

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


        //1.获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //2.获取文本匹配器的对象
        //拿着m去读取str,找符合p规则的子串
        Matcher m = p.matcher(str);

        //3.利用循环获取
        while (m.find()) {
            String s = m.group();
            System.out.println(s);
        }


    }

    private static void method1(String str) {
        //Pattern:表示正则表达式
        //Matcher: 文本匹配器,作用按照正则表达式的规则去读取字符串,从头开始读取。
        //          在大串中去找符合匹配规则的子串。

        //获取正则表达式的对象
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //获取文本匹配器的对象
        //m:文本匹配器的对象
        //str:大串
        //p:规则
        //m要在str中找符合p规则的小串
        Matcher m = p.matcher(str);

        //拿着文本匹配器从头开始读取,寻找是否有满足规则的子串
        //如果没有,方法返回false
        //如果有,返回true。在底层记录子串的起始索引和结束索引+1
        // 0,4
        boolean b = m.find();

        //方法底层会根据find方法记录的索引进行字符串的截取
        // substring(起始索引,结束索引);包头不包尾
        // (0,4)但是不包含4索引
        // 会把截取的小串进行返回。
        String s1 = m.group();
        System.out.println(s1);


        //第二次在调用find的时候,会继续读取后面的内容
        //读取到第二个满足要求的子串,方法会继续返回true
        //并把第二个子串的起始索引和结束索引+1,进行记录
        b = m.find();

        //第二次调用group方法的时候,会根据find方法记录的索引再次截取子串
        String s2 = m.group();
        System.out.println(s2);
    }
}

练习二

package com.itheima.a08regexdemo;

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

public class RegexDemo8 {
    public static void main(String[] args) {
        /*
            需求:把下面文本中的座机电话,邮箱,手机号,热线都爬取出来。
            来黑马程序员学习Java,
            手机号:18512516758,18512508907或者联系邮箱:[email protected],
            座机电话:01036517895,010-98951256邮箱:[email protected],
            热线电话:400-618-9090 ,400-618-4000,4006184000,4006189090

            手机号的正则表达式:1[3-9]\d{9}
            邮箱的正则表达式:\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}座机电话的正则表达式:θ\d{2,3}-?[1-9]\d{4,9}
            热线电话的正则表达式:400-?[1-9]\\d{2}-?[1-9]\\d{3}

        */

        String s = "来黑马程序员学习Java," +
                "电话:18512516758,18512508907" + "或者联系邮箱:[email protected]," +
                "座机电话:01036517895,010-98951256" + "邮箱:[email protected]," +
                "热线电话:400-618-9090 ,400-618-4000,4006184000,4006189090";

        System.out.println("400-618-9090");

        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})|" +
                "(400-?[1-9]\\d{2}-?[1-9]\\d{3})"; 

        //1.获取正则表达式的对象
        Pattern p = Pattern.compile(regex);

        //2.获取文本匹配器的对象
        //利用m去读取s,会按照p的规则找里面的小串
        Matcher m = p.matcher(s);
        //3.利用循环获取每一个数据 
        while(m.find()){
        String str = m.group();
        System.out.println(str);

    }
}
}

练习三:有条件的爬取

package RegexDemo;

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

public class Demo5 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11," +
                "因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台";
        //定义规则
        //需求一
        Pattern p1 = Pattern.compile("Java(?=8|11|17)");
        //需求二
        Pattern p2 = Pattern.compile("Java(?:8|11|17)");
        //需求三
        Pattern p3 = Pattern.compile("Java(?!8|11|17)");




        Matcher m = p3.matcher(str);
        while (m.find()){
            System.out.println(m.group());
        }

    }
}
package com.itheima.a08regexdemo;

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

public class RegexDemo9 {
    public static void main(String[] args) {
        /*
            有如下文本,按要求爬取数据。
                Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11,
                因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台


            需求1:爬取版本号为8,11.17的Java文本,但是只要Java,不显示版本号。
            需求2:爬取版本号为8,11,17的Java文本。正确爬取结果为:Java8 Java11 Java17 Java17
            需求3:爬取除了版本号为8,11.17的Java文本,
        */
        String s = "Java自从95年问世以来,经历了很多版本,目前企业中用的最多的是Java8和Java11," +
                "因为这两个是长期支持版本,下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台";

        //1.定义正则表达式
        //?理解为前面的数据Java
        //=表示在Java后面要跟随的数据
        //但是在获取的时候,只获取前半部分
        //需求1:
        String regex1 = "((?i)Java)(?=8|11|17)";
        //需求2:
        String regex2 = "((?i)Java)(8|11|17)";
        String regex3 = "((?i)Java)(?:8|11|17)";
        //需求3:
        String regex4 = "((?i)Java)(?!8|11|17)";

        Pattern p = Pattern.compile(regex4);
        Matcher m = p.matcher(s);
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

练习四:贪婪爬取和非贪婪爬取

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

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

Java中默认贪婪爬取。如果在数量词+ * 的后面加上问号,此时就是非贪婪爬取。

package RegexDemo;

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

public class Demo6 {
    public static void main(String[] args) {
        /*
            只写+和*表示贪婪匹配

            +? 非贪婪匹配
            *? 非贪婪匹配

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

            ab+:
            贪婪爬取:abbbbbbbbbbbb
            非贪婪爬取:ab
        */
        String s = "Java自从95年问世以来,abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "经历了很多版木,目前企业中用的最多的是]ava8和]ava11,因为这两个是长期支持版木。" +
                "下一个长期支持版本是Java17,相信在未来不久Java17也会逐渐登上历史舞台";
        //贪婪爬取
        String regex1 = "ab+";
        //非贪婪爬取
        String regex2 = "ab+?";

        Pattern p = Pattern.compile(regex2);
        Matcher m = p.matcher(s);

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


    }
}

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

package RegexDemo;

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

public class Demo7 {
    public static void main(String[] args) {
        String str = "小诗诗cscscwc323小圆圆efefef8848小芳芳";

        //定义正则表达式
        String s = str.replaceAll("[\\w&&[^_]]+", "vs");
        System.out.println(s);

        String[] split = str.split("[\\w&&[^_]]+");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }


    }
}
package com.itheima.a08regexdemo;

public class RegexDemo11 {
    public static void main(String[] args) {
        //public string replaceAll(string regex,string newstr) 按照正则表达式的规则进行替换
        //public string[] split(string regex): 按照正则表达式的规则切割字符串

        /*
            有一段字符串:小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
            要求1:把字符串中三个姓名之间的字母替换为vs
            要求2:把字符串中的三个姓名切割出来*/

        String s = "小诗诗dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
        //细节:
        //方法在底层跟之前一样也会创建文本解析器的对象
        //然后从头开始去读取字符串中的内容,只要有满足的,那么就用第一个参数去替换。
        String result1 = s.replaceAll("[\\w&&[^_]]+", "vs");
        System.out.println(result1);

        String[] arr = s.split("[\\w&&[^_]]+");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

分组

练习:捕获分组的练习

package RegexDemo;

public class Demo8 {
    public static void main(String[] args) {

                //需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
                //举例: a123a b456b 17891 &abc& a123b(false)
                // \\组号:表示把第X组的内容再出来用一次
                String regex1 = "(.).*\\1";
                System.out.println("a123a".matches(regex1));
                System.out.println("b456b".matches(regex1));
                System.out.println("17891".matches(regex1));
                System.out.println("&abc&".matches(regex1));
                System.out.println("a123b".matches(regex1));
                System.out.println("--------------------------");


                //需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
                //举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
                String regex2 = "(.+).*\\1";
                System.out.println("abc123abc".matches(regex2));
                System.out.println("b456b".matches(regex2));
                System.out.println("123789123".matches(regex2));
                System.out.println("&!@abc&!@".matches(regex2));
                System.out.println("abc123abd".matches(regex2));
                System.out.println("---------------------");

                //需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
                //举例: aaa123aaa bbb456bbb 111789111 &&abc&&
                //(.):把首字母看做一组
                // \\2:把首字母拿出来再次使用
                // *:作用于\\2,表示后面重复的内容出现日次或多次
                String regex3 = "((.)\\2).*\\1";
                System.out.println("aaa123aaa".matches(regex3));
                System.out.println("bbb456bbb".matches(regex3));
                System.out.println("111789111".matches(regex3));
                System.out.println("&&abc&&".matches(regex3));
                System.out.println("aaa123aab".matches(regex3));
            }
        }



练习:口吃替换

package RegexDemo;

public class Demo9 {
    public static void main(String[] args) {
        String str = "我要要学学学编编编编编程程";
        hh(str);
    }
    public static String hh(String str){
        //编写正则表达式
        //找同时出现多次的
        String s = str.replaceAll("(.)\\1+", "$1");
        System.out.println(s);
        return s;
    }
}
package com.itheima.a08regexdemo;

public class RegexDemo13 {
    public static void main(String[] args) {
        /*需求:
            将字符串:我要学学编编编编程程程程程程替换为:我要学编程
        */
        String str = "我要学学编编编编程程程程程程";

        //需求:把重复的内容 替换为 单个的
        //学学                学
        //编编编编            编
        //程程程程程程        程
        //  (.)表示把重复内容的第一个字符看做一组
        //  \\1表示第一字符再次出现
        //  + 至少一次
        //  $1 表示把正则表达式中第一组的内容,再拿出来用
        String result = str.replaceAll("(.)\\1+", "$1");
        System.out.println(result);



    }
}

非捕获分组特点:

不占用组号。

正则表达式小结:

标签:复习,matches,day18API,System,String,println,javase,public,out
From: https://blog.csdn.net/m0_72625929/article/details/141983141

相关文章

  • 指针(3)的期末复习
    1.字符指针变量在指针的类型中我们知道有⼀种指针类型为字符指针char*代码constchar*pstr="hellobit.";特别容易让同学以为是把字符串到字符指针pstr⾥了,但是本质是把字符串hellobit放hellobit.⾸字符的地址放到了pstr中。 #include<stdio.h>intmain......
  • C++复习day06
    一、内存管理1.课件上关于内存分配的题目intglobalVar=1;staticintstaticGlobalVar=1;voidTest(){staticintstaticVar=1;intlocalVar=1;intnum1[10]={1,2,3,4};charchar2[]="abcd";constchar*pChar3="abcd";int*ptr1=(in......
  • 1.Javase入门基础
    Javase入门基础1.会常用的dos命令2.会安装java所需要的环境(jdk)3.会配置java的环境变量4.知道java开发三步骤5.会入门程序6.会三种注释方式7.Java入门程序所需要注意的地方8.println和print区别一、算机编程核心语法(固定格式)数据类型、运算符、流程控制、数组、方法二、面向对象核......
  • 每天5分钟复习OpenStack(十五)Ceph与Bcache结合
    上一章我们成功部署了bcache,这一章我们将Ceph与Bcache结合来使用,使用Bcache来为ceph的数据盘提速。1ceph架构一个标准的ceph集群可能是如下的架构,SSD/NVME存储元数据,而SATA盘存储数据。这样的架构下,物理介质的SATA盘读写速率上限决定了存储集群Ceph的上限(木桶效应)。如果在......
  • C++复习day02
    一、库函数的模拟实现1.memcpy的使用和模拟首先先来了解一下memcpy函数的作用是什么?void*memcpy(void*destination,constvoid*source,size_tnum);函数memcpy从source的位置开始向后复制num个字节的数据到destination指向的内存位置。这个函数在遇到‘\0......
  • android kotlin基础复习—for while do...while
    1、新建一个文件kt:2、循环的几种用法:forwhiledo...whilefor:println("----for使用-----")valitems=listOf("apple","banana","kiwi")for(iteminitems){println(item)}for(indexinitems.indic......
  • CSP-J初赛知识点总复习( 3.3链式栈 3.4链式队列3.5链表习题)
    链式栈:(代码)#include<bits/stdc++.h>usingnamespacestd;//栈元素structStack{intdata;structStack*next;};Stack*top=NULL;//栈顶指针//入栈voidpush(intx){Stack*p=newStack;p->data=x;p->next=top;top=p;//修......
  • 关于指针问题的期末复习(1)
    可以去前面文章看看我的代码库哦,宝宝们1.内存和地址 内存单元的编号==地址==指针2.指针变量和地址(&)-取地址操作符 那我们通过取地址操作符(&)拿到的地址是⼀个数值,⽐如:0x006FFD70,这个数值有时候也是需要存储起来,⽅便后期再使⽤的,那我们把这样的地址存储在指针变量......
  • MySQL复习2
    高级查询准备createdatabasegreatselect;usegreatselect;droptableifexists`class`;createtable`class`(`cid`int(11)notnullauto_increment,`caption`varchar(32)notnull,primarykey(`cid`))engine=innoDBAUTO_INCREMENT=5de......
  • 操作符复习 看看你学会了吗?复习必备
    sizeof的应用判断输出值:#include<stdio.h>voidtest(intarr[]){   printf("%d\n",sizeofarr);}voidtry(charch[]){   printf("%d",sizeofch);}   intmain()   {      intarr[10]={0};      charch[10]={0}; ......