基础学习笔记 + 代码实例 （3）

一、Java异常处理机制 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 异常学习测试类 
5.  * @history 
6.  */  
7. public class ExceptionDemo {  
8.     /** 
9.      *@description  
10.      *@param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // Throable类是所有错误和异常的根基类  
14.         // Throable类下两个重要的子类Exception和Error  
15.           
16.         // 1、编写一个常见的异常例子  
17.         try {  
18.             int i = 1;  
19.             int j = 0;  
20.             int r = i / j;  
21.         } catch (ArithmeticException ae) {  
22.             ae.printStackTrace();  
23.             // Exception in thread "main" java.lang.ArithmeticException: / by zero  
24.         }  
25.           
26.         // 2、catch多个种类的异常例子  
27.         String s1 = "1";  
28.         String s2 = "0"; // String s2 = "eclipse";  
29.         try{  
30.             int i1 = Integer.parseInt(s1); // 字符串解析成数字  
31.             int i2 = Integer.parseInt(s2);  
32.             int temp = i1/i2;  
33.         } catch(ArithmeticException ae){  
34.             ae.printStackTrace(); // 分母为0异常捕获  
35.         } catch(NumberFormatException nfe){  
36.             nfe.printStackTrace(); // 数字格式转换异常捕获  
37.         }  
38.           
39.         // 3、异常可以往上抛出去例子  
40.         int[] array = new int[5];  
41.         try{  
42.             int i3 = array[5]; // 数组越界异常  
43.         } catch(ArrayIndexOutOfBoundsException aiobe){   
44.             // 捕获异常后往外抛出  
45.             // 在某一层统一处理掉这些异常，比如可以采用拦截器  
46.             throw aiobe;  
47.         }  
48.           
49.         // 4、自定义异常类，继承自Exception类  
50.         try{  
51.             // 实例化内部类对象比较特殊点  
52.             ExceptionDemo out = new ExceptionDemo(); // 先实例化外部类对象  
53.             throw out.new MyException("hello-exception"); // 再实例化内部类对象  
54.         } catch(MyException me){  
55.             // hello-exception  
56.             System.out.println(me.getLocalizedMessage());  
57.         }  
58.     }  
59.     // 自定义异常类  
60.     class MyException extends Exception{  
61.         public MyException(String msg){  
62.             super(msg);  
63.         }  
64.     }  
65.   
66. }  

二、 Java多线程编程 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description Java多线程编程入门测试类 
5.  * @history 
6.  */  
7. // 方法一、继承线程类Thread  
8. class MyThread extends Thread{  
9.     public MyThread(String threadName){ // 设置当前线程的名称  
10.         currentThread().setName(threadName);  
11.     }  
12.     public void run(){  
13.         System.out.println(Thread.currentThread().getName());  
14.     }  
15. }  
16. // 方法二、实现Runnable接口  
17. class MyThread2 implements Runnable{  
18.     public void run() {  
19.         System.out.println(Thread.currentThread().getName());  
20.     }  
21. }  
22. public class SynTestDemo {  
23.     /** 
24.      *@description  
25.      *@param args 
26.      */  
27.     public static void main(String[] args) {  
28.         // 1、线程的定义、线程和进程的区别、为什么要引入线程等  
29.         // 2、Java实现多线程的方法主要有两种：继承Thread类和实现Runnable接口  
30.         // 3、多个线程并发同时访问公共的临界资源的时候需要进行同步处理，过多的同步不当会造成死锁问题  
31.           
32.         MyThread t1 = new MyThread("hello-thread");  
33.         t1.start(); // 启动线程1  
34.           
35.         MyThread2 t2 = new MyThread2();  
36.         new Thread(t2).start(); // 启动线程2  
37.     }  
38. }  

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 多线程编程演练例子 
5.  * @history 
6.  */  
7. public class SynABCTest {  
8.     /** 
9.      * @description 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // 通过具体的例子来加深对多线程的认识  
14.         // 问题为：循环打印10遍ABCABC...ABC  
15.         PrintThread p1 = new PrintThread(0, "A"); // 参数为线程标志和打印的内容  
16.         PrintThread p2 = new PrintThread(1, "B");  
17.         PrintThread p3 = new PrintThread(2, "C");  
18.         // 启动线程A B C  
19.         new Thread(p1).start();  
20.         new Thread(p2).start();  
21.         new Thread(p3).start();  
22.     }  
23. }  
24. // 采用实现接口的方式定义线程类  
25. class PrintThread implements Runnable {  
26.     // 标记执行当前应该执行的线程0、1、2依次表示A B C  
27.     // 定义成静态变量，因为线程各自使用独立的栈  
28.     private static int index = 0;   
29.     private static Object lock = new Object();  
30.     private int key = 0; // 线程标志  
31.     private int print = 0; // 打印的次数  
32.     private String name; // 打印的内容  
33.       
34.     public PrintThread(int key, String name) {  
35.         this.key = key;  
36.         this.name = name;  
37.     }  
38.       
39.     public void run() {  
40.         while (this.print < 10) { // 打印的次数  
41.             synchronized (lock) {  
42.                 while (!(this.key == index % 3)) { // 从0开始执行  
43.                     try {  
44.                         lock.wait(); // 阻塞掉  
45.                     } catch (InterruptedException e) {  
46.                         e.printStackTrace();  
47.                     }  
48.                 }  
49.                 System.out.print(this.name); // 打印出内容  
50.                 this.print++; // 当前线程打印次数++  
51.                 index++; // 线程切换下一个  
52.                 lock.notifyAll(); // 唤醒其他等待的线程  
53.             }  
54.         }  
55.     }  
56. }  

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description 死锁模拟测试类 
5.  * @history 
6.  */  
7. public class DeadLockTest {  
8.     /** 
9.      *@description  
10.      *@param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // 过多的同步操作可能会造成死锁问题，死锁产生的原因是形成了环路等待  
14.         // 通过两个线程对象进行模拟，线程A完成一个操作需要资源1和资源2，线程B也是一样  
15.         // 在资源分配的过程中，线程A占用了资源1，等待资源2，此时此刻线程B占用了资源2，等待资源1  
16.         DeadThread dt1 = new DeadThread("1", true);  
17.         DeadThread dt2 = new DeadThread("2", false);  
18.         new Thread(dt1).start(); // 启动线程1  
19.         new Thread(dt2).start(); // 启动线程2  
20.     }  
21.     // 定义静态内部类、类似外部类了  
22.     static class DeadThread implements Runnable{  
23.         /** 
24.          * 定义资源1和资源2 lock1和lock2 
25.          */  
26.         private static Object lock1 = new Object();  
27.         private static Object lock2 = new Object();  
28.         private String name; // 线程名称  
29.         private boolean run; // 执行顺序标记  
30.         public DeadThread(String name,boolean run){  
31.             this.name = name;  
32.             this.run = run;  
33.         }  
34.         @Override  
35.         public void run() {  
36.             if(this.run){  
37.                 // 线程1先占用资源1  
38.                 synchronized(lock1){  
39.                     try {  
40.                         System.out.println("thread1 used lock1");  
41.                         Thread.sleep(3000); // 暂时休眠3秒  
42.                     } catch (InterruptedException e) {  
43.                         e.printStackTrace();  
44.                     }  
45.                     // 线程1再去申请资源2，此时资源2已经被线程2占用着不放了  
46.                     synchronized(lock2){  
47.                         System.out.println("hello dead-lock");  
48.                     }  
49.                 }  
50.             }else{  
51.                 // 线程2先占用资源2  
52.                 synchronized(lock2){  
53.                     try {  
54.                         System.out.println("thread2 used lock2");  
55.                         Thread.sleep(3000); // 线程2暂时休眠3秒  
56.                     } catch (InterruptedException e) {  
57.                         e.printStackTrace();  
58.                     }   
59.                     // 线程2再去申请资源1，此时资源1已经被线程1占用着不放了  
60.                     synchronized(lock1){  
61.                         System.out.println("hello dead-lock");  
62.                     }  
63.                 }  
64.             }  
65.         }  
66.     }  
67.   
68. }  

Java代码  

1. class MyThread1 implements Runnable {  
2.     private boolean flag = true; // 定义标志位  
3.     public void run() {  
4.         int i = 0;  
5.         while (this.flag) {  
6.             System.out.println(Thread.currentThread().getName() + "运行，i = "  
7.                     + (i++));  
8.         }  
9.     }  
10.     public void stop() {  
11.         this.flag = false; // 修改标志位  
12.     }  
13. }  
14.   
15. /** 
16.  * @author Administrator 
17.  *  
18.  * @description 通过修改标记位停止线程 
19.  * @history 
20.  */  
21. public class ThreadStopDemo {  
22.     public static void main(String[] args) {  
23.         MyThread1 my = new MyThread1();  
24.         Thread t = new Thread(my, "线程"); // 建立线程对象  
25.         t.start(); // 启动线程  
26.         try {  
27.             Thread.sleep(50); // 适当地延迟下  
28.         } catch (Exception e) {  
29.             e.printStackTrace();  
30.         }  
31.         my.stop(); // 修改标志位，停止运行  
32.     }  
33. }  

三、 Java常用类学习代码 

Java代码  

1. /** 
2.  * @author Administrator 
3.  *  
4.  * @description Java常用类-StringBuffer学习 
5.  * @history 
6.  */  
7. public class StringBufferTest {  
8.     /** 
9.      *@description  
10.      *@param args 
11.      */  
12.     public static void main(String[] args) {  
13.         // StringBuffer类在处理字符串时候比较常用  
14.         // 1、StringBuffer类的append方法  
15.         // 具体的方法参数个数和类型，请参看JDK的API即可  
16.         StringBuffer sb = new StringBuffer();  
17.         sb.append("helloworld"); // string类型  
18.         sb.append("\n"); // 特殊符号，换行符  
19.         sb.append(false); // boolean类型  
20.         sb.append('j'); // char类型  
21.         sb.append(1.50d); // double类型  
22.         // ... 等等  
23.         sb.insert(0, "eclipse"); // 在index出插入值  
24.         sb.reverse(); // 反转操作  
25.         sb.replace(1, 3, "helloeclipse"); // 替换操作  
26.         sb.substring(1, 5); // 字符串截取操作  
27.         sb.delete(0, 1); // 删除操作  
28.         sb.indexOf("hello"); // index出现的位置  
29.           
30.         // 2、StringBuffer类的引用传递  
31.         StringBuffer sb1 = new StringBuffer();  
32.         sb1.append("hello");  
33.         fun(sb1);  
34.         System.out.println(sb1.toString()); // helloworld  
35.           
36.         // 3、StringBuffer类和String类的区别  
37.         // 一个可变、一个不可变，具体选择根据具体的场景  
38.     }  
39.     private static void fun(StringBuffer sb1) {  
40.         sb1.append("world"); // 改变对应的值  
41.     }  
42. }  

Java代码  

1. import java.io.IOException;  
2.   
3. /** 
4.  * @author Administrator 
5.  *  
6.  * @description Runtime类学习测试 
7.  * @history 
8.  */  
9. public class RuntimeTest {  
10.     /** 
11.      * @description 
12.      * @param args 
13.      */  
14.     public static void main(String[] args) {  
15.         // Runtime类是一个封装了JVM进程的类，每一个java应用程序都有一个JVM实例来支持  
16.         // 因此每个JVM进程对应一个Runtime类的实例对象，由java虚拟机来实例化对象  
17.         // 查看源代码发现，其构造方法被私有化了，类似单例模式  
18.         /* 
19.          * public class Runtime { private static Runtime currentRuntime = new 
20.          * Runtime(); public static Runtime getRuntime() { return 
21.          * currentRuntime; } private Runtime() {} } 
22.          */  
23.         Runtime run = Runtime.getRuntime(); // 通过静态方法获取实例对象  
24.         // 1、查看一些JVM内存级别的参数  
25.         System.out.println(run.maxMemory()); // 最大内存空间  
26.         System.out.println(run.freeMemory()); // 空间的内存空间  
27.         String str = "";  
28.         for (int i = 0; i < 10000; i++) {  
29.             str += i;  
30.         }  
31.         System.out.println(run.freeMemory()); // 空间的内存空间  
32.         run.gc(); // 进行垃圾回收处理  
33.         System.out.println(run.freeMemory());  
34.   
35.         // 2、Runtime类一般和Process类一起使用，可以打开本机的一些进程  
36.         Process p = null; // 定义进程变量  
37.         try {  
38.             p = run.exec("notepad.exe"); // 打开记事本程序  
39.             /*public Process exec(String command) throws IOException { 
40.                 return exec(command, null, null); 
41.             }*/  
42.             // 底层有个ProcessBuilder类处理执行这些命令  
43.         } catch (IOException e) {  
44.             e.printStackTrace();  
45.         }  
46.         try {  
47.             Thread.sleep(5000); // 让记事本程序执行5秒后关闭掉  
48.         } catch (Exception e) {  
49.         }  
50.         p.destroy(); // 结束此进程  
51.     }  
52.   
53. }  

Java代码  

1. import java.io.PrintStream;  
2.   
3. class Demo{  
4.     public Demo(){}  
5.     // 覆写该方法，测试System调用gc方法的过程  
6.     protected void finalize() throws Throwable {  
7.         System.out.println("hello-finalize");  
8.     }  
9. }  
10. public class SystemTest {  
11.     /** 
12.      *@description  
13.      *@param args 
14.      */  
15.     public static void main(String[] args) {  
16.         // System类和上面说到的Runtime类一样也是比较靠近虚拟机实例的类  
17.         // 1、我们经常使用的方式是打印输出操作System.out.println("hello world");  
18.         // PrintStream extends FilterOutputStream extends OutputStream  
19.         PrintStream out = System.out; // 获取打印流  
20.         out.println("helloworld"); // 打印输出  
21.           
22.         // 2、通过该类获取系统时间操作  
23.         // public static native long currentTimeMillis();  
24.         long current = System.currentTimeMillis();  
25.         System.out.println(current); // 毫秒级别  
26.           
27.         // 3、查看系统的属性值情况  
28.         System.getProperties().list(out);  
29.         // java.runtime.name=Java(TM) SE Runtime Environment  
30.         // sun.boot.library.path=C:\Program Files\Java\jre6\bin  
31.         // java.vm.version=20.1-b02  
32.         // java.vm.vendor=Sun Microsystems Inc.  
33.         // java.vendor.url=http://java.sun.com/  
34.         // ...等等系统值  
35.           
36.         // Properties extends Hashtable<Object,Object>  
37.         // Key-Value的键值对形式，实现了Map接口的类  
38.         System.out.println(System.getProperty("os.name")); // Windows 7  
39.         /*public static String getProperty(String key) { 
40.             checkKey(key); 
41.             SecurityManager sm = getSecurityManager(); 
42.                 if (sm != null) { 
43.                 sm.checkPropertyAccess(key); 
44.             } 
45.             return props.getProperty(key); 
46.         }*/  
47.           
48.         // 4、释放内存空间方法调用  
49.         // 在之前的笔记中说到了Object类，其中有个finalize方法  
50.         // protected void finalize() throws Throwable { }  
51.         Demo demo = new Demo();  
52.         demo = null; // 断开引用设置为null  
53.         System.gc(); // 强制性/显示释放内存空间，打印输出hello-finalize  
54.         // 调用的是Runtime类的释放方法  
55.         /*public static void gc() { 
56.             Runtime.getRuntime().gc(); 
57.         }*/  
58.     }  
59. }  

Java代码  

1. import java.text.ParseException;  
2. import java.text.SimpleDateFormat;  
3. import java.util.Date;  
4.   
5. /** 
6.  * @author Administrator 
7.  *  
8.  * @description 时间帮助工具类 
9.  * @history 
10.  */  
11. public class DateHelperUtil {  
12.     /** 
13.      * @description 获取当前时间的字符串格式 
14.      * @return 
15.      */  
16.     public static String getNowDate() {  
17.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");  
18.         return sdf.format(new Date());  
19.     }  
20.   
21.     /** 
22.      *@description 对传入的date类型时间转换成字符串格式的时间 
23.      *@param date 
24.      *@return 返回字符串格式时间 
25.      */  
26.     public static String formatDate(Date date){  
27.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");  
28.         return sdf.format(date);  
29.     }  
30.       
31.     /** 
32.      *@description 对传入的date类型时间转换成字符串格式的时间 
33.      *@param date 
34.      *@param formatStr 格式模板 
35.      *@return 返回字符串格式时间 
36.      */  
37.     public static String formatDate(Date date,String formatStr){  
38.         SimpleDateFormat sdf = new SimpleDateFormat(formatStr);  
39.         return sdf.format(date);  
40.     }  
41.       
42.     /** 
43.      *@description 对传入的字符串格式的时间进行解析处理成date类型 
44.      *@param dateStr 
45.      *@return 
46.      * @throws ParseException 解析错误异常 
47.      */  
48.     public static Date parseDate(String dateStr) throws ParseException{  
49.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");  
50.         return sdf.parse(dateStr);  
51.     }  
52.       
53.     /** 
54.      *@description 对传入的字符串格式的时间进行解析处理成date类型 
55.      *@param dateStr 
56.      *@param formatStr 解析字符串的时间模板 
57.      *@return 
58.      *@throws ParseException 解析错误异常 
59.      */  
60.     public static Date parseDate(String dateStr, String formatStr) throws ParseException {  
61.         SimpleDateFormat sdf = new SimpleDateFormat(formatStr);  
62.         return sdf.parse(dateStr);  
63.     }  
64.       
65.     /** 
66.      *@description 获取当前时间的时间戳 
67.      *@return 
68.      */  
69.     public static String getTimeStamp() {  
70.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");  
71.         return sdf.format(new Date());  
72.     }  
73.       
74. }  

Java代码  

1. import java.math.BigInteger;  
2.   
3. /** 
4.  * @author Administrator 
5.  *  
6.  * @description BigInteger大数学习测试类 
7.  * @history 
8.  */  
9. public class BigIntegerDemo {  
10.     /** 
11.      *@description  
12.      *@param args 
13.      */  
14.     public static void main(String args[]) {  
15.         BigInteger bi1 = new BigInteger("123456789"); // 声明BigInteger对象  
16.         BigInteger bi2 = new BigInteger("987654321"); // 声明BigInteger对象  
17.         System.out.println("加法操作：" + bi2.add(bi1)); // 加法操作  
18.         System.out.println("减法操作：" + bi2.subtract(bi1)); // 减法操作  
19.         System.out.println("乘法操作：" + bi2.multiply(bi1)); // 乘法操作  
20.         System.out.println("除法操作：" + bi2.divide(bi1)); // 除法操作  
21.         System.out.println("最大数：" + bi2.max(bi1)); // 求出最大数  
22.         System.out.println("最小数：" + bi2.min(bi1)); // 求出最小数  
23.         BigInteger result[] = bi2.divideAndRemainder(bi1); // 求出余数的除法操作  
24.         System.out.println("商是：" + result[0] + "；余数是：" + result[1]);  
25.     }  
26. }  

Java代码  

1. class Student implements Comparable<Student> { // 指定类型为Student  
2.     private String name;  
3.     private int age;  
4.     private float score;  
5.   
6.     public Student(String name, int age, float score) {  
7.         this.name = name;  
8.         this.age = age;  
9.         this.score = score;  
10.     }  
11.   
12.     public String toString() {  
13.         return name + "\t\t" + this.age + "\t\t" + this.score;  
14.     }  
15.   
16.     public int compareTo(Student stu) { // 覆写compareTo()方法，实现排序规则的应用  
17.         if (this.score > stu.score) {  
18.             return -1;  
19.         } else if (this.score < stu.score) {  
20.             return 1;  
21.         } else {  
22.             if (this.age > stu.age) {  
23.                 return 1;  
24.             } else if (this.age < stu.age) {  
25.                 return -1;  
26.             } else {  
27.                 return 0;  
28.             }  
29.         }  
30.     }  
31. }  
32.   
33. public class ComparableDemo01 {  
34.     public static void main(String[] args) {  
35.         Student stu[] = { new Student("张三", 20, 90.0f),  
36.                 new Student("李四", 22, 90.0f), new Student("王五", 20, 99.0f),  
37.                 new Student("赵六", 20, 70.0f), new Student("孙七", 22, 100.0f) };  
38.         java.util.Arrays.sort(stu); // 进行排序操作  
39.         for (int i = 0; i < stu.length; i++) { // 循环输出数组中的内容  
40.             System.out.println(stu[i]);  
41.         }  
42.     }  
43. }  

Java代码  

1. class BinaryTree {  
2.     class Node { // 声明一个节点类  
3.         private Comparable data; // 保存具体的内容  
4.         private Node left; // 保存左子树  
5.         private Node right; // 保存右子树  
6.   
7.         public Node(Comparable data) {  
8.             this.data = data;  
9.         }  
10.   
11.         public void addNode(Node newNode) {  
12.             // 确定是放在左子树还是右子树  
13.             if (newNode.data.compareTo(this.data) < 0) { // 内容小，放在左子树  
14.                 if (this.left == null) {  
15.                     this.left = newNode; // 直接将新的节点设置成左子树  
16.                 } else {  
17.                     this.left.addNode(newNode); // 继续向下判断  
18.                 }  
19.             }  
20.             if (newNode.data.compareTo(this.data) >= 0) { // 放在右子树  
21.                 if (this.right == null) {  
22.                     this.right = newNode; // 没有右子树则将此节点设置成右子树  
23.                 } else {  
24.                     this.right.addNode(newNode); // 继续向下判断  
25.                 }  
26.             }  
27.         }  
28.   
29.         public void printNode() { // 输出的时候采用中序遍历  
30.             if (this.left != null) {  
31.                 this.left.printNode(); // 输出左子树  
32.             }  
33.             System.out.print(this.data + "\t");  
34.             if (this.right != null) {  
35.                 this.right.printNode();  
36.             }  
37.         }  
38.     }  
39.   
40.     private Node root; // 根元素  
41.   
42.     public void add(Comparable data) { // 加入元素  
43.         Node newNode = new Node(data); // 定义新的节点  
44.         if (root == null) { // 没有根节点  
45.             root = newNode; // 第一个元素作为根节点  
46.         } else {  
47.             root.addNode(newNode); // 确定是放在左子树还是放在右子树  
48.         }  
49.     }  
50.   
51.     public void print() {  
52.         this.root.printNode(); // 通过根节点输出  
53.     }  
54. }  
55.   
56. public class ComparableDemo02 {  
57.     public static void main(String[] args) {  
58.         BinaryTree bt = new BinaryTree();  
59.         bt.add(8);  
60.         bt.add(3);  
61.         bt.add(3);  
62.         bt.add(10);  
63.         bt.add(9);  
64.         bt.add(1);  
65.         bt.add(5);  
66.         bt.add(5);  
67.         System.out.println("排序之后的结果：");  
68.         bt.print();  
69.     }  
70. }  

Java代码  

1. import java.text.SimpleDateFormat;  
2. import java.util.Date;  
3. import java.util.Timer;  
4. import java.util.TimerTask;  
5.   
6. /** 
7.  * @author Administrator 
8.  *  
9.  * @description 任务调度程序学习类 
10.  * @history 
11.  */  
12. class MyTask extends TimerTask{ // 任务调度类都要继承TimerTask  
13.     public void run(){  
14.         SimpleDateFormat sdf = null ;  
15.         sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;  
16.         System.out.println("当前系统时间为：" + sdf.format(new Date())) ;  
17.     }  
18. }  
19.   
20. public class TaskTestDemo {  
21.     /** 
22.      * @description 
23.      * @param args 
24.      */  
25.     public static void main(String args[]) {  
26.         Timer t = new Timer(); // 建立Timer类对象  
27.         MyTask mytask = new MyTask(); // 定义任务  
28.         t.schedule(mytask, 1000, 2000); // 设置任务的执行，1秒后开始，每2秒重复  
29.     }  
30. }