刻苦学习Java第十二天【打卡贴】

开始简单记笔记 不写过多内容~

 

=====================================================

异常处理

ctrl+alt+t 选中try-catch

Java语言中，将程序执行中发生的不正常情况称为“异常”

（逻辑和语法错误不算）

Error（错误）：Java虚拟机无法解决的严重问题，程序崩溃

Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以针对性的代码进行处理

Exception分两类：运行时异常、编译时异常

常见运行时异常

NullPointException空指针异常

程序在需要对象的地方使用null

ArithmeticException数学运算异常

ArrayIndexOutOfBounds数组下标越界异常

ClassCastException试图将对象强制转换为不是子类的实例时

NumberFormatException数字格式不正确异常

异常处理

try-catch-finally ：try包含代码catch处理异常finally必须执行

throws：向上抛，知道JVM，JVM会直接停掉chengxu

二选一，默认throws

就是发生异常try中的代码不执行，直接执行catch，但finally不管怎么样都会执行

1. 如果try代码块可能有多个异常，可以使用多个catch分别捕获异常分别做处理，要求子类异常在前，父类异常在后

2. finally执行完程序该崩溃还是崩溃

3. throws是方法中可能发生某种异常，但是不能确定如何处理，此方法显示的声明异常，表明该方法不对异常处理，由调用者处理

4. 可以声明抛出异常的列表，throws声明的是可以产生的异常或者它的父类

throws关键字后可以是异常列表，即可以抛出多个异常

5. 子类重写的方法抛出的异常是父类抛出的一致或者是该异常的子类

6. 有try-catch就不用throws了

7. 一个方法调用一个有编译异常的方法，该方法必须处理该异常

8. 运行异常可以默认处理（默认处理机制），编译异常要显示处理

自定义异常

没有在Throwable中定义的错误，自己定义异常

定义类名 继承 Exception/RuntimeException

可以通过构造器设定信息

一般时候自定义的是RuntimeException，好处是使用默认处理机制比较方便

throw和throws

	意义	位置	后面跟的东西
throws	异常处理的一种方式	方法声明处	异常类型
throw	手动生成异常对象的关键字	方法体中	异常对象

包装类 Wrapper

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

 

 包装类和基本数据类型转换（int Integer）

1. jdk5以前是手动装箱和拆箱 装箱：基本类型->包装类型 反之拆箱

2. jdk5（含）是自动拆箱和装箱

3. 自动装箱底层调用ValueOf方法

手动装箱

Integer integer1 =  new Integer(n);

Integer integer2 = Integer.valueOf(n);

手动拆箱

int i = integer.intValue();

自动装箱

Integer integer3 = n;

自动拆箱

int n = integer;

Integer和String相互转换

public class WrapperVsString {
    public static void main(String[] args) {
        //包装类->String
        Integer n = 1;
        String str1 = n + "";
        String str2 = n.toString();
        String str3 = String.valueOf(n);
        //String->包装类
        String str4 = "123";
        Integer i1 = Integer.parseInt(str4);
        Integer i2 = new Integer(str4);
    }
}

小知识点（阅读源码）！！！（结果为false true false）

在-128~127直接从数组返回值，超过范围就new！！！

new的话对象就不同

只要有基本数据类型，就判断值是否相等，比如比较int和integer的值

public class Method1 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);
        Integer a = 128;
        int b = 128;
        System.out.println(a==b);

    }
}

String类

 用双引号引起的字符序列 用Unicode编码 一个字符占两个字节 实现构造器重载 实现重要接口

可以串行化代表数据可以在网络传播Serialable 可以比较Comparable

 String是final类

String有属性private final char value[];

用于存放字符串内容 final类型不可修改->指地址！！！内容可修改！！！

举例：

1. String s1 = "hello"; s1 = "haha";

不是改变hello的内容，而是在方法区创建新的haha，再指向它，创建了两个对象

2. String a = "hello" + "abc";

编译器做一个优化，判断创建常量池的对象，是否有引用指向

String a = "hello" + "abc"; =>String a = "helloabc";

3. 

public class String01 {
    public static void main(String[] args) {
        String a = "hello";
        String b = "abc";
        //1. 先创建一个 StringBuilder sb = new StringBuilder();
        //2. 执行sb.append("hello");
        //3. 执行sb.append("abc");
        //4. String c = sb.toString();
        //最后c指向堆中的对象(String)value[]->池中"helloabc"
        String c = a + b;
    }
}

创建方式

String s = "XXX";

String s = new String("XXX");

intern方法：返回常量池中的地址

String常用方法

equals //区分大小写 判断内容是否相等

equalsIgnoreCase //忽略大小判断内容是否相等

length //获取字符的个数 字符串的长度

indexOf //获取字符在字符串中第一次出现的索引，从0开始，找不到返回-1 可以是字符串

lastIndexOf //获取字符在字符串中最后一次出现的索引，从0开始，找不到返回-1

substring //截取范围内的子串 substring(6):从6开始截距到最后 substring(0,5):截取0~5-1

toUpperCase //转换成大写

toLowerCase //转换成小写

concat //拼接

replace //替换 s.replace(a,b) s中所有a内容替换成b  s.replace()对s没有影响 要接收

split //分割字符串 要注意转义字符！！

public class StringMethod {
    public static void main(String[] args) {
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        String[] split = poem.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
}

toCharArray //转成字符数组

compareTo //比较两个字符串的大小 前者大返回正数 后者大返回负数 相等返回0

比较直到出现差值->长度不同时长度相减 长度相同时为0

format //格式字符串 %s %d %.2f %c称为占位符 %.2f进行四舍五入处理

String name = "jack";

String formatStr = "我的名字是%s";

String info = String.format(formatStr, name);

StringBuffer类

String保存的是字符串常量 里面的值不能更改 每次String类的更新实际上就是修改地址 效率低

StringBuffer保存的是字符串变量 里面的值可以更改 每次String类的更新实际上就是更新内容 

不用每次更改地址 效率高 用数组存放在堆中 char[] value

StringBuffer str1 = new StringBuffer(); 16

StringBuffer str2 = new StringBuffer(100);  100

StringBuffer str3 = new StringBuffer("hello"); 21=5+16

String和StringBuffer转换

String->StringBuffer

1. StringBuffer s1 = new StringBuffer(str);

2. StringBuffer s2 = new StringBuffer();  s2.append(str);

StringBuffer->String

1. String str = s.toString();

2. String str = new String(s);

append //增加 s.append("XXX");

delete //删除 s.delete(a,b); 删除[a,b)的字符

replace //修改 s.replace(a,b,XX);  使用XX替换[a,b)的字符

indexOf //查找 s.indexOf(XX);

insert //插入 s.insert(a,XX); 在索引为a的位置插入XX，原来的自动后移

length //长度 s.length();

StringBuilder

StringBuilder提供一个与StringBuffer兼容的API，是简易替换，但不能保证同步，用在字符串缓冲区被单个线程使用得时候，如果可以优先使用该类，大多数情况比StringBuffer快

StringBuilder主要操作是append和insert

String StringBuffer StringBuilder 比较

String：不可变字符序列、效率低、但复用率高

StringBuffer：可变字符序列、效率较高（增删）、线程安全

StringBuilder：可变字符序列、效率最高、线程不安全

如果对String进行大量修改，不要用String

使用的原则

1. 如果字符串实现大量修改操作，一般用StringBuffer和StringBuilder

2. 如果字符串实现大量修改操作，单线程，一般用StringBuilder

3. 如果字符串实现大量修改操作，多线程，一般用StringBuffer

4. 如果字符串很少修改，被多个对象引用，使用String，比如配置信息

Math类

数学运算方法

abs 绝对值

pow 幂 //pow(2,4) 2的4次方

ceil 向上取整 //>=该参数的最小整数（转成double）

floor 向下取整 //<=该参数的最大整数（转成double）

round 四舍五入

sqrt 求开方

random 0~1之间的随机小数[0,1）

max 最大值

min 最小值

Arrays类

toString 返回数组的字符串形式 Arrays.toString(arr);

sort 排序（自然排序和定制排序）

自然排序:Arrays.sort(arr);

定制排序:通过传入一个接口Comparator实现定制排序

binarySearch 通过二分搜索法查找，要求必须排好

copyOf  拷贝Arrays.copyOf(arr,arr.length);

从arr数组中拷贝arr.length个元素到新数组中 

拷贝长度大于arr.length，那后面增加null 拷贝长度小于0，抛出异常

fill 数组填充 Arrays.fiil(num,n); 使用n填充num数组，可以理解为替换原来元素

equals 比较两个数组元素是否完全一致 Arrays.equals(arr1,arr2);

asList 将一组值转化为list

System类

exit 退出当前程序 exit(0); 正常退出（0表示一个正常状态）

arraycopy 复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组

arraycopy(src,0,dest,0,3); 拷贝个数不要越界

源数组 ,从源数组哪个索引位置开始拷贝,目标数组, 目标数组开始的索引位置 ,拷贝个数

currentTimeMillens：返回当前时间距1970-01-01的毫秒数

gc 垃圾回收机制