Java初级笔记No.9之Java程序实例（异常处理与数据结构）

2019年7月23日 116次阅读 来源: wenmingxing

I、异常处理

1.1 异常处理方法

使用System类的System.err.println()展示异常的处理方法，这样会显示为红色：

package example;

public class ErrPrintlnEmp {
    public static void main(String[] args) {
        try {
            throw new Exception("My Exception");
        } catch (Exception e) {
            System.err.println("Caught Exception");
            System.err.println("getMessage(): " + e.getMessage());
            System.err.println("getLocalizedMessage(): " + e.getLocalizedMessage());
            System.err.println("toString(): " + e);
            System.err.println("printStackTrace()");
            e.printStackTrace();
        }
        
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

1.2 多个异常处理（多个catch）

对异常的处理：
1、声明异常时，建议声明更为具体的异常，这样可以处理的更具体。
2、对方声明几个异常，就对应几个catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在前面。

package example;

class Demo {
    int div(int a, int b) throws ArithmeticException,ArrayIndexOutOfBoundsException {
        int[] arr = new int [a];
        System.out.println(arr[4]); //制造的第一处异常
        return a/b;     //制造的第二处异常
    }
}

public class MuliCatchEmp {
    public static void main(String[] args) {
        Demo d = new Demo();
        
        try {
            int x = d.div(4, 0);
            
            System.out.println("x="+x);
        }
        catch (ArithmeticException e) {
            System.out.println(e.toString());
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.toString());
        }
        catch (Exception e) {   //      父类 可以捕捉没有预料到的异常，只能写在子类异常代码后面一般情况是可以不写的
            System.out.println(e.toString());
        }
        
        System.out.println("Over");
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

1.3 Finally的用法

Java中的Finally关键字一般与try一起使用，在程序进入try块之后，无论程序是因为异常而终止或其他方式返回终止的，finally块的内容一定被执行。

使用finally通过e.getMessage()来捕获异常：

package example;

public class FinallyEmp {
    public static void main(String[] argc) {
        new FinallyEmp().doTheWork();
    }
    
    public void doTheWork() {
        Object o = null;
        for (int i = 0; i < 5; ++i) {
            try {
                o = makeObj(i);
            }
            catch (IllegalArgumentException e) {
                System.err.println("Error: (" + e.getMessage() + ")");
                return;
            }
            finally {
                System.err.println("都执行完毕");
                if (o == null)
                    System.exit(0);
            }
            System.out.println(o);
        }
    }
    public Object makeObj(int type) throws IllegalArgumentException {
        if (type == 1) throw new IllegalArgumentException("不是指定类型：" + type);
        return new Object();
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

1.4 多线程异常处理

下面实例展示了多线程异常处理的方法：

package example;

class MyThread extends Thread {
    public void run() {
        System.out.println("Throwing in " + "MyThread");
        throw new RuntimeException();
    }
}

public class ThreadExceptionEmp {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        
        try {
            Thread.sleep(1000);
        }
        catch(Exception x) {
            System.out.println("Caught it" + x);
        } 
        System.out.println("Exiting main");
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

1.5 自定义异常

下面实例通过继承Exception来实现自定义异常：

package example;

//自定义异常类
class WrongInputException extends Exception {
    WrongInputException(String s) {
        super(s);
    }
}

class Input {
    void method() throws WrongInputException {
        throw new WrongInputException("Wrong input");
    }
}

public class DefineExceptionEmp {
    public static void main(String[] args) {
        try {
            new Input().method();
        }
        catch(WrongInputException wie) {
            System.out.println(wie.getMessage());
        }
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

II、数据结构

2.1 在链表(LinkedList)的开头和结尾添加元素

使用LinkedList类的addFirst()和addLast()方法在链表的开头和结尾添加元素：

package example;

import java.util.LinkedList;

public class AddtoLinkedListEmp {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("1");
        lList.add("2");
        lList.add("3");
        lList.add("4");
        lList.add("5");
        
        System.out.println(lList);
        
        lList.addFirst("0");
        
        System.out.println(lList);
        
        lList.addLast("6");
        
        System.out.println(lList);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.2 获取链表（LinkedList）的第一个元素与最后一个元素

使用LinkedList类的linkedlistname.getFirest()和linkedlistname.getLast()获取链表的第一个和最后一个元素：

package datastruct;

import java.util.LinkedList;

public class LinkedListFirstLastEmp {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("100");
        lList.add("200");
        lList.add("300");
        lList.add("400");
        lList.add("500");
        
        System.out.println(lList.getFirst());
        System.out.println(lList.getLast());
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.3 删除链表中的元素

使用clear()方法来删除链表中的元素。

package datastruct;

import java.util.LinkedList;

public class LinkedListClearEmp {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("100");
        lList.add("200");
        lList.add("300");
        lList.add("400");
        lList.add("500");
        
        System.out.println(lList);
        lList.subList(2, 3).clear();
        System.out.println(lList);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.4 获取向量元素的索引值

使用Collections类的sort()方法对向量进行排序并使用binarySearch()方法获取向量元素的索引值：

package datastruct;

import java.util.Collections;
import java.util.Vector;

public class VectorIndexEmp {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("X");
        v.add("M");
        v.add("D");
        v.add("A");
        v.add("O");
        
        Collections.sort(v);
        System.out.println(v);
        
        int index = Collections.binarySearch(v, "O");
        
        System.out.println(index);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.5 链表元素查找

使用linkedlistname.indexof(element)和linkedlistname.Lastindexof(element)方法在链表中获取元素第一次和最后一次出现的位置：

package datastruct;

import java.util.LinkedList;

public class LinkedListIndex {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        
        lList.add("1");
        lList.add("2");
        lList.add("3");
        lList.add("4");
        lList.add("5");
        
        System.out.println("2第一次出现的位置是：" + lList.indexOf("2"));
        System.out.println("2最后一次出现的位置是：" + lList.lastIndexOf("2"));
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.6 Queue的用法
package datastruct;

import java.util.LinkedList;
import java.util.Queue;

public class queueEmp {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        
        for (String q : queue)
            System.out.println(q);
        
        System.out.println("---------------------");
        System.out.println("poll = " + queue.poll());   //返回第一个元素，并从队列中删除
        
        for (String q : queue)
            System.out.println(q);
        
        System.out.println("---------------------");
        System.out.println("element = " + queue.element()); //返回第一个元素
        
        for (String q : queue)
            System.out.println(q);
        
        System.out.println("---------------------");
        System.out.println("peek = " + queue.peek());   //返回第一个元素
        
        for (String q : queue)
            System.out.println(q);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.7 获取向量最大元素

使用Vector类的add()方法及Collections类的Collections.max()方法获取向量最大元素：

package datastruct;

import java.util.Collections;
import java.util.Vector;

public class VectorMaxEmp {
    public static void main(String[] args) {
        Vector v = new Vector();
        
        v.add(new Double(3.1415));
        v.add(new Double(3.14159));
        v.add(new Double(3.1));
        
        Object o = Collections.max(v);
        
        System.out.println(o);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.8 链表修改

使用listname.add()和listname.set()方法来修改链表中的元素：

package datastruct;

import java.util.LinkedList;

public class LinkedListSetEmp {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        
        lList.add("a");
        lList.add("b");
        lList.add("c");
        lList.add("d");
        lList.add("e");
        
        System.out.println(lList);
        
        lList.set(2, "H");
        
        System.out.println(lList);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

2.9 旋转向量

使用swap()方法来旋转向量：

package datastruct;

import java.util.Collections;
import java.util.Vector;

public class VectorSwapEmp {
    public static void main(String[] args) {
        Vector v = new Vector();
        
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
        
        System.out.println(v);
        
        Collections.swap(v, 0, 3);
        
        System.out.println(v);
    }
}

《Java初级笔记No.9之Java程序实例（异常处理与数据结构）》

    原文作者：wenmingxing
    原文地址: https://www.jianshu.com/p/97a850a97cf7
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞