java - day015 - 手写双向链表, 异常(续), IO(输入输出)

类的内存分配

加载到方法区
对象在堆内存
局部变量在栈内存

判断真实类型,在方法区加载的类

对象.getClass();
类名.class;

手写双向链表

package day1501_手写双向链表;

//  链表类
public class SXLianBiao<T> {
    
    private Node first; // 头部节点, 初始 null
    private Node last;  // 尾部节点, 初始 null
    
    private int size;   // 节点数量,初始值 0
    
    
    public void add(T value) {
        
        Node n = new Node();
        n.value = value; //  数据封装到 n
        
        if (size == 0) { // 添加第一个node 对象
            n.prev = n;      //  n向前引用n
            n.next = n;      //  n向后引用n
            
            this.first = n;  // n 是头部节点
            this.last = n;   // n 也是尾部节点
            
        }else {
            n.prev = this.last;
            n.next = this.first;
            this.last.next = n;
            this.first.prev = n;
            this.last = n;
            
        }
        
        this.size++;
    }
    
    public T get(int index) {
        
        
        Node n = getNode(index);
        
        return n.value;
    }
    
    private SXLianBiao<T>.Node getNode(int index) {
        // i越界
        // 取头尾
        // 取中间
        
        if (index < 0 || index >= this.size) {
            throw new IndexOutOfBoundsException(""+index+"越界");
        }
        
        if (index == 0) {
            return this.first;
        }else if (index == this.size-1) {
            return this.last;
        }
        
        
        Node n = null;
        
        if (index < this.size/2) { // 前边一半
            // n 引用first
            n = this.first;
            // 从 j 到 index
            for (int j = 1; j < index; j++) {
                n = n.next;
            }
            
            return n;
            
        }else { // 后面一半
            n = this.last;
            for (int j = this.size-2; j >= index ; j--) {
                n = n.prev;
            }
        }
        
        return n;
    }

    public int size() {
        return size;
    }
    
    // 内部类, 封装节点数据
    // 节点类,辅助外部双向链表对象
    // 来封装局部数据
    private class Node{
        T value;     // 节点中封装的数据
        Node prev;   // 引用前一个节点对象
        Node next;   // 引用后一个节点对象
    }
}

异常

异常信息

类型
消息
行号

继承结构

Throwable

Error
Exception

其他Exception
RuntimeException

异常的捕获

try-catch-finally

throws

设置异常的抛出管道

throw

手动抛出异常

RuntimeException

默认抛出管道
不强制处理,称为非检查异常

其他异常

强制处理
必须二选一

try-catch捕获
或者添加异常管道 throws

也叫做检查异常

异常的包装

捕获的异常,包装成另一种类型,再抛出
使用场景

不能抛出的异常,包装成可以抛出的异常再抛出
异常简化- 把多种类型的异常,简化成一种

重写方法时, 异常管道不能比父类方法多

自定义异常

现有的异常类型, 不能标识业务中遇到的所有的错误情况

程序内存数据的输入输出
内存数据导出到磁盘文件是输出; output
磁盘文件数据导入内存, 是输入; input
java.io包

File
InputStream / OutputStream
FileInputStream / FileOutputStream
ObjectInputStream / ObjectOutputStream
Reader / Writer
InputStreamReader / OutputStreamWriter
FileReader / FileWriter
BuffereadReader
PrintStream / PrintWriter

File

封装一个磁盘路径字符串
- 文件路径
- 文件夹路径
- 不存在的路径
提供对文件或文件夹的一下操作方法
创建对象

new File("磁盘路径");
new File("d:/abc", "a.txt");

方法

文件或文件夹属性

length();
- 文件字节量 / 1024 = Kb / 1024 = Mb
- 对文件夹无效
getName();
- 文件名
getParent();
- 父目录
getLastModified();
- 最后修改时间,毫秒值
isFile(); // 是否是文件
isDirectory(); // 是否是文件夹
exists(); // 是否存在

创建/删除文件或文件夹

createNewFile();
- 新建文件
  - 文件已存在,返回 false
  - 文件夹不存在, 会出现异常
mkdirs();

mkdir();
- 创建单层目录
delete();

list();
- 对目录列表的String[]数组, 存放文件 ,目录名
listFiles();

获得file[]数组,存放文件,目录的封装对象
对文件, 不存在的路径,无权进入的目录,列表方法返回 null

流 stream

字节数据的读写, 抽象成数据在管道中流动
流是单方向的

输入流,只能用来读取数据
输出流,从内存输出数据

数据只能从头到尾流动一次

InputStream / OutputStream 抽象类
- 子类, FileInputStream / OutputStream
- 文件流, 直接插在文件上,直接读写文件数据
- 方法
  - write(int b);
    - int的四个字节,只输出末尾的一个字节
    - [1][2][3][4] ---> [4]
    - 所以只能读取0~255 范围内的值
  - write(byte[] , from, length);
  - ```
  // 新建文件输出流
  FileOutputStream outF = new FileOutputStream("/Users/dingzhijie/Desktop/file.txt");
  不管文件是否存在,都会新建一个空文件
  文件夹不存在会出现异常
```
- read();
  - 读取一个字节值, 补3个0字节,转成 int
  - 读取结束,再读取,会返回-1,标识结束
- read();

posted @ 2019-07-28 11:56 Dingzhijie 阅读(227) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Dingzhijie

java - day015 - 手写双向链表, 异常(续), IO(输入输出)

公告