数据库当中的视图，可以类比的设计模式是修饰者模式
int和interger区别：
Ingeter是int的包装类，int的初值为0，Ingeter的初值为null
public class TestInteger { 8 9 /** 10 * @param args 11 */ 12 public static void main(String[] args) { 13 int i = 128; 14 Integer i2 = 128; 15 Integer i3 = new Integer(128); 16 //Integer会自动拆箱为int，所以为true 17 System.out.println(i == i2); 18 System.out.println(i == i3); 19 System.out.println("**************"); 20 Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127); 21 Integer i6 = 127; 22 System.out.println(i5 == i6);//true 23 /*Integer i5 = 128; 24 Integer i6 = 128; 25 System.out.println(i5 == i6);//false 26 */ Integer ii5 = new Integer(127); 27 System.out.println(i5 == ii5); //false 28 Integer i7 = new Integer(128); 29 Integer i8 = new Integer(123); 30 System.out.println(i7 == i8); //false 31 } 32 33 }
17行和18行输出结果都为true,因为Integer和int比都会自动拆箱（jdk1.5以上）
22行的结果为true,而25行则为false,很多人都不动为什么。其实java在编译Integer i5 = 127的时候,被翻译成-> Integer i5 = Integer.valueOf(127);所以关键就是看valueOf()函数了。只要看看valueOf()函数的源码就会明白了。JDK源码的valueOf函数式这样的：
1 public static Integer valueOf(int i) { 2 assert IntegerCache.high >= 127; 3 if (i >= IntegerCache.low && i <= IntegerCache.high) 4 return IntegerCache.cache[i + (-IntegerCache.low)]; 5 return new Integer(i); 6 }
看一下源码大家都会明白，对于-128到127之间的数，会进行缓存，Integer i5 = 127时，会将127进行缓存，下次再写Integer i6 = 127时，就会直接从缓存中取，就不会new了。所以22行的结果为true,而25行为false。
对于27行和30行，因为对象不一样，所以为false。
”==“是比较两个变量的值是否相等、对于引用型变量表示的是两个变量在堆中存储的地址是否相同。 equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
我对于以上的情况总结如下：
①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，i3的引用指向堆，而i4指向专门存放他的内存（常量池），他们的内存地址不一样，所以为false
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
③两个都是new出来的,都为false
④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比
java object
| 方法摘要 | |
|---|---|
| protected Object |
clone() 创建并返回此对象的一个副本。 |
| boolean |
equals(Object obj) 指示其他某个对象是否与此对象“相等”。 |
| protected void |
finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 |
| Class<?> |
getClass() 返回此Object的运行时类。 |
| int |
hashCode() 返回该对象的哈希码值。 |
| void |
notify() 唤醒在此对象监视器上等待的单个线程。 |
| void |
notifyAll() 唤醒在此对象监视器上等待的所有线程。 |
| String |
toString() 返回该对象的字符串表示。 |
| void |
wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 |
| void |
wait(long timeout) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。 |
| void |
wait(long timeout, int nanos) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。 |
- package java.lang;
- public class Object {
- /* 一个本地方法，具体是用C（C++）在DLL中实现的，然后通过JNI调用。*/
- private static native void registerNatives();
- /* 对象初始化时自动调用此方法*/
- static {
- registerNatives();
- }
- /* 返回此 Object 的运行时类。*/
- public final native Class<?> getClass();
- /*
- hashCode 的常规协定是：（本质 上是 返回该对象的哈希码值。 ）
- 1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
- 2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
- 3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
- */
- public native int hashCode();
- public boolean equals(Object obj) {
- return ( this == obj);
- }
- /*本地CLONE方法，用于对象的复制。*/
- protected native Object clone() throws CloneNotSupportedException;
- /*返回该对象的字符串表示。非常重要的方法*/
- public String toString() {
- return getClass().getName() + "@" + Integer.toHexString(hashCode());
- }
- /*唤醒在此对象监视器上等待的单个线程。*/
- public final native void notify();
- /*唤醒在此对象监视器上等待的所有线程。*/
- public final native void notifyAll();
- /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
- 当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/
- public final void wait() throws InterruptedException {
- wait( 0 );
- }
- /*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。*/
- public final native void wait( long timeout) throws InterruptedException;
- /* 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。*/
- public final void wait( long timeout, int nanos) throws InterruptedException {
- if (timeout < 0 ) {
- throw new IllegalArgumentException( "timeout value is negative" );
- }
- if (nanos < 0 || nanos > 999999 ) {
- throw new IllegalArgumentException(
- "nanosecond timeout value out of range" );
- }
- if (nanos >= 500000 || (nanos != 0 && timeout == 0 )) {
- timeout++;
- }
- wait(timeout);
- }
- /*当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。*/
- protected void finalize() throws Throwable { }
System.arraycopy > clone > Arrays.copyOf
> for循环
关于Collection接口:
1、Collection接口
Collection是最基本集合接口，它定义了一组允许重复的对象。Collection接口派生了两个子接口Set和List，分别定义了两种不同的存储方式，如下：
2、 Set接口
Set接口继承于Collection接口，它没有提供额外的方法，但实现了Set接口的集合类中的元素是无序且不可重复。
特征：无序且不可重复。
3、 List接口
List接口同样也继承于Collection接口，但是与Set接口恰恰相反，List接口的集合类中的元素是对象有序且可重复。
特征：有序且可重复。
两个重要的实现类：ArrayList和LinkedList
1.ArrayList特点是有序可重复的
2.LinkedList是一个双向链表结构的。
4、Map接口
Map也是接口，但没有继承Collection接口。该接口描述了从不重复的键到值的映射。Map接口用于维护键/值对（key/value pairs）。
特征：它描述了从不重复的键到值的映射。
两个重要的实现类：HashMap和TreeMap
1.HashMap，中文叫散列表，基于哈希表实现，特点就是键值对的映射关系。一个key对应一个Value。HashMap中元素的排列顺序是不固定的。更加适合于对元素进行插入、删除和定位。
2.TreeMap，基于红黑书实现。TreeMap中的元素保持着某种固定的顺序。更加适合于对元素的顺序遍历。
5、Iterator接口
Iterator接口，在C#里有例外一种说法IEnumerator，他们都是集合访问器，用于循环访问集合中的对象。
所有实现了Collection接口的容器类都有iterator方法，用于返回一个实现了Iterator接口的对象。Iterator对象称作迭代器，Iterator接口方法能以迭代方式逐个访问集合中各个元素，并可以从Collection中除去适当的元素。
不同点： Thread.sleep(long)可以不在synchronized的块下调用，而且使用Thread.sleep()不会丢失当前线程对任何对象的同步锁(monitor);
object.wait(long)必须在synchronized的块下来使用，调用了之后失去对object的monitor, 这样做的好处是它不影响其它的线程对object进行操作。
饰者模式修饰者模式