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

String

String概述

public void fun1() {
    String name = "lisi";name = "zhangsan";String name2 = "zhangsan";//只在方法池里面创建name和name2System.out.println(name == name2);//trueString name3 = new String("zhangsan");//产生两个对象，堆、池中各存储一个System.out.println(name == name3);//falseSystem.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,containsSystem.out.println(str.length());//23System.out.println(str.charAt(str.length() - 1));//a//如果超出会StringIndexOutOfBoundsExceptionSystem.out.println(str.contains("是世界上") + " " + str.contains("是世界下"));//true false//toCharArray,indexOf,lastIndexOfchar[] s = str.toCharArray();for(char i:s)System.out.print(i + ",");//J,a,v,a,是,世,界,上,最,好,的,编,程,语,言,System.out.println(str.indexOf("是世界上"));//4，参数可以是char或者StringSystem.out.println(str.lastIndexOf('v'));//21 最后一次出现System.out.println(str.indexOf("jabc"));//-1 没有返回-1System.out.println(str.indexOf("Java", 6));//10 从第六个字符开始找//trim,toUpperCase,endsWithString str2 = " i love 看电视 ";System.out.println(str2.trim());//i love 看电视 输出后str2字符串没有改变System.out.println(str.toUpperCase());//JAVA是世界上最好JAVA的编程语言JAVASystem.out.println(str2.endsWith("看电视"));//falseSystem.out.println(str2.trim().endsWith("看电视"));//true//replace,splitSystem.out.println(str.replace('J', 'j'));//可以用char或者Stringstr = "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));//1742long 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));//4long 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.09999999999999998double 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.1BigDecimal r2 = bd1.add(bd2);//加法System.out.println(r2);//1.9BigDecimal r3 = bd1.multiply(bd2);//乘法System.out.println(r3);//0.90BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));//除法(1.4 - 0.5) / 0.9System.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;}@Overridepublic String toString() {
    return "Car [brand=" + brand + ", t=" + t + "]";}
}

package cn.edu.tyut.demo;import org.junit.Test;public class CarTest {
    @Testpublic 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> {
    @Overridepublic Integer serve(Integer t) {
    System.out.println(t);return t;}
}

到了main类里面再表示泛型

public class MyInterfaceimpl2<T> implements MyInterface<T> {
    @Overridepublic 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声明}}
}@Testpublic 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);}
}

方法覆盖(重写)

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

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