正则表达式，日期，异常详细介绍Java笔记

常用API-异常

Calendar类

java.util.Calendar日历对象类,取代Date类的部分功能.

日历类是抽象类,不能创建对象,利用子类对象 GregorianCalendar

Calendar类静态的方法 static Calendar getInstance() 获取了子类的对象,返回值是父类类型

Calendar cal = Calendar.getInstance() : 获取子类对象

日历字段

组成一个日历,需要最基本的数据,年,月,日,小时,分钟… …

组成部分称为日历字段,日历自动的数据类型是int类型

Calendar类的方法

方法 : 是Calendar类中定义的方法,如果方法是抽象的,执行子类方法重写

方法不是抽象的, 子类继承直接来使用.

方法返回值	方法名字	方法解释
static Calendar	getInstace()	静态方法,返回子类对象
int	get(int)	返回指定的日历字段数据
void	set(int,int,int)	设置日历,传递年,月,日
void	set(int,int)	设置日历,设置指定的某个日历字段
void	add(int,int)	日历字段的偏移量

public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		/*
		 * get方法获取日历字段
		 * 年,月,日,小时,分钟... ...
		 * 日历自动使用的是int类型表示 1 2 3 分别代表什么,不清楚
		 * 变量表示 - 见名知意
		 * Calendar的静态成员变量
		 */
		System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" + 
		                  cal.get(Calendar.DAY_OF_MONTH) + "日");
	}

	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		//设置日历,设置到今年的10月份
		//参数1:设置哪个字段, 参数2: 具体数据
		//cal.set(Calendar.MONTH, 9);
		
		//设置日历,设置到2030年的5月1日
		cal.set(2030, 4, 1);
		
		//打印输出日历
		System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" + 
                cal.get(Calendar.DAY_OF_MONTH) + "日");
	}

public static void main(String[] args) {
    Calendar cal = Calendar.getInstance();
    //当前日历,向后偏移180天
    //参数1: 要偏移的字段, 参数2: 具体数据
    cal.add(Calendar.DAY_OF_MONTH, 180);
    //打印输出日历
    System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" +  cal.get(Calendar.DAY_OF_MONTH) + "日");
}

日历的练习

需求 : 计算闰年

提供年份,计算出是不是闰年

实现思想 : 闰年的2月是29天,日历设置到这年的3月1日,向前偏移1天

public static void main(String[] args) {
    Calendar cal = Calendar.getInstance();
    //设置日历  3月1日
    cal.set(3024, 2, 1);
    //向前偏移1天
    cal.add(Calendar.DAY_OF_MONTH, -1);
    //取出天数
    int i = cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(i);
}

Math类

java.lang.Math类,实现了数学计算的类,包括对数,底数,三角函数等运算

不能创建对象,因为构造方法被私有修饰,方法全部是静态方法,Math.调用()

返回值	方法名	方法解释
static int	abs(int a)	返回参数a的绝对值
static double	ceil(double a)	对参数a向上取整,返回大于或者等于参数的最小整数
static double	floor(double a)	对参数a向下取整,返回大于或者等于参数的最大整数
static long	round(double a)	对参数四舍五入,取整数部分
static double	pow(double a,double b)	幂运算,a的b次方
static double	random()	返回随机数,范围0.0-1.0之间,可能是0.0不会到1.0
static double	sqrt(double a)	对参数进行平方很计算

public static void main(String[] args) {
    //abs方法,绝对值
    System.out.println("绝对值 " + Math.abs(-5) );

    //ceil方法,向上取整
    System.out.println("向上取整  " + Math.ceil(12.56) );

    //floor方法,向下取整
    System.out.println("向下取整 " + Math.floor(-12.56));

    //round方法,四舍五入,取整数
    System.out.println("四舍五入 " + Math.round(5.49999999));

    //pow方法,幂运算  3个2相乘 
    System.out.println("幂运算 " + Math.pow(2, 3));

    //random方法,随机数
    System.out.println("随机数 " + Math.random());

    //sqrt方法,平方根
    System.out.println("平方根 " + Math.sqrt(3));
	}

大数据运算

当数字,超过long的取值范围,这样的数据是真实存在的.Java认为 ,超过long的取值范围不能称为数字,称为超级大数对象,对象是由类产生:

java.math.BigInteger 超级大整数

java.math.BigDecimal 超级大的浮点数 (精确的浮点运算)

BigInteger

构造方法: new BigInteger(String val) 参数是字符串类型,可以写任意的长度,但是必须是数字.

创建BigInteger对象,封装超级大数

方法: + - * /

返回值	方法名	方法解释
BigInteger	add(BigInteger big)	两个大数求和
BigInteger	subtract(BigInteger big)	两个大数减法
BigInteger	multiply(BigInteger big)	两个大数乘法
BigInteger	divide(BigInteger big)	两个大数除法

public static void main(String[] args) {
    //创建BigInteger大数对象,构造方法中,传递字符串
    BigInteger big1 = new BigInteger("1234567890987654321234567890");
    //9223372036854775807
    BigInteger big2 = new BigInteger("23245678908765432456786543");

    //求和 big1 + big2 计算结果,是BigInteger对象
    BigInteger bigAdd = big1.add(big2);
    System.out.println(bigAdd);

    //减法 big1 - big2
    BigInteger bigSub = big1.subtract(big2);
    System.out.println(bigSub);

    //乘法 big1 * big2
    BigInteger bigMul = big1.multiply(big2);
    System.out.println(bigMul);

    //除法 big1 / big2
    BigInteger bigDiv = big1.divide(big2);
    System.out.println(bigDiv);
	}

BigDecimal

精确的浮点数运算.计算财务问题

构造方法 : BigDecimal(String val) 传递字符串,保证精度,可以任意长度

四则运算和BigInteger几乎一样的

区别在除法运算, 出现无限小数

方法返回值	方法名	解释
BigDecimal	divide(BigDecimal big)	两个大数的除法运算,高精度
BigDecimal	divide(BigDecimal big,int s ,int round)	参数含义 : 自定义的精度计算,(取舍)
static int	ROUND_DOWN	舍入模式,直接舍去
static int	ROUND_UP	舍入模式,向上+1
static int	ROUND_HALF_UP	舍入模式,四舍五入

public static void main(String[] args) {
		BigDecimal big1 = new BigDecimal("5.055");
		BigDecimal big2 = new BigDecimal("1.0005");
		
		BigDecimal bigMul = big1.multiply(big2);
		System.out.println(bigMul);
		
		//System.out.println(5.055*1.0005);
		
		BigDecimal big4 = new BigDecimal("3.55");
		BigDecimal big5 = new BigDecimal("1.35");
		//除法计算 big4 / big5
		
		//2.62962962962963
		/*
		 * BigDecimal divisor, int scale, int roundingMode)
		 * divisor 被除数 big5
		 * scale 要保留的位数
		 * roundingMode 舍入模式  ROUND_DOWN 直接舍去
		 * roundingMode 舍入模式  ROUND_UP 向上+1
		 * roundingMode 舍入模式  ROUND_HALF_UP 四舍五入向上+1
		 */
		BigDecimal bigDiv = big4.divide(big5,3,BigDecimal.ROUND_HALF_UP);
		System.out.println(bigDiv);
	}

基本数据类型包装类

基本数据类型,提供的功能基本都是运算为主. 实际工作中这些功能是不够的,因此提高了一套包装类,作用将基本数据类型变成对象, 对象具有的功能就会更多.

基本类型包装类 : 主要实现了一个非常关键的功能 : 基本类型和字符串之间的相互转换 “1”

包装类都在java.lang

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

int类型的包装类 Integer类, 其他的包装类的用法基本都一样的

Integer类的使用

内部包装了一个int数据类型,变成了对象.

• 字符串String转成基本数据类型int
  • Integer类静态方法 : static int parseInt(String s) 字符串转成基本类型int,字符串必须是数字格式
  • Integer对象转换 : Integer构造方法(String val) 字符串必须数字格式
  • Integer对象转换 : static Integer valueOf(String val) 字符串必须数字格式
  • Integer对象的方法: int intValue() 字符串转成基本类型int

	public static void main(String[] args) {
		//传递的参数是100,返回值基本类型int
		int i = Integer.parseInt("100");
		System.out.println(i+1);
		
		//创建Integer对象
		Integer integer = new Integer("10");
		//对象的方法 intValue(),构造方法中的 字符串,转成基本类型
		int j = integer.intValue();
		System.out.println(j+1);
		
		//Integer类的静态方法 valueOf 创建出Integer的对象
		Integer integer2 = Integer.valueOf("20");
		int k = integer2.intValue();
		System.out.println(k+1);
	}

自动装箱和自动拆箱

自动的装箱和拆箱,无需程序人员参与这个过程,但是原理要学习.

是JDK1.5出现

自动装箱 : 基本数据类型,自动变成对象

自动拆箱 : 对象,自动变成基本数据类型

public static void main(String[] args) {
    //自动装箱, 基本类型自动变成对象
    /*
    * Integer是类名,引用数据类型
    * 引用数据类型变量 i  指向一个对象
    * 1 是基本类型,自动装箱成为对象
    */
    Integer i = 1;

    /*
    *  i 变量是引用类型,保存是内存地址
    *  能和1相加吗
    *  引用类型变量 i 自动拆箱,对象变成基本类型 1了
    *  1 + 1 =  2, 2 赋值变量i
    *  i = 2计算,进行自动装箱
    */
    i = i + 1;
    System.out.println(i);
}

自动装箱和自动拆箱面试

public static void main(String[] args) {
    Integer i = new Integer(100);
    Integer j = new Integer(100);

    System.out.println( i == j); // == 引用类型,比较内存地址   false
    System.out.println(i.equals(j)); // equals方法继承父类重写  true

    System.out.println("==========");

    Integer ii = 200; // valueOf() = new Integer()
    Integer jj = 200;
    System.out.println(ii == jj); // == 引用类型,比较内存地址  false
    System.out.println(ii.equals(jj));  // equals方法继承父类重写  true

    System.out.println("==========");

    Integer iii = 127;
    Integer jjj = 127;
    System.out.println(iii == jjj); //== 引用类型,比较内存地址 true
    System.out.println(iii.equals(jjj)); // true

    //装箱 , 范围是byte之间,不new对象
    //Integer a = Integer.valueOf(1); // 源码中 valueOf方法里面new Integer对象
}

正则表达式

正则表达式介绍 : 正则是专门对字符串处理的一种技术.

String,StringBuilder都是操作字符串,但是他们的功能远远不够, 正则表达式出现,填补了字符串操作的空白.

用户输入QQ号 : 验证QQ号码是否是合法的

QQ号码 : 全数字,不能0开头,位数6-10位

public static void main(String[] args) {
		boolean b = checkQQ("34567");
		System.out.println(b);
	}
	/*
	 * 定义方法,验证QQ号码
	 * 验证通过返回true,否则返回false
	 * 全数字,不能0开头,位数6-10位
	 */
	public static boolean checkQQ(String qq) {
		// 字符串的长度,验证位数
		if( qq.length() < 6 || qq.length() > 10)
			return false;
		//字符串开头方法 startsWith , 0开头,if就是true
		if(qq.startsWith("0"))
			return false;
		//全数字 QQ号码拆分成单个字符,一个个验证
		char[] ch = qq.toCharArray();
		for(int i = 0 ; i < ch.length ; i++) {
			if( ch[i] < 48 || ch[i] > 57 )
				return false;
		}
		return true;
	}

正则表达式规则

• 字符类
  • [abc] 字符匹配abc
  • [a-z] 字符匹配所有的小写字母
  • [a-zA-Z] 字符匹配所有的字母
  • [^a-z] 匹配所有的非小写字母
  • [^abc] 字符匹配不是abc
  • [a-zA-Z0-9_] 字符匹配所有的字母,数字和下划线
  • [^a-zA-Z0-9_] 字符匹配不是字母,不是数字,不是下划线
• 预定义字符类
  • . 匹配任意字符
  • [\w]匹配所有的单词字符,等同于 [a-zA-Z0-9_]
  • [\W] 匹配所有的非单词字符,等同于 [^a-zA-Z0-9_]
  • [\d] 匹配所有数组,等同于[0-9]
  • [\D] 匹配非数字 , 等同于[^0-9]
• 次数类
  • X? 这个字符X,出现的次数,一次或者一次也没有
  • X* 这个字符X,出现零次或者多次
  • X+ 这个字符X,出现一次或者多次
  • X{m} 这个字符X,出现正好m次
  • X{m,} 这个字符X,出现至少m次
  • X{m,n} 这个字符X,出现至少m次,但是不超过n次

正则表达式匹配方法

String类的方法 matches

• boolean matches(String reg)
  • 正则表达式验证的方法
  • 参数传递正则的规则
  • 字符串和规则匹配,返回true

public static void main(String[] args) {
		boolean b = checkQQ("1245");
		System.out.println(b);
		
		b = checkNumber("13800138000");
		System.out.println(b);
	}
	/*
	 * 验证手机号
	 * 全数字, 1开头,必须11位 第二位不能是012
	 * 13800138000 
	 */
	public static boolean checkNumber(String number) {
		//定义手机号规则
		String reg = "1[3745689][0-9]{9}";
		return number.matches(reg);
	}
	
	/*
	 * 定义方法,验证QQ号码
	 * 验证通过返回true,否则返回false
	 * 全数字,不能0开头,位数6-10位
	 */
	public static boolean checkQQ(String qq) {
		//正则表达式,定义QQ号码规则
		//QQ号码第一位是数字,不能0开头
		//QQ号码第二位,必须数字
		//QQ号码第三位,数字
		String reg = "[1-9][0-9]{5,9}";
		return qq.matches(reg);
	}

正则表达式切割方法

String类的方法split

• String[] split(String reg)
  • 按照指定的正则表达式进行切割
  • 参数reg传递正则表达式

public static void main(String[] args) {
    //正则表达式对字符串切割
    //String str = "ab123cd45ef999909gh";
    //按照数字,对字符串切割
    //String[] array = str.split("[\\d]+");

    String ip = "10....10...........18.28";
    String[] array = ip.split("\\.+");
    System.out.println(array.length);
    for(int i = 0 ; i < array.length ; i++) {
    	System.out.println(array[i]);
    }
}

正则表达式替换方法

String类的方法 replaceAll()

• String replaceAll("正则规则","要替换内容")

public static void main(String[] args) {
    String str = "assdfg23432ewge098765rewg3232ewflkjjf12321lw";
    //字符串的所有数组,替换为一个 #
    String rep = str.replaceAll("\\d+", "#");
    System.out.println(rep);
}

异常

异常概念 : 程序在运行过程中,出现的不正常现象,就是异常

异常也是对象 : 都是由异常类产生的

Java语言的异常的继承体系

• java.lang.Throwable 所有异常和错误的父类
  • java.lang.Error 所有错误的父类
  • java.lang.Exception 所有异常的父类
    • java.lang.RuntimeException 运行时异常
• Error错误和Exception异常的区别
  • Error错误 : 理解人病了,非典,艾滋,癌症, 等死
    • 程序一旦反生错误,根本运行不了,修改源码
  • Exception异常 : 阑尾炎,感冒,划伤, 治好以后和以前一样
    • 程序一旦发生异常,处理完,继续执行

Throwable类的方法

所有的异常和错误,都是子类, Throwable类的方法,都会被继承使用

• String toString() 返回异常信息的简短描述
• String getMessage() 返回异常信息的详细描述
• void printStackTrace() 将异常信息,追踪到标准错误流 (目前,方法可以异常信息输出在控制台)

异常引发过程和JVM默认处理机制

异常信息输出打印,停止程序的允许

public static void main(String[] args) {
    int[] arr = {1,2,3};
    int i = getArray(arr);
    System.out.println(i);
    System.out.println("程序结束");
}

public static int getArray(int[] arr) {
	return arr[5];
}

异常的处理方式 try catch

• try{} catch(){}异常的处理

语法格式:

try{
  //被检测的代码,或者是可能出现异常代码
}catch(异常类的名字 变量){
  //异常的处理方式
  //变量,循环,判断,new对象,调用方法
}

public static void main(String[] args) {
    int[] arr = {1,2,3};
    try {
        int i = getArray(arr);
        System.out.println(i);
    }catch(Exception e) {
    	System.out.println("异常被处理了");
    }

    System.out.println("程序结束");
    }

    public static int getArray(int[] arr) {
    	return arr[0];
	}

• try{} catch(){}异常的处理 , 多catch并行处理

语法格式 :

try{
  //被检测的代码,或者是可能出现异常代码
}catch(异常类的名字 变量){
  //异常的处理方式
  //变量,循环,判断,new对象,调用方法
}catch(异常类的名字 变量){
  //异常的处理方式
}

• 多catch并行处理 catch中的异常类名,写法很关键
  • 两个类之间,没有继承关系,顺序随意
  • 两个类之间,存在继承关系,父类写在最后面

public static void main(String[] args) {
		//多catch并行处理,抓异常
		try {
			get(10);
		}catch(NullPointerException ex) {
			System.out.println("处理了空指针异常");
		}catch(ArrayIndexOutOfBoundsException ex) {
			System.out.println("处理了数组越界异常");
		}
	}
	
	/*
	 * 定义方法,传递参数 int类型
	 * 参数变量i的值是0 ,方法出现空指针异常
	 * 参数变量i的值非0 ,方法出现数组越界异常
	 */
	public static void get(int i) {
		if( i == 0) {
			int[] arr = null;
			System.out.println(arr[0]);
		}
		
		if( i != 0) {
			int[] arr = {1,2};
			System.out.println(arr[3]);
		}
	}

• try{} catch(){}异常的处理 , 多catch合并为一个catch

public static void main(String[] args) {
		//多catch并行处理,抓异常
		try {
			get(10);
		}catch(NullPointerException | ArrayIndexOutOfBoundsException e) {
			System.out.println("异常被处理");
		}
	}

Throwable类的方法

public static void main(String[] args) {
		//异常信息的用法
		try {
			get();
		}catch(ArrayIndexOutOfBoundsException ex) {
			//方法 toString()异常信息的简短描述
			System.out.println(ex); //  java.lang.ArrayIndexOutOfBoundsException: 3
			
			//方法 getMessage() 异常信息的详细描述
			String message = ex.getMessage();
			System.out.println(message); //  3
			
			//printStackTrace() 
			/*
			 * java.lang.ArrayIndexOutOfBoundsException: 3
				at exception.ExceptionDemo05.get(ExceptionDemo05.java:30)
				at exception.ExceptionDemo05.main(ExceptionDemo05.java:12)
			 */
	        ex.printStackTrace();

		}

finally代码块

finally代码块,是跟随try catch出现的,凡是写在finally代码块里的程序,必须执行

作用 : 释放资源

public static void main(String[] args) {
		//异常信息的用法
		try {
			get();
		}catch(ArrayIndexOutOfBoundsException ex) {
	        ex.printStackTrace();
		}finally {
			System.out.println("无论如何都运行");
		}
	}
	public static void get() {
		int[] arr = {1,2};
		System.out.println(arr[1]);	
	}

throw和throws

• throw 抛出的意思,只能作用在方法里面,表示方法中会出现异常
• throws 声明的意思,只能作用在方法的定义上,告知调用者,我有异常

/*
 *  throw和throws
 *  
 *  遇到调用异常的方法,throws继续抛出,还是try 捕获,现在阶段,都可以
 *  以后不行 : 持久层抛出,业务层捕获
 */
public class ExceptionDemo08 {
	public static void main(String[] args) {
		/*
		 * 调用 了一个抛出异常的方法
		 * 必须处理,编译失败
		 * 一种在方法上,继续throws, 异常抛到JVM
		 */
		try {
			buy(0);
		}catch (Exception e) {
			System.out.println("异常被处理");
		}
				
		System.out.println("程序结束");
	}
	/*
	 * 方法演示
	 * 定义方法,传递参数(钱),方法的作用是买饭
	 * 方法的参数有问题,功能不能实现
	 * 
	 * 将方法内部异常,表现出来,告诉调用者
	 * 关键字 throws 后面写的是异常类的类名
	 */
	public static void buy(int money)throws Exception{
		if(money <= 0) {
			//抛出异常 throw关键字  抛出的是异常对象
			throw new Exception();
		}
	}
}

异常分类

• 编译异常
  • 当我们调用了一个抛出异常的方法,调用者必须处理,要是不处理编译失败
  • 处理方式 try catch 也可以使用throws
• 运行异常
  • 凡是RuntimeException类,和他的所有子类,全都是运行异常
  • 方法中如果抛出的异常是运行异常,方法的声明上不需要使用throws关键字
  • 方法调用者,是看不到方法内部有异常
  • 调用者调用方法,不要处理这个异常
  • 运行时期的异常,不能处理,一旦发生,程序人员必须修改源码
  • RuntimeException子类 :
    • 数组越界
    • 空指针异常
    • 类型转换异常 (ClassCastException)
    • 无效参数异常 IllegalArgumentException

子类父类的异常处理

• 父类方法抛出异常
  • 子类继承父类,重写方法后,异常可以不抛
  • 子类继承父类,重写方法后,如果子类要抛异常,抛出的异常不能大于父类的
• 父类方法不抛异常
  • 子类继承父类,重写方法后,也不能抛出异常
  • 如果子类调用了一个抛出异常的方法,子类只能是try catch处理