Java进阶2(Sting/BigDecimal/泛型/异常)

String

String概述

public void fun1() {
	String name = "lisi";
	name = "zhangsan";
	String name2 = "zhangsan";//只在方法池里面创建name和name2
	System.out.println(name == name2);//true
	String name3 = new String("zhangsan");//产生两个对象，堆、池中各存储一个
	System.out.println(name == name3);//false
	System.out.println(name.equals(name3));//true
}

String方法

public int length()返回字符串的长度
public char charAt(int index)根据下表获取字符
public boolean contains(String str)判断当前字符串中是否包含str
public char[] toCharArray()将字符串转换成数组
public int indexOf(String str, int formindex)查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1，后面的formindex表示从哪个索引开始找
public int lastIndexOf(String str)查找字符串在当前字符串中最后一次出现的下标索引
public String trim()去掉字符串前后的空格
public String toUpperCase()将小写转化为大写 toLowerCase()小写
public boolean endsWith(String str)判断字符串是否以str结尾 startWith判断开头
public String replace(char oldChar, char newChar)将旧字符串替换成新新字符串
public String[] split(String str)根据str划分字符串
public boolean equals(String str)比较大小equalsIgnoreCase忽略大小写
public boolean compareTo(String str)比较大小按照字典表，前一个的ASCII值减去后一个，如果两个前面都一样那么用前一个长度减去后面的长度
public String substring(int beginIndex)截取下标的字符串

public void fun2() {
	//字符串方法的使用
	String str = "Java是世界上最好Java的编程语言Java";
	//length,charAt,contains
	System.out.println(str.length());//23
	System.out.println(str.charAt(str.length() - 1));//a//如果超出会StringIndexOutOfBoundsException
	System.out.println(str.contains("是世界上") + " " + str.contains("是世界下"));//true false
	//toCharArray,indexOf,lastIndexOf
	char[] s = str.toCharArray();
	for(char i:s)System.out.print(i + ",");//J,a,v,a,是,世,界,上,最,好,的,编,程,语,言,
	System.out.println(str.indexOf("是世界上"));//4，参数可以是char或者String
	System.out.println(str.lastIndexOf('v'));//21 最后一次出现
	System.out.println(str.indexOf("jabc"));//-1 没有返回-1
	System.out.println(str.indexOf("Java", 6));//10 从第六个字符开始找
	//trim,toUpperCase,endsWith
	String str2 = "   i love 看电视       ";
	System.out.println(str2.trim());//i love 看电视  输出后str2字符串没有改变
	System.out.println(str.toUpperCase());//JAVA是世界上最好JAVA的编程语言JAVA
	System.out.println(str2.endsWith("看电视"));//false
	System.out.println(str2.trim().endsWith("看电视"));//true
	//replace,split
	System.out.println(str.replace('J', 'j'));//可以用char或者String
	str = "i love and only love   my book,how about you,jay";
	String[] sp = str.split("[ ,]+");//不但最而且J也是分隔符，后面有+可以把多个空格看作一个
	for(String i:sp)System.out.println(i);
	String str3 = "abcdefg";
	String str4 = "abc";
	System.out.println(str3.compareTo(str4));//4

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全

常用方法：

1. append追加
2. insert指定位置添加sb.insert(int offset, String str)
3. replace替换sb.replace(int start, int end, int str)
4. delete删除sb.delete(int start, int end)

public void fun4() {
	//StringBuffer sb = new StringBuffer();
	StringBuilder sb = new StringBuilder();
	//1append追加
	sb.append("Java是一种编程语言");
	sb.append(2021);
	System.out.println(sb);//Java是一种编程语言2021
	//2insert指定位置添加
	sb.insert(4, ",very good,");
	System.out.println(sb);//Java,very good,是一种编程语言2021
	//3replace替换
	sb.replace(0, 4, "python");
	System.out.println(sb);//python,very good,是一种编程语言2021
	//4delete删除
	sb.delete(6, 16);
	System.out.println(sb);//python,是一种编程语言2021
}

public void fun5() {
	//证明StringBuffer和StringBuilder比string效率高
	long start1 = System.currentTimeMillis();
	String str = "";
	for(int i = 1; i < 49999; i++)	str += i;
	long end1= System.currentTimeMillis();
	System.out.println("用时：" + (end1 - start1));//1742
	
	long start2 = System.currentTimeMillis();
	StringBuffer sb = new StringBuffer();
	for(int i = 1; i < 49999; i++)	sb.append(i);
	long end2 = System.currentTimeMillis();
	System.out.println("用时：" + (end2 - start2));//4
	
	long start3 = System.currentTimeMillis();
	StringBuilder sb3 = new StringBuilder();
	for(int i = 1; i < 49999; i++)	sb.append(i);
	long end3 = System.currentTimeMillis();
	System.out.println("用时：" + (end3 - start3));//2
	}

BigDecimal

位置：java.math
作用：计算浮点数
创建方式：BigDecimal bd = new BigDecimal(“1.0”);

public void fun1() {
	double d1 = 1.0;
	double d2 = 0.9;
	System.out.println(d1 - d2);//0.09999999999999998
	
	double d3 = (1.4 - 0.5) / 0.9;
	System.out.println(d3);//0.9999999999999999
	
	//BigDecimal大浮点数的精确计算
	BigDecimal bd1 = new BigDecimal("1.0");
	//如果不给字符串的话，本来就是不准确的会导致BigDecimal也是不准确的
	BigDecimal bd2 = new BigDecimal("0.9");
	
	BigDecimal r1 = bd1.subtract(bd2);//减法
	System.out.println(r1);//0.1
	
	BigDecimal r2 = bd1.add(bd2);//加法
	System.out.println(r2);//1.9
	
	BigDecimal r3 = bd1.multiply(bd2);//乘法
	System.out.println(r3);//0.90
	
	BigDecimal r4 = new BigDecimal("1.4")
			.subtract(new BigDecimal("0.5"))
			.divide(new BigDecimal("0.9"));//除法(1.4 - 0.5) / 0.9
	System.out.println(r4);//1
	
	//不能整除时会有ArithmeticException，而BigDecimal里面有四舍五入保留小数方法
	BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"));
	System.out.println(r5);
	//divide(BigDecimal divisor, int scale, int roundingMode) scale是保留位数，roundingMode是方法
	BigDecimal r6 = new BigDecimal("11").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
	//记住ROUND_HALF_UP是四舍五入就可以
	System.out.println(r6);
}

System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法是私有的、

方法名	说明
static void arraycopy(...)	复制数组
static long currentTimeMillis	获取当前系统时间，返回的是毫秒值
static void gc()	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status)	退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm

//arraycopy数组的复制
//System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
//源数组，开始位置，目标数组，目标数组的位置，复制的长度
int[] arr = {20, 15, 18, 5, 60, 64, 82};
int[] dest = new int[8];
System.arraycopy(arr, 4, dest, 3, 3);
for (int i : dest) System.out.println(i);//0 0 0 60 64 82 0 0
//Arrays.copyOf(boolean[] original, int newLength)用的也是arraycopy

//退出jvm
System.exit(0);
System.out.println("你看不到这句话...");

泛型

语法：类名<T>
T是一种类型占位符，表示一种引用类型如果写多个用逗号隔开
注意：1泛型只能使用引用类型，2不同泛型类型对象之间不能相互赋值

package cn.edu.tyut.demo;

public class Car<T> {//T类型参数
	private String brand;
	private T t;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public T getT() {
		return t;
	}
	public void setT(T t) {
		this.t = t;
	}
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", t=" + t + "]";
	}
}

package cn.edu.tyut.demo;

import org.junit.Test;

public class CarTest {
	@Test
	public void fun() {
		Car<String> car = new Car<String>();
		car.setBrand("Ford");
		car.setT("red");
		System.out.println(car);
		Car<Double> car1 = new Car<Double>();//这里Double必须大写
		car1.setBrand("Wmiw");
		car1.setT(4.5);
		System.out.println(car1);
		
		test(car);
		test(car1);
	}

	//?是类型通配符，任何类型都可以调用这个函数
	private void test(Car<?> car1) {
		System.out.println(car1.getBrand());
		System.out.println(car1.getT());
	}
}

泛型接口

泛型接口中不能有泛型常量
接口

public interface MyInterface<T> {
	T serve(T t);
}

直接用类表示泛型

public class Myinterfaceimpl implements MyInterface<Integer> {
	@Override
	public Integer serve(Integer t) {
		System.out.println(t);
		return t;
	}
}

到了main类里面再表示泛型

public class MyInterfaceimpl2<T> implements MyInterface<T> {
	@Override
	public T serve(T t) {
		System.out.println(t);
		return t;
	}
}

泛型方法

语法：<T> 返回值类型

public class MyGenericMethod {
	public <T> void show(T t) {//这里在测试类中传入什么类型，T就变成什么类型
		System.out.println(t);
	}
}

泛型集合

泛型集合

异常处理

概念：程序在运行过程中出现的不正常现象。出现异常不处理将终止程序运行
异常处理的必要性：任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失。
异常处理：Java编程语言使用异常处理机制为程序提供了异常处理的能力

异常的分类

Throwable：可抛出的，一切错误或异常的父亲，位于java.llang包中

• Error：JVM、硬件、执行逻辑错误，不能手动处理 StackOverflowError OutOfMemoryError
• Exception：程序在运行和配置中产生的问题，可处理。
  RuntimeException：运行时异常，可处理，可不处理
  CheckedException：检查时异常，必须处理

常见的运行时异常

类型	说明
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组越界异常
ClassCastException	类型转化异常
NumberFormatException	数字格式化异常
ArithmeticException	算术异常

异常的产生和传递

产生：当程序在运行时遇到不符合规范的代码或结果时，会产生异常或程序员使用throw关键字手动抛出异常
传递：按照方法的调用链反向传递，如始终没有处理异常，最终会由JVM进行默认异常处理(打印堆栈跟踪信息)。

public void operation() {
	System.out.println("------operation-------");
	divide();
	System.out.println("因为没有经过任何处理，异常按照方法的调用链反向传递，而且看不到这段话");
}
public void divide() {
	int num1 = 10, num2 = 0;
	int result = num1 / num2;
	System.out.println("结果是" + result);
	System.out.println("...");
}
@Test
public void fun1() {
	//演示异常的产生和传递
	//要求：实现输入的两个数字相除
	operation();
}

异常的处理

五个关键字

关键字	作用
try	执行可能产生异常的代码
catch	捕获异常，并处理
finally	无论是否发生异常，代码总能执行(只有在退出java虚拟机的情况下才不执行finally块)
throw	手动抛出异常
throws	声明方法可能要抛出的各种异常

召唤异常菜单：alt+shift+z

try…catch…finally

演示try…catch…finally…语句的使用

1. try{…可能发生异常的代码}
2. catch{…捕获异常，并处理异常}
3. finally{…有没有发生异常都会执行的代码}

多重catch

1. 子类异常在前，父类异常在后
2. 发生异常逐个匹配
3. 只执行第一个与异常类型匹配的语句

try…finally…
不能处理异常，可以释放资源，把异常向上抛出

int num1 = 10, num2 = 0;
int result = 0;//把result放到try里面了，所以要在外面声明
try {
	result = num1 / num2;
	//System.exit(0);//手动退出jvm
	} catch(NullPointerException e) {//这里无法捕获异常
	System.out.println(e.getMessage());
} catch (Exception e) {//Exception是所有异常的父类，可以捕获异常
	//下面这两个都可以打印出异常信息
	//e.printStackTrace();
	System.out.println(e.getMessage());
}finally{
	System.out.println("释放资源，除非手动退出jvm，不然都会执行");
}
System.out.println("结果是" + result);
System.out.println("...");

声明异常：throws

如果抛出CheckedException表示这个方法里肯定会有异常，调用者必须去处理，不处理就会报错。而如果是RuntimeException这类就可以不处理
使用原则：底层代码向上声明或者抛出异常，最上层一点要处理异常，否则程序中断

public void divide() throws ArithmeticException, Exception {//这里如果抛出Exception则必须在主函数中进行想应的处理
	int num1 = 10, num2 = 0;
	int result = num1 / num2;
	System.out.println("结果是" + result);
	System.out.println("...");
}
@Test
public void fun() throws Exception {//这里直接给了JVM相当于没有进行异常处理
	//throws声明异常
	divide();
}

抛出异常throw

除了系统自动抛出异常外，有些问题需要程序员自行抛出异常
throw 异常对象

public class Person {
	private int age;
	public Person() {}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age <= 120) {
			this.age = age;
		}
		else {//抛出异常
			throw new RuntimeException("输入年龄不符合要求");
			//这里用检查类异常需要咋子setAge函数后面用throws声明
		}
	}
}
	@Test
	public void fun4() {
		Person p = new Person();
		p.setAge(200);
		System.out.println(p.getAge());
	}

自定义异常

需要继承Exception或Exception的子类，常用RuntimeException
作用：可以区分，比如造一个AgeException可以确认就是和年龄有关
必须提供的构造方法

1. 无参数构造方法
2. String message参数的构造方法

public class AgeException extends RuntimeException {
	//简单点要一个带参的和一个无参的也可以
	public AgeException() {
		super();
	}
	public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}
	public AgeException(String message, Throwable cause) {
		super(message, cause);
	}
	public AgeException(String message) {
		super(message);
	}
	public AgeException(Throwable cause) {
		super(cause);
	}
}

方法覆盖(重写)

带有异常声明的方法的覆盖

• 方法名、参数列表、返回值类型必须和父类相同
• 子类的访问修饰符合父类相同或是比父类更宽
• 子类中的方法，不能抛出比父类更多、更宽的检查时异常