Java学习-part.05（异常、字符串、字符串处理及转换、包装类、时间处理、Math类操作）

Java异常处理

语法

语法格式：

try{
    //代码块
    ....
    
    //主动抛出异常
    throw new MismatchException("这里是异常信息");
}catch(MismatchException e){
    //除非try里面执行代码发生了异常，否则这里的代码不会执行 
    //出现异常的处理
}catch(Exception e){
    //除非try里面执行代码发生了异常，否则这里的代码不会执行 
    //出现异常的处理
    e.printStackTrace();
}finally{
    //最终将执行的代码
    //***不管什么情况都会执行，包括try catch 里面用了return ,可以理解为只要执行了try或者catch，就一定会执行 finally 
}

代码中可以有多个catch来捕获不同类型的Exception，从上至下必须是子到父的关系，也就是说越明显的异常最先捕获，最后的异常才有Exception来捕获；finally里面的代码是程序最后执行的地方。

高升对finally的解译: *

finally的作用是上面的try代码块出现异常了，会中转执行跳转的catch块，这个时候如果有其他逻辑不管是否异常都要继续执行，就写到finally里面

自定义异常

在很多的情况下java内部定义的异常可能不满足目前场景，需要我们自己去定义一个异常类来处理，自定义的异常类必须是继承父类或者Exception的。

DrunkException.java

package com.exceptiontest;

public class DrunkException extends Exception{
	
	public  DrunkException(String message) {
		super(message);
	}
	public DrunkException() {
		
	}
}

异常链

在业务场景当中，我们可能会对某个服务进行处理，服务里面的异常和外部对服务的异常处理应该这样处理：

package com.exceptiontest;

public class MyTryCacth {

	public static void main (String[] args) throws DrunkException { //自定义的异常必须要先声明
		// TODO Auto-generated method stub
		MyTryCacth mc = new MyTryCacth();
		try {
		    //调用服务方的时候需要try-catch
			mc.test();
		} catch (Exception e) {
			e.printStackTrace(); //打印出异常情况
		}finally {
			System.out.println("来点骚东西"); //这里是最后的执行
		}
	}
	
	
	public void test() throws DrunkException {  //自定义的异常必须要先声明
		try {
			throw new DrunkException("我喝大了！");
		} catch (Exception e) {
		    //这里看业务需要，这里是包装成了RuntimeException()
			throw new RuntimeException(e);
		}
	}
}

前车之鉴

处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
在多重catch块后面，可以加一个catch(Exception) 来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出（例如可以回滚）
具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加finally语块去释放占用的资源

Java中的字符串

概述与语法

在Java中字符串属于引用类型，字符串被作为String类型的对象处理，String类位于java.lang包中。

创建String对象：

String s1 = "xiexiang";

String s2 = new String();

String s3 = new String("xiexiang");

字符串的不变性

String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。

String name1 = "xiexiang";

String name2 = "xiexiang";

String name3 = new String("xiexiang");

String name4 = new String("xiexiang");

//多次出现的字符常量，java编译程序只会创建一个，所以返回true
System.out.println(name1 == name2);
//name1和name3是不同的对象，所以返回false
System.out.println(name1 == name3);
//name3和name4是不同的对象，返回false
System.out.println(name3 == name4);


执行结果：

true
false
false

每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法, System.out.println(name3.equals(name4));

字符串处理的常用方法

“==” 和 equals() 的区别

==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals(): 比较存储在两个字符串对象中的内容是否一致

Java中的StringBuilder类及常用方法

概述：String是一个不可变的类，而StringBuilder是一个可变类。

StringBuilder对象用来储存字符串，并对其做了追加和插入的操作，这些操作只是修改了str对象的值，而没有创建新的对象，这就是StringBuilder和String最大的区别。

StringBuilder常用方法

方法	说明
StringBuilder append(参数)	追加内容到当前的StringBuilder对象的末尾
StringBuilder insert(位置，参数)	将内容插入到StringBuilder对象的指定位置
String toString()	将StringBuilder对象转换为String对象
int length()	获取字符串的长度

package com.string;

public class StringBuilderTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuilder str = new StringBuilder("hello");
		str.append(" xiaochuhan");
		System.out.println(str);
		
		str.insert(5, "daye");
		System.out.println(str);
		
		str.toString();
		System.out.println(str);
		
		System.out.println(str.length());
	}
}

执行结果：
hello xiaochuhan
hellodaye xiaochuhan
hellodaye xiaochuhan
20
  //都会在原值上进行修改，不会创建新的对象

Java中的包装类

概述：比如int、float、double、boolean、char等都属于基本数据类型是不具备对象的特性的，也不能条用方法、功能简单；为了让基本数据类型也具有对象的特性，java为每个基本数据类型都提供了一个包装类，这样就可以像操作对象那样操作基本数据类型。

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

语法：

1 2	int age = 19; //定义一个int基本数据类型 float age1 = new Integer(age).floatValue(); //转为为float类型

我们以Integer为例看下包装类里面的常用方法：

方法名	说明	返回值
byteValue()	将该Integer转为byte类型	byte
doubleValue()	转为double类型	double
floatValue()	转为float类型	float
intValue()	转为int类型	int
longValue()	转为long类型	long
parseInt(String s)	将字符串转换为int类型	static int
toString()	转为字符串类型	String
valueOf(String s)	将字符串传唤为Integer类型	static Integer

int age = 18;
Integer itr = new Integer(age);
String age1 = itr.toString();
float age2 = itr.floatValue();
double age3 = itr.doubleValue();
long age4 = itr.longValue();

System.out.println(age1);
System.out.println(age2);
System.out.println(age3);
System.out.println(age4);
		
输出结果：
18
18.0
18.0
18

基本数据类型与包装类的转换（装箱与拆箱）

在JDK1.5引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就轻松了。

装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱；

1
2
3

int age = 18;    //定义一个int的基本类型
Integer ag = new Integer(age);  //手动装箱
Integer ag = age;       //自动装箱

拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱；

1
2
3

Integer j = new Integer(90); //定义一个Integer包装类
int m = j.intValue();  //手动拆箱为int类型
int n = j;             //自动拆箱为int类型

基本数据类型与字符串之间的转换

基本类型转字符串

基本类型转换为字符串有三种方法：

1、使用基本类型的包装类的toString()方法；

2、使用String类的 valueOf()方法；

3、用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串；

//将基本类型转换成字符串
int age = 18;
String age1 = Integer.toString(age); //方法一
String age2 = String.valueOf(age);   //方法二
String age3 = age + "";              //方法三

float t =10f;
String t1 = Float.toString(t);
String t2 = String.valueOf(t);

字符串转基本类型

字符串转基本类型有两种方法：

1、调用包装类的parseXxx静态方法；

2、调用包装类的 valueOf()方法转换成基本类型

//将字符串转换成基本类型
String str= "33";
int str1 = Integer.parseInt(str);   //方法一  转int
int str2 = Integer.valueOf(str);    //方法二  转int

flaot str3 = Float.parseFloat(str); 
float str4 = Float.valueOf(str); 

** valueOf()方法会自动判断转换的类型

使用Date和SimpleDateFormat类表示时间

开发中我们可以用import java.util.Date这个类获取当前的时间。

Date time = new Date();
system.out.println(time);

执行输出：
Fri Jun 29 16:39:54 CST 2018

这种方式并不是我们想要的结果，这个时候就需要用到import java.text.SimpleDateFormat这个类来对日期时间进行格式化。

1、使用format()方法将日期转换为指定格式的文本

Date time = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
String nowTime = sdf.format(time);
System.out.println(nowTime);

执行结果：
2018-43-29 16:43:51

2、使用parse()方法将文本转换为日期

String date = "4018年06月18日 12:34:45";
try {
    SimpleDateFormat ss = new SimpleDateFormat("yyyy年mm月dd日 HH:mm:ss");
    Date timeNow  = ss.parse(date);
    System.out.println(timeNow);
}catch(ParseException e){
    e.printStackTrace();
}

执行结果：
Thu Jan 18 12:34:45 CST 4018

代码中的”yyyy年MM月dd日 HH:mm:ss”指定了字符串的日期格式，调用parse()方法将文本转换为日期。

需要注意：

1、调用SimpleDateFormat对象的parse()方法时可能会出现转换异常，即parseException，因此需要进行异常处理。
2、使用Date类时需要导入java.util.Date包，使用SimpleDateFormat时需要导入 java.text.SimpleDateFormat 包

Calendar 类的应用

java.util.Calendar类是一个抽象类，可以通过调用getInstance()静态方法获取一个Calendar对象，此对象已由当前日期时间初始化，即默认为当前时间，如 Calendar c = Calendar.getInstance();

如何获取年月日时分秒？

Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int min =  c.get(Calendar.MINUTE);
int second =  c.get(Calendar.SECOND);
System.out.println("当前时间为：" + year +"-"+month+"-"+day+" "+ hour+":"+min+":"+second);

执行结果：
当前时间为：2018-5-29 17:21:20

调用 Calendar 类的 getInstance() 方法获取一个实例，然后通过调用 get() 方法获取日期时间信息，参数为需要获得的字段的值， Calendar.YEAR 等为 Calendar 类中定义的静态常量。

Calendar类提供了getTime()方法，用来获取Date对象，完成Calendar和Date的转换，还可以通过getTimeInMillis()方法，获取此Calendar的时间值，以毫秒为单位。

// 创建Calendar对象
Calendar c = Calendar.getInstance();
// 将Calendar对象转换为Date对象
Date date = c.getTime();

// 创建SimpleDateFormat对象，指定目标格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

// 将日期转换为指定格式的字符串
String now = sdf.format(date);

System.out.println("当前时间：" + now);

执行结果：
当前时间：2018-06-29 17:44:41

Math类操作数据

Math类位于java.lang包中，包含用于执行基本数学运算的方法，Math类的所有的方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名。

常用的方法：

方法名	说明	返回值
round	返回四舍五入后的整数	long
floor	返回小于参数的最大整数	double
ceil	返回大于参数的最小整数	double
random	返回[0，1）之前的随机数浮点数	double

package com.string;

public class MathTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MathTest test = new MathTest();
		test.MathRandomTest();
	}
	
	public void MathRandomTest() {
		int nums[] = new int[10];
		float douStr = 45.66f;
		for(int i=0;i<nums.length;i++) {
			nums[i] = (int)(Math.random() * 100);
		}
		for(int num:nums) {
			System.out.print(num+"-");
		}
		System.out.println(Math.ceil(douStr));
		System.out.println(Math.floor(douStr));
		System.out.println(Math.round(douStr));
	}
}

执行结果：
  44-98-49-49-94-13-64-86-72-50-
  46.0
  45.0
  46