正则表达式包装类自动装箱自动拆箱 BigDecimal

最新推荐文章于 2024-06-25 00:19:29 发布

睡不醒的小小秦

最新推荐文章于 2024-06-25 00:19:29 发布

阅读量468

点赞数

文章标签：正则表达式前端后端

本文链接：https://blog.csdn.net/weixin_43762083/article/details/122556992

版权

4 BigDecimal

BigDecimal：常用来解决精确的浮点数运算不精确的问题

4.1 创建对象

方式一 : BigDecimal(double val) 将double转换为BigDecimal,后者是double的二进制浮点值十进制表示形式,有坑! 方式二 : BigDecimal(String val) 将String类型字符串的形式转换为BigDecimal

4.2 常用方法

Add(BigDecimal bd) : 做加法运算 Subtract(BigDecimal bd) : 做减法运算 Multiply(BigDecimal bd) : 做乘法运算 Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常 Divide(BigDecimal bd,保留位数,舍入方式) : 除不尽时使用 setScale(保留位数,舍入方式) : 同上 pow(int n) : 求数据的几次幂

舍入方式解析 ROUND_HALF_UP 四舍五入,五入如:4.4结果是4; 4.5结果是5 ROUND_HALF_DOWN 五舍六入,五不入如:4.5结果是4; 4.6结果是5 ROUND_HALF_EVEN 公平舍入(银行常用) 比如:在5和6之间,靠近5就舍弃成5,靠近6就进位成6,如果是5.5,就找偶数,变成6 ROUND_UP 直接进位,不算0.1还是0.9,都进位 ROUND_DOWN 直接舍弃,不算0.1还是0.9,都舍弃 ROUND_CEILING(天花板) 向上取整,取实际值的大值朝正无穷方向round 如果为正数，行为和round_up一样，如果为负数，行为和round_down一样 ROUND_FLOOR(地板) 向下取整,取实际值的小值朝负无穷方向round 如果为正数，行为和round_down一样，如果为负数，行为和round_up一样

package cn.tedu.api;
import java.math.BigDecimal;
import java.util.Scanner;
public class TestBig {
    public static void main(String[] args) {
        System.out.println("请输入数据：");
        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();
        BigDecimal bd1 = new BigDecimal(a + "");
        BigDecimal bd2 = new BigDecimal(b + "");
        System.out.println(  bd1.add(bd2));
        System.out.println(bd1.subtract(bd2));
        System.out.println(bd1.multiply(bd2));
        System.out.println(bd1.divide(bd1, 3, BigDecimal.ROUND_HALF_UP));
    }
}

package cn.tedu.api;
import java.math.BigDecimal;
import java.util.Scanner;
/***
 * 本类用于解决浮点数不精确的问题
 */
public class TestBigDecimal {
    public static void main(String[] args) {
       // f1();//使用普通的+ -* /四则运算，暴露浮点数运算不精确的问题
        f2();//使用BigDecimal解决浮点数运算不精确的问题
    }
//本方法用来解决浮点数运算不精确问题
    private static void f2() {
        //1.提示并输入用户输入的两个小数
        System.out.println("请输入要计算的两个小数：");
        double a=new Scanner(System.in).nextDouble();
        double b=new Scanner(System.in).nextDouble();
        //2.创建工具类的对象,把基本类型的a与b交给工具类对象来保存
        /**
         * 最好不要使用double作为构造函数的参数类型，推荐使用String类型参数，
         * double转String,直接拼个空串就可以
         */
        BigDecimal bd1 = new BigDecimal(a+"");//最快的方式，在后面加上空字符串，如果是double报错
        BigDecimal bd2 = new BigDecimal(b+"");
        //3.1定义变量保存结果，通过BigDecimal提供的方法进行运算
        BigDecimal bd3= bd1.add(bd2);//做加法运算
        System.out.println(bd3);
        BigDecimal subtract = bd1.subtract(bd2);//做减法运算
        System.out.println(subtract);
        BigDecimal multiply = bd1.multiply(bd2);//做乘法运算
        System.out.println(multiply);

//        BigDecimal divide = bd1.divide(bd2);所以一般不用这个
//        System.out.println(divide);//ArithmeticException,算数异常，1/0.3
        /**
         * divide（）在除不尽时候。会抛出算数异常，因为没有办法精确表示结果
         * 解决方案：需要额外设置除不尽时的保留位数和舍入位数
         * divide（a，b，c）
         * a是指要除哪个数字，b是指保留位数，c是指舍入位数
         */
        BigDecimal divide = bd1.divide(bd2, BigDecimal.ROUND_HALF_UP);
        System.out.println(divide);

    }

    private static void f1() {
        //1.提示并输入用户输入的两个小数
        System.out.println("请输入要计算的两个小数：");
        double a=new Scanner(System.in).nextDouble();
        double b=new Scanner(System.in).nextDouble();
        //2.做运算
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
    }
}

3 自动装箱和自动拆箱

3.1 概述

自动装箱：把基本类型包装成对应的包装类型的过程 Integer a = 5;//a是引用类型，引用了包装对象的地址。编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);

自动拆箱：从包装类型的值，自动变成基本类型的值 int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。编译器会完成自动拆箱：int i = a.intValue();

package cn.tedu.api;
/**
 * 本类用于测试自动装箱与自动拆箱
 */
public class TestBox {
    public static void main(String[] args) {
        //1.定义包装类integer对象,两种创建方式
        Integer i1 = new Integer(127);
        Integer i2 = Integer.valueOf(127);
        /**
         * 1.自动装箱现象
         * 编译器会自动把基本类型int 127，包装成包装类integer
         * 然后交给integer类型的变量i3来保存，底层发生的代码：integer.valueof（127）
         * 自动装箱的方向：int【基本类型】->integer【包装类型】
         */
        Integer i3 = 127;
        int i4 = i3;
        /**
         * 包装类型给基本类型，自动拆箱，编译器会自动把包装类型i3拆掉箱子，变回基本类型的数据127
         * 然后交给基本类型的类型变量i4来保存，底层发生的代码：i3.intValue（）
         * 自动拆箱的方向：integer[包装类型]->int【基本类型】
         */

    }
}

package cn.tedu.api;
/**
 * 本类用于测试包装类
 */
public class TestNumber {
    //integer放了-128到127
    //1.定义成员变量，注意要设置成静态的，因为静态只能调用静态
     static String io;
    public static void main(String[] args) {
        //2.打印integer的默认值测试：引用类型的默认值都是null
        System.out.println(io);//null
        //3.创建int类型对应的包装类型Integer对象
        Integer i1 = new Integer(5);
        Integer i11 = new Integer(5);
        System.out.println(i1==i11);//false
        /**
         * integer对象创建方式2有一个高效的效果，但是要求：
         * 1.是integer类型
         * 2.使用valueof（）的创建方式
         * 3.数据在-128~127范围内
         * 只要满足以上3个条件，相同的数据只会存一次，后续再存都是使用之前创建好的数据
         */
        //3.2创建int类型对应的包装类型integer对象 -- 方式二
        Integer i2 = Integer.valueOf(127);
        Integer i22 = Integer.valueOf(127);
        Integer i3=Integer.valueOf(300);
        Integer I33= Integer.valueOf(300);
        System.out.println(i1==i2);//false
        System.out.println(i2==i22);//true
        System.out.println(i3==I33);//false 300不在范围内


        //4.创建double包装类对象
        Double D1=new Double(3.14);
        Double d11=new Double(3.14);
        System.out.println(D1==d11);//false
        /**
         * 只有integer才有高效的效果，double是没有的
         */
        Double S1=Double.valueOf(3.14);
        Double s2=Double.valueOf(3.14);
        System.out.println(S1==s2);//false
        //把String类型的数据转为int类型的数据
        System.out.println(i1.parseInt("800")+10);//810
        System.out.println(D1.parseDouble("2.2")+3.3);//5.5
    }
}

1 正则表达式Regex

1.1 概述

正确的字符串格式规则。常用来判断用户输入的内容是否符合格式的要求，注意是严格区分大小写的。

1.2 常见语法

在这里插入图片描述

1.3 String提供了支持正则表达式的方法

Matches(正则) : 当前字符串能否匹配正则表达式 replaceAll(正则,子串) : 替换子串 split(正则) : 拆分字符串

package cn.tedu.api;
import java.util.Scanner;
/**
 *本类用于测试正则表达式
 * 需求：接收用户输入的身份证号，判断用户输入的数据是否正确
 */
public class TestRegex {
    public static void main(String[] args) {
        //1.编辑正则表达式
        //身份证号的规律：一共是18位，前17位是数字，有可能是"x"
        String regex="[0-9]{17}[0-9X]";
        //2.定义变量用于接收用户输入的身份证号
        String input;
        //3.判断用户输入的数据是否符合正则表达式
        do {
            System.out.println("请您输入身份证号:");
            input=new Scanner(System.in).nextLine();
            if(input.matches(regex)){
                System.out.println("恭喜您输入正确");
                return;//结束本方法
            }
        }while (!input.matches(regex));
    }
}

package cn.tedu.api;
import java.util.Scanner;
/**
 * 本类用于复写身份证号验证案例
 */
public class TestRegex2 {
    public static void main(String[] args) {
       //1.定义正则表达式
       String regex="[0-9]{17}[0-9X]";
       //单个\在java中有特殊的含义，表示转义符号，不认为这是一个单纯的斜杠
        //所以，如果想要单纯的表示斜杠，需要在它的前面再加上一个斜杠用来转义
        //也就是\\才单纯的表示为一个斜杠
       String regex2="\\d{17}[0-9X]";
       //判断用户输入的数据是否正确
        System.out.println("请输入身份证号：");
        String input=new Scanner(System.in).nextLine();
        if(input.matches(input)){
            System.out.println("输入正确");
        }else{
            System.out.println("输入错误");
        }
    }
}

5 StringBuilder/StringBuffer

5.1 特点

封装了char[]数组
是可变的字符序列
提供了一组可以对字符内容修改的方法
常用append()来代替字符串做字符串连接”+”
内部字符数组默认初始容量是16：super(str.length() + 16);
如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全

5.2 常见方法

append()

package cn.tedu.api;
/**
 * 本类用于测试字符串的拼接
 * 使用操作字符串的方法还是用String的api
 * 拼接字符串用StringBuffer或StringBuilder
 */
public class TestString3 {
    public static void main(String[] args) {
        //需求：将26个字母拼接10000次
        String s = "abcdefghijklmnopqrstwuvxyz";
//        Method1(s);
        Method2(s);//用来测试StringBuilder或者StringBuffer的字符串拼接
    }
    private static void Method2(String s) {
        //创建工具类对象
//        StringBuffer sb=new StringBuffer();
        StringBuilder sb1=new StringBuilder();
        long t1 = System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            sb1.append(s);//拼接字符串
        }
        //3.输出拼接的效果
        System.out.println(sb1);
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }

    //使用方式一拼接字符串
    //5.1获取循环开始时间
    private static void Method1(String s) {
        //开始拼接之前的时间
        long l = System.currentTimeMillis();
        //1.创建一个变量用来保存最终拼接好的效果
        String result=" ";
        for (int i = 0; i <10000; i++) {
             i++;
             result+=s;
        }
        //打印结束之后的时间
        long l1 = System.currentTimeMillis();
        //打印拼接花费的时间
        System.out.println(l1-l);
        System.out.println(result);
    }
}

3 File文件类

3.1概述

封装一个磁盘路径字符串,对这个路径可以执行一次操作可以封装文件路径、文件夹路径、不存在的路径

3.2创建对象

File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例 new File(“d:/abc/a.txt”); new File(“d:/abc”,”a.txt”);

3.3常用方法

在这里插入图片描述

package cn.tedu.file;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.创建file类的对象
        /**
         * 1.ready文件夹与1.txt需要自己手动创建
         * 2.File需要导包：import java.io.File;
         * 3.路径pathname是String类型的数据，必须手写正确，不然找不到文件报错
         * 4.完整的文件名包含两部分，文件名+后缀名
         */
        File file = new File("D:\\ready\\1.txt");
        //2.1测试file类的常用方法
        System.out.println(file.length());//10文件夹里的数据是abcdodaska,所以打印10字节
        System.out.println(file.isDirectory());//false，判断当前file对象是一个文件夹吗
        System.out.println(file.isFile());//true，判断当前file对象是一个文件吗？
        System.out.println(file.getName());//1.txt
        System.out.println(file.getParent());//D:\ready
        System.out.println(file.getAbsolutePath());//D:\ready\1.txt,完完全全的完整路径
        System.out.println(file.exists());//true,判断当前file对象指定的路径是否存在
        //2.2测试file的创建与删除
        /**
         * new 只会帮我妈在内存中创建一个file类型的对象
         * 并不会帮我们在磁盘对应的路径下创建一个真实存在的2.txt
         */
        File file2 = new File("D:\\ready\\2.txt");//不存在的路径
        /*创建一个之前不存在不的文件2.txt，如果创建成功会返回true
        * 如果指定创建文件的路径不对，会抛出异常，ioexception，所以需要提前处理这个问题，我们
        * 暂时选择在main()上抛出，这个io异常是我们目前遇到的强制要求必须预先处理的异常，
        * 如果不处理，方法调用会报错，通不过编译*/
        System.out.println(file2.createNewFile());//true,在目录下有2.txt文件

        /*创建当前不存在的单层文件*/
        File file3 = new File("D:\\ready\\n");
        System.out.println(file3.mkdir());//true

        /*创建当前不存在的多层文件夹*/
        File file4 = new File("D:\\ready\\a\\b\\c");
        System.out.println(file4.mkdirs());//true
        /*delete()方法只能删除文件或者空的文件夹*/
        System.out.println(file2.delete());//true
        System.out.println(file4.delete());//true

        //2.3展示文件
        File file1 = new File("D:\\ready");
        String[] list = file1.list();
        System.out.println(Arrays.toString(list));//[1.txt, a, n]
        /*绝对路径，常用这种方法*/
        File[] fs = file1.listFiles();
        System.out.println(Arrays.toString(fs));//[D:\ready\1.txt, D:\ready\a, D:\ready\n]
    }
}