从零开始学Java-Day12

String

性能测试
- 使用String的 + 进行字符串拼接，效率比较低
- 使用StringBuilder/StringBuffer的 append 拼接效率高

package cn.tedu.api;
//本类用于字符串的拼接
public class TestString {
    public static void main(String[] args) {
        String s = "abcdefghijklmnopqrstuvwxyz";
       // method(s);
        method2(s);
    }

    private static void method2(String s) {
        //创建并使用可变字符序列对象
        StringBuilder sb = new StringBuilder();;
        StringBuffer sb2 = new StringBuffer();;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            sb.append(s);
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

//    public static void method(String s ){
//        String result = "";
//        long t1 = System.currentTimeMillis();
//        for (int i = 0; i < 10000; i++) {
//            result += s;
//        }
//        long t2 = System.currentTimeMillis();
//        long t = t2 - t1;
//        System.out.println(t);
//        System.out.println(result);
//    }
}

正则表达式（Matches）

作用：我们来定义一些规则，并校验指定的数据是否符合这样的规则
判断是否符合这个表达式:matcher()

package cn.tedu.api;

import java.util.Scanner;

//本类用于正则表达式的练习
public class TestRegex {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入身份证号码：");
        String IDCard = scanner.next();
        if (Method(IDCard)){
            System.out.println("输入格式正确");
        }else {
            System.out.println("输入格式错误");
        }
        scanner.close();
    }
    /*一个 \ 在程序中被认为是转义字符，需要写 \ 要在 \ 前在加一个 \*/
    private static boolean Method(String idCard) {
        String regex = "\\d{17}[\\dX]";
        if (idCard.matches(regex)){
            return true;
        }
            return false;
    }
}

包装类

对基本类型进行封装，提供一些其他功能
基本类型与包装类型的队形类型
Integer
1. 创建方式一：new Integer(1);没有高效的效果
2. 创建方式二：Integer.valueOf(1);有高效的效果，限制范围[-128~127]
TIPS：对于四种整形数据类型而言，都有缓存范围--- -128~127，在这个范围内的对象都是同一对象
Double
1. 创建方式一：new Double(1.0);没有高效的效果
2. 创建方式二：Double.valueOf(1.2);没有高效的效果

把字符串类型转成对应的包装类型方便参与计算

System.out.println(i2.parseInt("600") + 10.5);
System.out.println(d.parseDouble("2.5") + 1);

自动装箱：基本类型 ->包装类型

自动拆箱：包装类型 ->基本类型

package cn.tedu.api;
//本类用于测试自动装箱和自动拆箱
public class TestBox {
    public static void main(String[] args) {
        Integer a = 6;
        /*
        自动装箱：
            编译器会自动把int类型的127转换成Integer类型的127
            然后交给引用类型变量a来保存，自动装箱底层发生的代码：
            Integer.valueOf(127);注意方向：int -> Integer
         */
        System.out.println(a);
        /*自动拆箱
        编译器会把Integer类型的a中保存的6交给int类型的b来保存
        自动拆箱底层发生的代码：i.intValue();
         */
        int b = a;
        System.out.println(b);
    }
}

package cn.tedu.api;
//本类用于包装类的测试
public class TestNumber {
    static Integer i1;
    public static void main(String[] args) {
        System.out.println(i1);
        Integer i2 = new Integer(5);
        Integer i3 = new Integer(5);
        System.out.println(i2 == i3);
        System.out.println(i2);
        /*Integer使用valueOf创建方式有高效的效果，在-127~128范围内又高效的效果
        * 在有效范围内数据只会村一次，后续再存都是直接使用之前存过的数据
        * 超出范围没有高效效果*/
        Integer i4 = Integer.valueOf(127);
        Integer i5 = Integer.valueOf(127);
        System.out.println(i4 == i5);
        Integer i6 = Integer.valueOf(360);
        Integer i7 = Integer.valueOf(360);
        System.out.println(i6 == i7);
        System.out.println("==============================");
        //Double没有高效的效果
        Double d = new Double(3.2);
        Double d0 = new Double(3.2);
        System.out.println(d0 == d);
        System.out.println(d);
        Double d1 = Double.valueOf(0.01);
        System.out.println(d1);
        Double d2 = Double.valueOf(0.01);
        System.out.println(d1 == d2);
        System.out.println(d0 == d2);
        System.out.println(d0.equals(d));
        System.out.println(Integer.parseInt("600") + 10.5);
        System.out.println(Double.parseDouble("2.5") + 1);
    }
}

Decimal

浮点数运算不精确解决方案

创建工具类对象
- new BigDecimal (double参数)--传过来的参数是double类的不精确
- new BigDecimal (String参数)--可以精确运算
通过工具类对象进行四则运算、
- add/subtract/,utiply/divide
除法要设置保留位数和舍入方式

package cn.tedu.bigDecimal;

import java.math.BigDecimal;
import java.util.Scanner;

//本类用于计算浮点类不精确的问题
public class TestBigDecimal {
    public static void main(String[] args) {
        //f1();//暴露四则运算不精确问题
        f2();//浮点运算不精确问题解决方案
    }

    private static void f1() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要计算的两个小数");
        double a = scanner.nextDouble();
        double b = scanner.nextDouble();
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        scanner.close();
    }

    private static void f2() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要计算的两个小数");
        /*采用double类型传给BigDecimal
        * 的数据不精确要通过String传*/
        String a = scanner.next();
        String b = scanner.next();
        BigDecimal bigDecimal = new BigDecimal(a);
        BigDecimal bigDecimal2 = new BigDecimal(b);
        System.out.println(bigDecimal.add(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        /*除不尽的数无法精确展示，要设置保留的位数和舍入规则*/
        System.out.println(bigDecimal.divide(bigDecimal2,3,BigDecimal.ROUND_HALF_UP));
        scanner.close();
    }
}

IO

输入和输出

字符流（文件）和字节流（二进制）

流steam

流是单方向的
输入流只能输入in（读取），输出只能输出out(写出)
流只能从头到尾读取一次

流id分类

根据操作数据单位不同：字节流（二进制，所有文件）和字符流（字符，文本文件）
根据流的方向不同：输入流和输出流
组合情况：字节输入流字节输出流

字符输入流字符输出流

package cn.tedu.file;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

//本类用于测试文件类file
public class TestFile {
    public static void main(String[] args) throws IOException {
        File file = new File("d:\\x\\1.txt");
        System.out.println(file.length());//表示文件的大小
        System.out.println(file.exists());//判断文件是否存在
        System.out.println(file.isFile());//判断是否是一个正常的文件
        System.out.println(file.isDirectory());//判断是是文件夹
        System.out.println(file.getName());//获取文件的名字
        System.out.println(file.getParent());//获取该文件的父目录
        System.out.println(file.getAbsoluteFile());//获取该文件的绝对路径
        System.out.println(file.isHidden());//判断是否是隐藏文件
        System.out.println("==================");
        File file1 = new File("d:\\x\\m\\n\\v\\1.txt");
        //System.out.println(file1.createNewFile());//创造该文件
        //System.out.println(file1.mkdir());创造文件夹
        //System.out.println(file1.mkdirs());创造多重目录
        //System.out.println(file1.delete());删除该文件
        System.out.println("==================");
        file = new File("D:\\x");
        String[] list = file.list();//建立该目录下文件的数组
        System.out.println(Arrays.toString(list));//[1.txt, 2.txt, m]
        File[] files = file.listFiles();//建立目录下文件路径的数组
        System.out.println(Arrays.toString(files));//[D:\x\1.txt, D:\x\2.txt, D:\x\m]
        System.out.println(files[0].length());
    }
}

posted on 2021-06-16 19:06 无声specialweek 阅读(35) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

无声specialweek

从零开始学Java-Day12

String

正则表达式（Matches）

包装类

Decimal

IO

导航

公告