大数据预科班13

最新推荐文章于 2021-05-25 23:15:07 发布

乘风御浪云帆之上

最新推荐文章于 2021-05-25 23:15:07 发布

阅读量508

点赞数

分类专栏：达内实训大数据学习痕迹

本文链接：https://blog.csdn.net/eieiei438/article/details/78035418

版权

大数据学习痕迹同时被 2 个专栏收录

102 篇文章 5 订阅

订阅专栏

达内实训

94 篇文章 7 订阅

订阅专栏

大数据预科班13

复习

包装类

1. 每种基本类型都对应了一种形式
2. 自动封箱、拆箱

数学类

1. Math
2. BigDecimal精确运算时参数为字符串

日期类

1. Date(字符串--日期)
2. Calendar

异常

引入

public static void main(String[] args){
    try{
    String msg = readFile("E://a.txt");
    }catch(PathNotExistsException pe){
        //处理问题
    }catch(FileCannotReadException pe){

    }
}

 public static String readFile(String path) throws PathNotExistsException,FileCannotReadException{
    //判断路径是否存在
    //判断文件是否损坏

    //引出异常处理
    //判断路径是否存在--抛出异常
    throw new PathNotExistsException();
    //判断文件是否损坏--抛出异常
    throw new FileNotReadException();
}

异常是一套用于反馈和处理问题的机制
顶级父类Throwable
Throwable的子类【Error】【Exception】

1. Error合理的代码出现不能处理错误--不对Error进行处理
2. 异常，合理应用程序可以捕获

异常

1. 编译时异常--语法错误--一旦出现，必须处理--要么抛出异常；要么捕获完进行处理；
2. 运行时异常--编译时无错，运行时异常；语法没错，逻辑有错；--可以处理，也可以不处理
    ArithmeticException
    ArrayIndexOutOfBoundesException
    小父类：RuntimeException
3. 绝大多数的异常是编译时异常

自定义异常

class PathNotExistException extends Exception{
    private String message;
    public PathNotExistException(){

    }
    public PathNotExistException(String message){
        this.message=message;
        //方式二：super(message);
    }
    public String getMessage(){
        return this.message;
    }

}

打印栈轨迹e.printStactPrin
异常怎么看--自己写的-->底层-->自己写的（先深入，后冒泡）

1. 看异常名称
2. 异常信息
3. 异常栈轨迹倒着看

如果异常最终抛给主函数（main函数），默认打印栈轨迹

如果一个类继承Exception，默认为编译时异常
如果一个类继承RuntimeException为运行时异常

异常的捕获处理

1. 如果有多个异常，可以有多个catch来捕获
2. 也可以一个来捕获Exception统一来处理//向上造型
3. 多异常
4. 分组捕获(这种方式为jdk1.7及之后)
    catch(Exception1 | Exception2 e){

    }catch(Exception3 | Exception4 e1){

    }
5. 如果抛出的是父类异常（Exception），那么要求必须捕获父类异常；或者捕获所有子类（不太靠谱，太多了）
6. 捕获异常时，从小到大，即先捕获小异常，载捕获大的异常。

异常与方法的重载与重写

1. 方法重载--异常不影响方法的重载
2. 方法覆盖--要求子类重写的方法抛出的异常的范围不能超过父类方法的子类；
    要求的是编译时异常

重写：另外一小--异常的抛出
方法重载：
1. 一个类中、方法名一致，参数列表不一致，重载和修饰符，返回值类型，异常都没有关系--编译时多态
2. 在父子类存在方法签名完全一致的普通方法，遵循“两等两小一大”规则--运行时多态

finally无论如何，都会执行一次，

1. 特点：无论代码中出现异常与否，都会执行finally，进行善后工作

finally例子

try代码块中不一定全部执行（编译时检查）

//报错：两个finally
try{

}catch(Exception e){

}finally{
    return 2;
    try{
    }catch{
    }finally{
        return 1;
    }

}

finally坑

编译和执行时
eg1：
public class Test { 
public static void main(String[] args) { 
        System.out 
.println("return value of getValue(): " + getValue 
()); 
} 

public static int getValue() { 
        try { 
                 return 0; 
        } finally { 
                 return 1; 
        } 
} 
} 
执行结果：return value of getValue(): 1 

eg2：
public class Test { 
public static void main(String[] args) { 
        System.out 
.println("return value of getValue(): " + getValue 
()); 
} 

public static int getValue() { 
        int i = 1; 
        try { 
                 return i; 
        } finally { 
                 i++; 
        } 
} 
} 
执行结果：return value of getValue(): 1

实际上，Java 虚拟机会把 finally 语句块作为 subroutine（对于这个 subroutine 不知该如何翻译为好，干脆就不翻译了，免得产生歧义和误解。）直接插入到 try 语句块或者 catch 语句块的控制转移语句之前。但是，还有另外一个不可忽视的因素，那就是在执行 subroutine（也就是 finally 语句块）之前，try 或者 catch 语句块会保留其返回值到本地变量表（Local Variable Table）中。待 subroutine 执行完毕之后，再恢复保留的返回值到操作数栈中，然后通过 return 或者 throw 语句将其返回给该方法的调用者（invoker）。请注意，前文中我们曾经提到过 return、throw 和 break、continue 的区别，对于这条规则（保留返回值），只适用于 return 和 throw 语句，不适用于 break 和 continue 语句，因为它们根本就没有返回值。

处理异常

1. 抛出
2. 捕获并处理

编译和运行

1. 对于程序而言，是从上到下，从左到右，先编译完再运行；
2. 注意基本类型数据和引用数据类型

异常的真实处理

开发阶段：碰到异常，捕获这个异常，获取这个异常的栈轨迹，会抛出RuntimeException
项目已经上线，捕获异常之后，跳转一个统一的错误页面，
项目更新：

1. 需求驱动
2. 打补丁（改错）--记录错误日志--先记录日志，再跳转到统一错误界面
    warring（不是很关心）
    error（需要关心）

集合

用于存储一组数据的大小不定的容器
Collection--集合的顶级接口

1. Collection<String> c的数据类型为Collection；c表示集合中存储的类型是String
2. <E>称之为“泛指类型”--声明集合的时候用泛型临时代替具体类型
3. 集合中只能存储对象

顶级Collection接口通用方法

1. 添加元素(add)
2. 删除元素（remove）--不存在删除时，不报错；在删除之前先判断元素是否存在，不在则跳过；
3. 是否存在某元素（contains)--true/false
4. 遍历集合--增强for循环（本质为迭代器）
5. 清空集合（clean）
6. equals和hashCode与子类相关
7. 判断空集合（isEmpty）
8. 获取元素个数（size）
9. 转化为数组(toArray)--返回Object[],不能用String[] ss=集合.toArray();
    集合底层--存储元素以Object
    Object[] obj=new Object[];
10. 集合转化为确定类型的数组 String[] ss=集合.toArray[new String[0]];
    底层会判断参数的长度，与集合元素的个数比较，如果参数的长度长，
    则用参数对象；否则底层根据集合的元素个数创建一个等大的数组。
    采用0好：不会浪费内存

集合元素的个数和集合的大小是两个概念（10（4））

List

有序的Collection，通过下标访问，从0开始
特点

1. 有序
2. 可重复

通用方法的与Collection相同

1. 添加元素list.add(元素);
2. 向列表的指定元素插入指定元素list.add(位置，元素)

不同的

1. equals判断两个集合是否相等【顺序+equals】--在比较两个集合时，实际上是依次比较对应位置上的元素的equals是否一致
2. get（下标）获取指定元素的元素
3. indexOf（元素）获取指定元素在列表中第一次出现的位置，元素不存在则返回-1
4. remove（下标）移除指定下标的元素
5. set(index,元素)替换指定下标上的元素
6. subList截取子列表

ArrayList

基于数组Object[]
默认初始容量为10，扩容--在上一次的基础上累加一半
内存连续

练习

1. 数组实现简易版的ArrayList--String--add/remove/set/indexof/contain/isEmpty/size/toString

public class ListExer {

    // 存储元素
    private String[] data;

    // 记录已经存储的元素个数
    private int size = 0;

    public ListExer() {
        data = new String[10];
    }

    public ListExer(int capacity) {
        // 需要判断容量是否符合事实
        if (capacity < 0) {
            capacity = 10;
        }
        data = new String[capacity];
    }

    private void grow() {

        if (data.length <= 1) {
            data = Arrays.copyOf(data, data.length + 1);
            return;
        }

        data = Arrays.copyOf(data, data.length + (data.length >> 1));

    }

    public void add(String s) {

        // 判断是否需要扩容
        if (size >= data.length) {
            this.grow();
        }

        data[size] = s;

        size++;

    }

    public void add(int index, String s) {

        // 判断下标是否越界
        if (index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }

        // 判断是否需要扩容
        if (size >= data.length) {
            this.grow();
        }

        // 插入元素
        // for (int i = size - 1; i >= index; i--) {
        // data[i + 1] = data[i];
        // }
        System.arraycopy(data, index, data, index + 1, size - index);

        data[index] = s;

        size++;
    }

    public void remove(String s) {

        // 获取这个元素第一次出现的下标
        int index = this.indexOf(s);

        // 判断这个下标是否存在
        if (index != -1) {
            this.remove(index);
        }

    }

    private void out(int index) {
        // 判断下标越界
        if (index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
    }

    public void remove(int index) {

        this.out(index);

        // for (int i = index; i < size - 1; i++) {
        // data[i] = data[i + 1];
        // }

        System.arraycopy(data, index + 1, data, index, size - index - 1);

        size--;
    }

    public void set(int index, String s) {

        this.out(index);

        data[index] = s;

    }

    public String get(int index) {

        this.out(index);

        return data[index];

    }

    public boolean contains(String s) {

        return this.indexOf(s) != -1;

    }

    public boolean isEmpty() {

        return size <= 0;

    }

    public int indexOf(String s) {

        for (int i = 0; i < size; i++) {
            if (s == data[i] || s != null && s.equals(data[i])) {
                return i;
            }
        }

        return -1;

    }

    public int size() {
        return size;
    }

    public String toString() {

        StringBuilder sb = new StringBuilder("[");

        for (int i = 0; i < size; i++) {
            sb.append(data[i]).append(", ");
        }

        String str = sb.toString();

        if (str.length() > 1) {

            str = str.substring(0, str.length() - 2);
        }

        return str += "]";

    }

    public static void main(String[] args) {

        ListExer le = new ListExer(3);

        le.add("a");
        le.add("b");
        le.add("c");

        le.add(0,"e");

        le.remove(0);

        System.out.println(le);

    }

}