12.Object类、System类、包装类、Math类、Calendar类、正则表达式

兮寒wr

已于 2024-04-29 14:23:06 修改

阅读量1.2k

点赞数 32

分类专栏： 393 文章标签： java 开发语言

于 2024-04-25 10:15:20 首次发布

本文链接：https://blog.csdn.net/weixin_50975714/article/details/138181211

版权

393 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Object类

protected Object clone()

创建并返回此对象的副本。

boolean equals(Object obj)

指示一些其他对象是否等于此。

protected void finalize()

当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。

类<?> getClass()

返回此 Object的运行时类。

int hashCode()

返回对象的哈希码值。

String toString()

返回对象的字符串表示形式。

package com.day12.object1;

public class Person implements Cloneable{
    String name;
    int age;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("当对象被JVM垃圾回收器回收的时候，可能会执行这个方法，不一定100%执行");
    }
}

package com.day12.object1;

public class ObjectDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        person.name="jack";
        person.age=20;
        //获取类对象，输出类的全类名
        System.out.println(person.getClass());
        //克隆出来的对象只是克隆了对象的属性值，不会克隆对象的地址值
        Person o1 = (Person) person.clone();
        System.out.println(o1);

        //System.err.println(o1);//输出的是提示的错误信息

        System.out.println(person==o1);//false
        System.out.println(person.equals(o1));//false

        System.out.println(person.getClass()==o1.getClass());//true
    }

}

System类

static PrintStream err

“标准”错误输出流。

static InputStream in

“标准”输入流。

static PrintStream out

“标准”输出流。

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

将指定源数组中的数组从指定位置复制到目标数组的指定位置。

static long currentTimeMillis()

返回当前时间（以毫秒为单位）。

static void exit(int status)

终止当前运行的Java虚拟机。

static void gc()

运行垃圾回收器。

package com.day12.system1;

import com.day12.object1.Person;

public class SystemDemo {
    public static void main(String[] args) {
        //System.arraycopy();

        //System.out.println("hello");
        //System.exit(0);
       // System.out.println("java");


        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        //new出来的对象，如果不将对象的引用赋值给某个变量
        //那么这个对象会被JVM当作一个垃圾对象
        //将来执行gc的时候，就会回收这个对象
        //对象被回收了，可能会执行finalize()方法
        System.gc();//执行回收
    }
}

包装类

Java为了解决基本数据类型没有方法可以使用的问题，给每个基本数据类型，都提供了一个包装类型

包装类也就是基本数据类型对应的对象

将来集合中，只能存放对象的，不能存放基本数据类型，所以也需要通过包装类来将基本数据类存入集合中

byte ==> Byte

short ==> Short

int ==> Integer

long ==> Long

float ==> Float

double ==> Double

char ==> Character

boolean ==> Boolean

包装类通用的方法

1.xxxValue() 方法，包装类型转为基本类型

比如：Integer中的 byte byteValue() 返回此值 Integer为 byte的基本收缩转换后。

2.toString()方法，将包装对象以字符串的形式展示

3.类名.valueOf()：valueOf()是一个静态方法，将值转为对应的包装类型

valueOf()传入对应的基本类型值作为参数

Character()的valueOf()方法不能传入字符串类型作为参数

4.parseXXX()方法，把参数的转为对应的基本类型

Character类型没有这个方法

package com.day12.baozhuannglei;

public class Demo01 {
    public static void main(String[] args) {
        //怎么去构建包装类对象？
        //通过构造方法，包装类的构造方法的使用
        //   byte ==> Byte
        //Byte(byte value)
        //构造一个新分配的 Byte对象，该对象表示指定的 byte值。
        //Byte(String s)
        //构造一个新分配 Byte对象，表示 byte由指示值 String参数。
        Byte b1 = new Byte((byte) 100);
        Byte b2 = new Byte("100");
        System.out.println(b1);
        System.out.println(b2);
        //   short ==> Short
        //Short(short value)
        //构造一个新分配的 Short对象，表示指定的 short值。
        //Short(String s)
        //构造一个新分配 Short对象，表示 short由指示值 String参数。
        Short s1 = new Short((short) 200);
        Short s2 = new Short("200");
        //   int ==> Integer
        //Integer(int value)
        //构造一个新分配的 Integer对象，该对象表示指定的 int值。
        //Integer(String s)
        //构造一个新分配 Integer对象，表示 int由指示值 String参数。
        Integer i1 = new Integer(300);
        Integer i2 = new Integer("300");
        //   long ==> Long
        Long l1 = new Long(1000L);
        Long l2 = new Long("1000");
        //   float ==> Float
        Float f1 = new Float(3.14f);
        Float f2 = new Float("3.14");
        //   double ==> Double
        Double d1 = new Double(5.12);
        Double d2 = new Double("5.12");
        //   char ==> Character
        Character ch1 = new Character('a');
            //Character character = new Character("a");
        //   boolean ==> Boolean
        Boolean bl1 = new Boolean(true);
        Boolean bl2 = new Boolean("true");

        //包装类通用的方法
        ///1.xxxValue() 方法，包装类型转为基本类型
        //比如：Integer中的 byte  byteValue() 返回此值 Integer为 byte的基本收缩转换后。
        //Integer -> int
        int i=i1.intValue();
        //Boolean -> boolean
        boolean b3=bl1.booleanValue();
        //Character -> char
        char ch3=ch1.charValue();

        //2.toString()方法 ，将包装对象以字符串的形式展示
        String s3=bl1.toString();
        String s4=ch1.toString();

        //3.类名.valueOf()：valueOf()是一个静态方法，将值转为对应的包装类型
        //valueOf()传入对应的基本类型值作为参数
        Integer i4=Integer.valueOf(100);
        Boolean bl4=Boolean.valueOf(true);
        Character ch4=Character.valueOf('a');
        //valueof()，传入字符串类型作为参数
        //Character()的valueOf()方法不能传入字符串类型作为参数
        Integer i5=Integer.valueOf("100");
        Float f3=Float.valueOf("3.12");
        //Character a=Character.valueOf("a");

        //4.parseXXX()方法，把参数的转为对应的基本类型
        //Character类型没有这个方法
        int i3=Integer.parseInt("100");
        float f=Float.parseFloat("5.67");
        boolean bl5=Boolean.parseBoolean("true");
    }
}

Integer类

static int max(int a, int b)

返回两个 int的较大值，就像调用 Math.max一样。

static int min(int a, int b)

返回两个 int的较小值，就像调用 Math.min一样。

static String toBinaryString(int i)

在基数2中返回整数参数的字符串表示形式为无符号整数。

static String toHexString(int i)

返回整数参数的字符串表示形式，作为16位中的无符号整数。

static String toOctalString(int i)

在基数8中返回整数参数的字符串表示形式为无符号整数。

装箱和拆箱

装箱指的是，将基本类型转为包装类型

拆箱指的是，将包装类型转为基本类型


package com.day12.baozhuannglei;

public class Demo02 {
    public static void main(String[] args) {
        //装箱和拆箱
        //装箱指的是，将基本类型转为包装类型
        //拆箱指的是，将包装类型转为基本类型
        
        //自动装箱
        //基本类型的值可以直接赋值给对象
        Integer i1=100;
        //Integer integer = new Integer(100);
        Boolean b1=true;
        Float f1=2.35f;

        //自动拆箱
        //把引用类型直接赋值给基本类型
        int i2=i1;
        //int i = i1.intValue();\

        //Integer类的其他方法
        int max=Integer.max(5,3);
        System.out.println(max);

        //static String toBinaryString(int i)
        //在基数2中返回整数参数的字符串表示形式为无符号整数。
        System.out.println(Integer.toBinaryString(100));
        //static String toHexString(int i)
        //返回整数参数的字符串表示形式，作为16位中的无符号整数。
        System.out.println(Integer.toHexString(100));
        //static String toOctalString(int i)
        //在基数8中返回整数参数的字符串表示形式为无符号整数。
        System.out.println(Integer.toOctalString(100));

        //int和String的互相转换
        //int -> String
        int num=100;
        //1.String.valueOf()
        String s = String.valueOf(num);
        //2.字符串拼接
        String s1 = "" + num;
        //3.int->Integer->String
        Integer integer = new Integer(num);
        String s3=integer.toString(num);
        //4.Integer.toString(int i)
        String s4 = Integer.toString(num);

        //String -> int
        String ss="100";
        //1.Integer.parseInt(String s)
        int i = Integer.parseInt(ss);
        //2.String->Integer->int
        Integer integer1 = new Integer(ss);
        int i3 = integer1.intValue();

        //Integer值比较问题
        //Integer中，存在一个数值缓冲区，-128~127之间的值
        //如果直接拿去，就是从缓冲区拿的，比较是相等的
        Integer ii1 = new Integer(100);
        Integer ii2 = new Integer(100);
        System.out.println(ii1==ii2);//false
        System.out.println(ii1.equals(ii2));//true

        Integer num1=100;
        Integer num2=100;
        System.out.println(num1==num2);//true

        Integer num3=200;
        Integer num4=200;
        System.out.println(num3==num4);//false

    }
}

Character类

static boolean isDigit(char ch)

确定指定的字符是否是数字。

static boolean isLowerCase(char ch)

确定指定的字符是否是小写字符。

static boolean isUpperCase(char ch)

确定指定的字符是否是大写字符。


package com.day12.baozhuannglei;

public class Demo03 {
    public static void main(String[] args) {
        //求一段字符串fshgdyWWQ12Pjdu123FGmn中
        //有多少个大写、小写字母，数字
        //拿到每个字符
        String s="fshgdyWWQ12Pjdu123FGmn";
        int numCount=0;
        int smallCount=0;
        int bigCount=0;
        for (int i = 0; i < s.length(); i++) {
            char c=s.charAt(i);
            //判断字符
            if(Character.isDigit(c)){//如果是数字
                numCount++;
            }else if(Character.isLowerCase(c)){//如果是小写字母
                smallCount++;
            }else if(Character.isUpperCase(c)){//如果是大写字母
                bigCount++;
            }
        }
        System.out.println("数字："+numCount+"，小写："+smallCount+",大写："+bigCount);
    }
}

Boolean类

Math类


package com.day12.baozhuannglei;

public class MathDemo {
    public static void main(String[] args) {
        //Math计算
        //abs()   返回绝对值。
        System.out.println(Math.abs(-10));
        //static double   ceil(double a)
        //返回大于或等于参数的最小（最接近负无穷大） double值，等于一个数学整数。
        System.out.println(Math.ceil(3.56));//向上取整 4.0

        //static double   floor(double a)
        //返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数。
        System.out.println(Math.floor(3.56));//向下取整 3.0

        System.out.println(Math.max(10,20));//最大值 20

        System.out.println(Math.min(10,20));//最小值 10

        System.out.println(Math.pow(2,5));//幂值 32.0

        System.out.println(Math.random());//[0,1)随机数
        //求10-20之间的随机数，包含10 不包含20
        System.out.println(Math.random()*10+10);
        //求10-20之间的随机数，包含10 包含20
        System.out.println(Math.random()*11+10);

        System.out.println(Math.round(3.58));//四舍五入 4

        System.out.println(Math.sqrt(144));//平方根 12.0
    }
}

Random类

package com.day12.baozhuannglei;

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        //Random
        Random random = new Random();//无参构造
        Random random1 = new Random(100);//有参构造
        //常用的方法 nextInt()
        System.out.println(random.nextInt());
        System.out.println(random1.nextInt());

        // nextInt(int i) : i值表示随机的范围
        System.out.println(random.nextInt(100));
        System.out.println(random1.nextInt(100));
    }
}

String类
字符串缓冲区（字符串常量池）

当声明了字符串之后，会将这个字符串常量值，存放在内存堆的字符常量池中，如果下次继续使用这个字符串，就直接拿去这个值

如果使用new的话，会先将字符常量串值的引用放在堆中，所以比较的时候是false

如果在表达式中，直接拼接字符串，JVM会将拼接好的字符串存入字符串常量池，

如果拼接好的字符串常量池已经存在，那就用存在的

以引用的方式拼接，拼接的都是单独的引用

package com.day12.baozhuannglei;

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

        //当声明了字符串之后，会将这个字符串常量值，存放在内存堆的字符常量池中，
        //如果下次继续使用这个字符串，就直接拿去这个值
        //如果使用new的话，会先将字符常量串值的引用放在堆中，所以比较的时候是false

        //如果在表达式中，直接拼接字符串，JVM会将拼接好的字符串存入字符串常量池，
        //如果拼接好的字符串常量池已经存在，那就用存在的

        //以引用的方式拼接，拼接的都是单独的引用
        String s1="helloworld";
        String s2 = new String("helloworld");
        String s3="hello"+"world";
        String s4="hello";
        String s5="world";
        String s6=s4+s5;

        System.out.println(s1==s2);//false
        System.out.println(s1==s3);//true
        System.out.println(s1==s6);//false
        System.out.println(s1==(s4+s5));//false
        System.out.println(s6==(s4+s5));//false
    }
}

Date类

package com.day12.baozhuannglei;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //Date和String类型的相互转换
        Date date = new Date();//当前时间的date对象

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //日期==>字符串
        String s=sdf.format(date);
        System.out.println(s);

        //字符串==>日期
        String s1="2000-10-10";
        Date date1 = sdf.parse(s1);
        System.out.println(date1);

        //日期类型可以获取对应日期的毫秒值
        long time = date1.getTime();
        System.out.println(time);


    }
}

Calendar类

获取年月日等信息

int get(int field)

返回给定日历字段的值。

获取日历类对象

static Calendar getInstance()

使用默认时区和区域设置获取日历。

void setTime(Date date)

使用给定的 Date设置此日历的时间。

abstract void add(int field, int amount)

根据日历的规则，将指定的时间量添加或减去给定的日历字段。

package com.day12.baozhuannglei;

import java.util.Calendar;
import java.util.Date;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar calendar = Calendar.getInstance();

        //获取年月日
        System.out.println(calendar.get(1));
        System.out.println(calendar.get(Calendar.YEAR));//年
        System.out.println(calendar.get(Calendar.MONTH)+1);//月
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//日

        System.out.println(calendar.get(Calendar.HOUR_OF_DAY));//时
        System.out.println(calendar.get(Calendar.MINUTE));//分
        System.out.println(calendar.get(Calendar.SECOND));//秒

        System.out.println(calendar.get(Calendar.DAY_OF_WEEK)-1);//周几

        //给日历类加个时间  add(添加类型 值)
        calendar.add(Calendar.YEAR,2);//两年后
        System.out.println(calendar.get(Calendar.YEAR));

        calendar.add(Calendar.MONTH,3);
        System.out.println(calendar.get(Calendar.YEAR));//年
        System.out.println(calendar.get(Calendar.MONTH)+1);//月

        //以指定日期，设置日历 setTime(Date date)
        Date date = new Date(971107200000L);
        calendar.setTime(date);
        System.out.println(calendar.get(Calendar.YEAR));//年
        System.out.println(calendar.get(Calendar.MONTH)+1);//月
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//日

    }
}

练习

package com.day12.baozhuannglei;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) throws ParseException {
        //已知停车位，8：00-20：00 每15分钟1元，不足15分钟算15分钟
        // 其他时间，每半小时0.5元不足半小时算半小时
        //设计一个计算程序，可以接受用户的开始时间和结束时间，计算用车的费用
        //计算9：35-15：15停车费用

        //接受用户输入时间
        Scanner sc = new Scanner(System.in);
        System.out.println("存车时间：yyyy-MM-dd hh:mm:ss");
        String s1=sc.nextLine();
        System.out.println("取车时间：yyyy-MM-dd hh:mm:ss");
        String s2=sc.nextLine();
        //把输入内容转为date
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

        Date t1 = sdf.parse(s1);
        Date t2 = sdf.parse(s2);

        //获取日历对象,分别设置日历对象的日期
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        //设置日历的时间
        c1.setTime(t1);
        c2.setTime(t2);

        int startHour=c1.get(Calendar.HOUR_OF_DAY);
        int startMinute=c1.get(Calendar.MINUTE);

        int endHour=c2.get(Calendar.HOUR_OF_DAY);
        int endMinute=c2.get(Calendar.MINUTE);
        //计算时间差 9：35-15：15  435-95=340
        int allMinutes=((endHour-8)*60+endMinute)-((startHour-8)*60+startMinute);
        //计算价格
        double money=Math.ceil(allMinutes/15.0)*1;
        System.out.println("停车费用："+money);
    }
}

正则表达式

Java中的正则，表示的是符合一定规则的字符串，用来限定一些字符串的格式、内容

1.字符格式

a 表示匹配a

[abc] 表示匹配abc

[^abc] 表示匹配abc以外的内容

[a-z] 表示匹配小写字母

[A-Z] 表示匹配大写字母

[0-9] 表示匹配0-9之间的数字

[a-zA-Z0-9] 表示匹配任意的大小写字母、数字

2.匹配次数

{n} 匹配n次

{n,m} 匹配n-m次

{n,} 最少匹配n次

? 1次或0次

* 0次或多次

+ 一次或多次

3.通配符

\ 转义符，将特殊含义的字符转义为本身的含义

^[] 以指定内容开头

[]$ 以指定内容结尾

\w 代表任意字符[a-zA-Z0-9]

\d 代表任意数字[0-9]

. 表示任意字符

\b 匹配单词边界

package com.day12.baozhuannglei;

import java.util.Scanner;

/*
正则表达式
 */
public class Demo06 {
    public static void main(String[] args) {
        //写一个正则表达式来验证用户输入的手机号码是否符合规范
        //11位 以1开头 3-9出现在第二位  0-9出现9次
        //        String regex="^[1][3-9][0-9]{9}";
        //        Scanner sc = new Scanner(System.in);
        //        System.out.println("请输入手机号：");
        //        String number=sc.next();
        //        //调用matches()方法去匹配正则表达式
        //        boolean b1 = number.matches(regex);
        //        System.out.println(b1);

        //邮箱的正则
        //1313515@qq.com
        //abcd123@163.com
        //addsf@sina.com

        String regex1="[a-z0-9A-Z]{4,20}@[a-z0-9A-Z]{2,10}(\\.[a-z]{2,3}){1,2}";
        String regex2="\\w+@\\w{2,10}(\\.\\w{2,3})+";
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入邮箱：");
        String email=sc.next();
        //调用matches()方法去匹配正则表达式
        boolean b2 = email.matches(regex1);
        System.out.println(b2);
        boolean b3 = email.matches(regex2);
        System.out.println(b3);
    }
}

package com.day12.baozhuannglei;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo07 {
    public static void main(String[] args) {
        String s="hello world java mysql spring oracle linux";

        //        String[] s2 = s.split(" ");
        //        System.out.println(Arrays.toString(s2));
        //        System.out.println(s2[2].length());

        //找出字符串中5个长度的字符串
        String regex="\\b\\w{5}\\b";
        //写一个正则后，把正则转为一个Pattern对象
        Pattern pattern = Pattern.compile(regex);
        //通过Pattern对象，匹配字符，将字符串中，符合条件的信息返回
        Matcher matcher = pattern.matcher(s);

        //        boolean b = matcher.find();
        //        String s1 = matcher.group();
        //        System.out.println(s1);

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