4.5～4.6·Java进阶内容

A宝呀

已于 2023-04-06 21:20:47 修改

阅读量80

点赞数 1

文章标签： java

于 2023-04-06 09:08:05 首次发布

本文链接：https://blog.youkuaiyun.com/m0_73254888/article/details/129981062

版权

常用API

Math

System

注:System.exit(0)代表JVM虚拟机正常停止，System.exit(1)代表JVM虚拟机异常停止哦

runtime

Object

1.本身是Java里面最顶层的类，一个类没有继承特定的类，那默认继承Object类，Object类只有无参构造方法，没有其他的构造方法

2.默认继承Object后，子类每调用自身的构造方法的时候就会先调用super()，也就是Object类的无参构造方法哦

3.当父类里面的方法到子类里面就不太好用的时候，我们可以对父类的方法进行重写哦

比如toString，equals方法等等（可以用快捷键完成哦）

Student.java

package myAPI;

public class Student{
    private String name;
    private int age;


    public Student() {
    }

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

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "{" +
            " name='" + getName() + "'" +
            ", age='" + getAge() + "'" +
            "}";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (age != other.age)
            return false;
        return true;
    }

}

test.java

package myAPI;

public class test{
    public static void main(String[] args) {
        Object obj = new Object();
        Student stu = new Student("wlc", 18);
        String str1 = stu.toString();

        // object类中的toString方法返回的是地址值
        // 如果我们打印一个对象，默认调用toString
        // 想要看到里面的属性值，就要重写toString方法
        // 在重写的方法中，把对象的属性值进行拼接就可以return啦
        System.out.println(stu);


        Student stu1 = new Student("w", 18);
        Student stu2 = new Student("w", 18);

        boolean result1 = stu1.equals(stu2);
        System.out.println(result1);
        
    }
}

equals的应用

package myAPI;

public class test{
    public static void main(String[] args) {
        String str = "abc";
        StringBuilder sb = new StringBuilder("abc");

        System.out.println(str.equals(sb));
        System.out.println(sb.equals(str));
    }
}

在String里面的equals方法的API形式如下哦

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        return (anObject instanceof String aString)
                && (!COMPACT_STRINGS || this.coder == aString.coder)
                && StringLatin1.equals(value, aString.value);
    }

1.先判断是不是同一个对象

2.在判断两个比较的对象是不是都是String类型的，如果不是就返回false，如果是的话就再执行下面的判断语句啦

然后第二题的话，我们要找StringBuilder里面的equals方法，但是它没有这个方法，那还可以被调用的话，那肯定是父类Object继承过来的呗，你现在又没有对这个类里面equals方法进行重写，那默认比较的就是这两个对象的地址值啦，而不是比较他们的属性值哦

Answer：false，false

浅克隆、深克隆

克隆对象实例

User.java

package myAPI;

import java.util.StringJoiner;

public class User implements Cloneable{
    private int id;
    private String username;
    private String password;
    private String path;        // 游戏图片
    private int[] data;         // 游戏进度

    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;
    }

    public int getId() {
        return this.id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPath() {
        return this.path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public int[] getData() {
        return this.data;
    }

    public void setData(int[] data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "{" +
            " id='" + getId() + "'" +
            ", username='" + getUsername() + "'" +
            ", password='" + getPassword() + "'" +
            ", path='" + getPath() + "'" +
            ", data='" + arrToString() + "'" +
            "}";
    }

    // 将对应地址下的数组显示出来
    public String arrToString(){
        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 {
        // TODO Auto-generated method stub
        return super.clone();
    }
}

test.java

package myAPI;

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] data = { 1, 2, 3, 4, 5 };
        User u1 = new User(1,"wlc", "123", "gril11", data);

        User u2 = (User) u1.clone();
        System.out.println(u1);
        System.out.println(u2);
    }
}

对象克隆（浅深克隆）

浅

深

package myAPI;

import com.google.gson.Gson;

public class test {
    public static void main(String[] args) throws CloneNotSupportedException {
        int[] data = { 1, 2, 3, 4, 5 };
        User u1 = new User(1,"wlc", "123", "gril11", data);

        // 这边的clone方法是浅拷贝
        User u2 = (User) u1.clone();
        System.out.println(u1);
        System.out.println(u2);

        // 利用外包来实现深拷贝，或者也可以自己去重写clone方法哦
        Gson gson = new Gson();
        gson.toJson(u1);
        // System.out.println(u1);
        String s = gson.toJson(u1);
        User u = gson.fromJson(s, User.class);
        System.out.println(s);
        System.out.println(u);
    }
}

clone()是浅克隆，要深克隆的话可以借助第三方类哦

Objects的成员方法

BigInteger

BigDecimal

正则表达式

验证手机号码 13112345678 13712345667 13945679027 139456790271

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

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

package com.itheima.a08regexdemo;

public class RegexDemo4 {
    public static void main(String[] args) {
        /*
            需求
            请编写正则表达式验证用户输入的手机号码是否满足要求。请编写正则表达式验证用户输入的邮箱号是否满足要求。请编写正则表达式验证用户输入的电话号码是否满足要求。
            验证手机号码 13112345678 13712345667 13945679027 139456790271
            验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434
            验证邮箱号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        */

        //心得:
        //拿着一个正确的数据，从左到右依次去写。
        //13112345678
        //分成三部分:
        //第一部分:1 表示手机号码只能以1开头
        //第二部分:[3-9] 表示手机号码第二位只能是3-9之间的
        //第三部分:\\d{9} 表示任意数字可以出现9次，也只能出现9次
        String regex1 = "1[3-9]\\d{9}";
        System.out.println("13112345678".matches(regex1));//true
        System.out.println("13712345667".matches(regex1));//true
        System.out.println("13945679027".matches(regex1));//true
        System.out.println("139456790271".matches(regex1));//false
        System.out.println("-----------------------------------");

        //座机电话号码
        //020-2324242 02122442 027-42424 0712-3242434
        //思路:
        //在书写座机号正则的时候需要把正确的数据分为三部分
        //一:区号@\\d{2,3}
        //      0:表示区号一定是以0开头的
        //      \\d{2,3}:表示区号从第二位开始可以是任意的数字，可以出现2到3次。
        //二:- ?表示次数，日次或一次
        //三:号码 号码的第一位也不能以日开头，从第二位开始可以是任意的数字，号码的总长度:5-10位
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));
        System.out.println("02122442".matches(regex2));
        System.out.println("027-42424".matches(regex2));
        System.out.println("0712-3242434".matches(regex2));

        //邮箱号码
        //3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        //思路:
        //在书写邮箱号码正则的时候需要把正确的数据分为三部分
        //第一部分:@的左边 \\w+
        //      任意的字母数字下划线，至少出现一次就可以了
        //第二部分:@ 只能出现一次
        //第三部分:
        //      3.1         .的左边[\\w&&[^_]]{2,6}
        //                  任意的字母加数字，总共出现2-6次(此时不能出现下划线)
        //      3.2         . \\.
        //      3.3         大写字母，小写字母都可以，只能出现2-3次[a-zA-Z]{2,3}
        //      我们可以把3.2和3.3看成一组，这一组可以出现1次或者两次
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));
        System.out.println("zhangsan@itcast.cnn".matches(regex3));
        System.out.println("dlei0009@163.com".matches(regex3));
        System.out.println("dlei0009@pci.com.cn".matches(regex3));


        //24小时的正则表达式
        String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
        System.out.println("23:11:11".matches(regex4));

        String regex5 = "([01]\\d 2[0-3])(:[0-5]\\d){2}";
        System.out.println("23:11:11".matches(regex5));
    }
}

爬虫

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

public class test{
    public static void main(String[] args) {
        String str = "wlcwlc43wlc2wlc3";

        // 编写正则表达式
        String regex = "wlc\\d{0,1}";
        // 得到正则表达式对象
        Pattern p = Pattern.compile(regex);
        // 获得文本匹配器的对象
        // 拿着m去读取str，找符合p规则的自串
        Matcher m = p.matcher(str);

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