Day12
正则表达式Regex
正确的字符串格式规则。
作用：我们来定义一些规则，并校验指定的数据是否符合这样的规则
1.定义一个正则表达式：String regex = “我们定义要匹配的规则”
2.判断是否符合这个表达式：matches（）
package cn.tedu.api;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import java.util.Scanner;
import java.util.regex.Matcher;
//正则表达式
public class TestRegex {
public static void main(String[] args) {
System.out.println("身份证号：");
String no = new Scanner(System.in).nextLine();
//编辑正则表达式，身份证一般是18位，最后一位，有可能是数字，
// 在程序中'\'表转义字符，需要写在前面加一个‘\\’表示一个'\'
String regex = "\\d{17}[0-9X]";
if (no.matches(regex)){
System.out.println("输入正确");
}else {
System.out.println("输入错误！");
}
}
}
包装类
1.对基本类型进行封装，提供一些其他的功能
2.基本类型与包装类型的对应类型（int Integer char Character）
3.Integer
3.1)创建方式一：new Integer(5); --没有高效的效果
3.2)创建方式二：Integer.valueOf(5); --有高效的效果，限制范围：[-128~127]
TIPS: 只有方式二的指定范围才有高效的效果，
在此范围内，数据只会存一次，后续再存都是直接使用之前存过的数据
package cn.tedu.api;
//Integer
public class TestNumber {
static Integer i0;
public static void main(String[] args) {
System.out.println(i0);//Integer的默认值是null
//创建方式一：没有高效效果
Integer i1 = new Integer(5);
Integer i2 = new Integer(5);
System.out.println(i1==i2);//false,比较地址值
//创建方式二：Integer类型的数据使用valueOf()创建方式，有高效的效果，
//注意范围[-128,127]数据只存一次，后续再存都是直接使用之前的数据
Integer i3 = Integer.valueOf(127);
Integer i4 = Integer.valueOf(127);
System.out.println(i3==i4);//true
Integer i5 = Integer.valueOf(300);
Integer i6 = Integer.valueOf(300);
System.out.println(i5==i6);//false 超出范围，没有Integer高效的效果
}
4.Double
4.1)创建方式一：new Double(5.5);
4.2)创建方式二：Double.valueOf(5.5);
TIPS:Double就没有高效的效果，不论哪种创建方式
i1.parseInt(“600”)+10.5–>610.5 --i1是Integer类型的对象
d1.parseDouble(“2.2”)+1–>3.2 --d1是Double类型的对象
5.包装类
parseInt（String s） ----Integer包装类提供的方法把String类型的数据转成int类型-----静态资源
parseDouble（String s） ----Double包装类提供的方法把String类型的数据转成Double类型-----静态资源
package cn.tedu.api;
public class TestDouble {
public static void main(String[] args) {
Double d1 = new Double(3.14);
Double d2 = new Double(3.14);
Double d3 = Double.valueOf(3.14);
Double d4 = Double.valueOf(3.14);
//没有高效效果
System.out.println(d1==d2);//false，同一个方式创建出来的两个不同的对象
System.out.println(d3==d4);//false//两个对象
System.out.println(d2==d3);//false两种不同的创建方式
String S="223";
Integer i1 = new Integer(5);
System.out.println(i1.parseInt(S));//610.5
System.out.println(d1.parseDouble("2.2")+10.5);//12.5
}
}
-
自动装箱 : 基本类型 -> 包装类型
自动拆箱：包装类型 -> 基本类型//自动装箱：编译器会自动把int类型的127转换成Integer类型的127
//然后交给引用类型i3来保存，自动装箱底层发生的代码：
//Integer.valueOf(127);注意方向int–》Integer
/*自动拆箱
* 编译器会自动把Integer类型的i1中的127交给int类型的i4来保存
* 自动拆箱的代码：i1.intValue（）；
* 注意方向：Integer–>int
* */
package cn.tedu.api;
public class TestBox {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = Integer.valueOf(127);
//自动装箱：编译器会自动把int类型的127转换成Integer类型的127
//然后交给引用类型i3来保存，自动装箱底层发生的代码：
//Integer.valueOf(127);注意方向int--》Integer
Integer i3 = 127;
/*自动拆箱
* 编译器会自动把Integer类型的i1中的127交给int类型的i4来保存
* 自动拆箱的代码：i1.intValue（）；
* 注意方向：Integer-->int
* */
int i4 = i1; //不会报错，会发生自动拆箱
}
}
BigDecimal
---------浮点数运算不精确解决方案
1.创建工具类对象
new BigDecimal(double参数)—有坑！！–还是不精确
newBigDeccimal(String参数)—注意需要把double转String，直接拼个"" 即可
2.2.通过工具类对象进行四则运算
bd1.add加/subtract减/mutiply乘/divide除
TIPS:注意除法可能会出现除不尽的现象，会报错，注意设置保留位数和舍入方式
//三个参数：除谁，除不尽时保留的位数，舍入方式
bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
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 f2() {
System.out.println("请输入要计算的两个小数");
double a = new Scanner(System.in).nextDouble();
double b = new Scanner(System.in).nextDouble();
/*有坑！！！
*不要使用double参数的构造方法
* 因为还是不精确的结果，要使用参数类型为String的构造方法
* double转String，直接拼个空串就可以了*/
BigDecimal bd1 = new BigDecimal(a+"");
BigDecimal bd2 = new BigDecimal(b+"");
BigDecimal bd3 ;
bd3 = bd1.add(bd2);
System.out.println(bd3);
bd3 = bd1.multiply(bd2);
System.out.println(bd3);
bd3 = bd1.subtract(bd2);
System.out.println(bd3);
//由于除法会出现除不尽的现象，数据仍没办方法精确展示
//需要提前设置除不尽时保留的位数以及s舍入规则
//bd3 = bd1.divide(bd2);
//三个参数：除谁，除不尽时保留的位数，舍入方式
bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
System.out.println(bd3);
}
}
舍入方式解析
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一样
流 Stream
1.流是单方向的
2.输入流只能输入in(读取)，输出流只能输出out(写出)
3.流只能从头到尾的顺序读取一次
TIPS:方向一定要对，注意可以从程序的角度的考虑
流的分类：
1.根据操作数据的单位不同：字节流（二进制，所有文件）和字符流（字符，文本文件）
2.根据流的方向不同：输入流和输出流
3.组合情况：字节输入流 字节输出流 字符输入流 字符输出流
File 文件流
创建File对象 new File(String pathname)
pathname是路径，路径可以是：文件路径/文件夹路径/不存在的文件路径
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 {
//手动创建 文件E:\ready\1.txt
File f = new File("E:\\ready\\1.txt");
System.out.println(f.length());//3
System.out.println(f.exists());//true 文件是否存在
System.out.println(f.isFile());//true 是否是文件
System.out.println(f.isDirectory());//false 是否是文件夹
System.out.println(f.getName());//1.txt 获取当前的名字
System.out.println(f.getParent());//E:\ready父级路径
System.out.println(f.getAbsoluteFile());//绝对路径 E:\ready\1.txt
/*文件的创建与测试
* 指定一个路径，期望在此路径下创建一个文件，这个路径当前是不存在的路径*/
f = new File("E:\\ready\\2.txt");
//本方法才是真正的帮我在系统中创建一个真实的文件--- f.createNewFile()
//注意：本方法需要抛出或者或者处理异常，如果路径不对会报错
System.out.println(f.createNewFile());
f = new File("E:\\ready\\m");
System.out.println(f.mkdir());//创建一个文件夹
f = new File("E:\\ready\\a\\b\\c");
System.out.println(f.mkdirs());
System.out.println(f.delete());//只能删除空文件夹c或文件
System.out.println(f.delete());
System.out.println();
//文件列表测试
f = new File("E:\\ready");
String[] list = f.list();//[1.txt, 2.txt, a, m]
System.out.println(Arrays.toString(list));
File [] files = f.listFiles();//[E:\ready\1.txt, E:\ready\2.txt, E:\ready\a, E:\ready\m]
System.out.println(Arrays.toString(files));
}
}
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
