java 小知识点

1.转Java中Vector和ArrayList的区别

 

首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：

1. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
2. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
3. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
4. 查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。

5. 关于ArrayList和Vector区别如下：

   1. ArrayList在内存不够时默认是扩展50% + 1个，Vector是默认扩展1倍。
   2. Vector提供indexOf(obj, start)接口，ArrayList没有。
   3. Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。

2.异常问题

1. java运行时异常是可能在java虚拟机正常工作时抛出的异常。

   java提供了两种异常机制。一种是运行时异常(RuntimeExepction)，一种是检查式异常(checked execption)。

   检查式异常：我们经常遇到的IO异常及sql异常就属于检查式异常。对于这种异常，java编译器要求我们必须对出现的这些异常进行catch 所以 面对这种异常不管我们是否愿意，只能自己去写一堆catch来捕捉这些异常。

   运行时异常：我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

   RuntimeExecption在java.lang包下。

2. 想要找出我们常见的5中运行时异常是非常容易的。  

   例如：ClassCastException(类转换异常)

   IndexOutOfBoundsException(数组越界)

   NullPointerException(空指针)

   ArrayStoreException(数据存储异常，操作数组时类型不一致)

   还有IO操作的BufferOverflowException异常

3.下面是由java虚拟机提供的运行时异常

AnnotationTypeMismatchException, 
ArithmeticException, 
ArrayStoreException, 
BufferOverflowException, 
BufferUnderflowException, 
CannotRedoException, 
CannotUndoException, 
ClassCastException, 
CMMException, 
ConcurrentModificationException, 
DOMException, 
EmptyStackException, 
EnumConstantNotPresentException, 
EventException, 
IllegalArgumentException, 
IllegalMonitorStateException, 
IllegalPathStateException, 
IllegalStateException, 
ImagingOpException, 
IncompleteAnnotationException, 
IndexOutOfBoundsException, 
JMRuntimeException, 
LSException, 
MalformedParameterizedTypeException, 
MirroredTypeException, 
MirroredTypesException, 
MissingResourceException, 
NegativeArraySizeException, 
NoSuchElementException, 
NoSuchMechanismException, 
NullPointerException, 
ProfileDataException, 
ProviderException, 
RasterFormatException, 
RejectedExecutionException, 
SecurityException, 
SystemException, 
TypeConstraintException, 
TypeNotPresentException, 
UndeclaredThrowableException, 
UnknownAnnotationValueException, 
UnknownElementException, 
UnknownTypeException, 
UnmodifiableSetException, 
UnsupportedOperationException, 
WebServiceException

看到这么多异常，想要找出我们常见的5中运行时异常是非常容易的。

3. sleep() 和wait()      sleep 和 wait 有什么区别

1. sleep指线程被调用时，占着CPU不工作，形象地说明为“占着CPU睡觉”，此时，系统的CPU部分资源被占用，其他线程无法进入，会增加时间限制。
wait指线程处于进入等待状态，形象地说明为“等待使用CPU”，此时线程不占用任何资源，不增加时间限制。
所以
sleep（100L）意思为：占用CPU，线程休眠100毫秒
wait（100L）意思为：不占用CPU，线程等待100毫秒

2.对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

获取对象锁进入运行状态。

什么意思呢？

举个列子说明：

 1 /**
 2  *
 3  */
 4 package com.b510.test;
 5
 6 /**
 7  * java中的sleep()和wait()的区别
 8  * @author Hongten
 9  * @date 2013-12-10
10  */
11 public class TestD {
12
13     public static void main(String[] args) {
14         new Thread(new Thread1()).start();
15         try {
16             Thread.sleep(5000);
17         } catch (Exception e) {
18             e.printStackTrace();
19         }
20         new Thread(new Thread2()).start();
21     }
22
23     private static class Thread1 implements Runnable{
24         @Override
25         public void run(){
26             synchronized (TestD.class) {
27             System.out.println("enter thread1...");
28             System.out.println("thread1 is waiting...");
29             try {
30                 //调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
31                 TestD.class.wait();
32             } catch (Exception e) {
33                 e.printStackTrace();
34             }
35             System.out.println("thread1 is going on ....");
36             System.out.println("thread1 is over!!!");
37             }
38         }
39     }
40
41     private static class Thread2 implements Runnable{
42         @Override
43         public void run(){
44             synchronized (TestD.class) {
45                 System.out.println("enter thread2....");
46                 System.out.println("thread2 is sleep....");
47                 //只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
48                 TestD.class.notify();
49                 //==================
50                 //区别
51                 //如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
52                 //方法，则线程永远处于挂起状态。
53                 try {
54                     //sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
55                     //但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
56                     //在调用sleep()方法的过程中，线程不会释放对象锁。
57                     Thread.sleep(5000);
58                 } catch (Exception e) {
59                     e.printStackTrace();
60                 }
61                 System.out.println("thread2 is going on....");
62                 System.out.println("thread2 is over!!!");
63             }
64         }
65     }
66 }

运行效果：

enter thread1...
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!
thread1 is going on ....
thread1 is over!!!

如果注释掉代码：

1 TestD.class.notify();

运行效果：

enter thread1...
thread1 is waiting...
enter thread2....
thread2 is sleep....
thread2 is going on....
thread2 is over!!!

且程序一直处于挂起状态。

4.Java中equals和==的区别

1. “==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】 
    equal用于比较两个对象的值是否相同【不是比地址】

   【特别注意】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。

    "=="比"equal"运行速度快,因为"=="只是比较引用.