九阳真经-java基础面试

java基础

集合

整体框架

 

通用实现

  Iterable（接口）接口是java 集合框架的顶级接口,实现此接口使集合对象可以通过迭代器遍历自身元素

├Collection（接口）
├List列表（接口）有序的 collection（也称为序列）,允许重复的元素
 │├LinkedList（实现类）使用双向链表实现存储，允许所有元素（包括 null）。非线程安全,要保证同步,可以使用List list = Collections.synchronizedList(new LinkedList());进行包装,可以被当作堆栈和队列来使用。（双向链表不能用单向链表替代，因为单项链表是无序的无法保证LinkedList的有序性）

│├ArrayList （实现类） 底层使用的是数组结构,特点:查询速度快,增删操作较慢,而且线程不同步.要保证同步,可以使用:List list = Collections.synchronizedList(new ArrayList());进行包装,默认容量为10.常用方法:add,addAll,remove,indexOf,subList,contains,isEmpty…. 初始容量定义：10 扩容：oldCapacity + (oldCapacity >> 1)，即原集合长度的1.5倍。
 │└Vector也是一个有序集合,允许重复元素,底层动态分配的Object[]数组实现并且线程安全. 初始容量定义：10 扩容：如果扩容因子>0 oldCapacity + 扩容因子，否则按照oldCapacity*2 进行扩容
 │　└Stack（派生类） Stack是继承于Vector的子类，它主要用来模拟”栈“，因此也具备了peek()、pop()、push()等主要用于栈操作的方法，性能不行。ArrayDeque可以代替
 └Set集（接口） Set是一种没有重复元素的集合,它所有的方法都是直接继承自Collection接口,并且添加了一个对重复元素的限制.Set要求强化了equals和hashCode两个方法,以使Set集合可以对元素进行排序和对比.

(SortedSet和NavigableSet接口)

     通用实现

├HashSet通过哈希表存储元素,它是Set通用类中性能最好的一个,但不保证元素的排序 默认容量 和扩容机制和hashmap一致。

├TreeSet 元素按一定规则排序,所以他的性能要比HashSet差许多.

└LinkedHashSet在HashSet的基础上,增添了一个链表结构,来保证数据的按插入先后存储有序,因为需要维持一个链表,所以它的性能比HashSet稍微差一点,介于HashSet和TreeSet之间.

专用实现

├EnumSet是一个高性能的枚举类型的Set实现类,其内部元素必须都是相同的枚举类型.

└CopyOnWriteArraySet是一个支持COW(copy-on-write)机制的集合.CopyOnWriteArraySet对集合的任何修改操作如,add,remove,set时,都会先复制一份,所以在CopyOnWriteArraySet可以安全的并发进行迭代和元素插入删除操作,不需要同步锁,实现了读写分离,但是读操作不具备实时性.CopyOnWriteArraySet只适用集合频繁迭代但很少修改的情景.

Map 映射Map是一个包含键值对的集合,一个map不能有重复的键(key),而且每个键至多只能对应一个值.Map同Collection一样,它的所有通用实现都会提供一个转换器构造函数,接收一个Map类型集合,并以此初始化自己,这样只要是Map的实现都可以相互之间转换.

（SortedMap和NavigableMap两个接口）
通用实现

├HashMap  是线程不安全的实现，且HashMap中可以使用null作为key或者value。

      1、 默认分配到空间是16=2^4 。2、手动为hashmap分配空间的时候 a：空间大小要为2的次幂（可以减少hash冲突，避免一些数组空间永远不被使用）b：0.75*size > 实际要存储的元素个数 3、hashmap 会在元素个数达到size*0.75（默人loadFactor）进行扩容。4、扩容的时候旧数组的长度左移一位。

├LinkedHashMap使用一个双向链表来维护key-value对的次序，其也是一个有序的Map集合，顺序与key-value对的插入顺序保持一致

├TreeMap是一个红黑树的结构，每个key-value作为红黑树的一个节点。TreeMap也会对key进行排序，也分为自然排序和定制排序两种
├Hashtable是一个比较古老的Map实现类，它是一个线程安全的Map实现，且不允许使用null作为key和value。由于该类是比较久远的类，其性能较低，所以现在用的也比较少

HashTable中hash数组默认大小是11，增加的方式是 old*2+1。

 

专用实现

├EnumMap是一个高性能的以枚举为键的Map集合,它内部是以数组实现.EnumMap将Map集合的丰富功能和安全性与数组的快速访问结合起来,如果想要实现一个用枚举映射值得结构,应当使用EnumMap

├IdentityHashMap存储元素时,不使用equal方法比较键对象,而是使用==来对比,适用于实现对象拓扑结构转换,比如对象序列化或深度拷贝时,作为一个”节点表”来跟踪处理那些已经处理过的对象引用.

├WeakHashMap只存储弱引用类型的key,当它内部的元素的键不再被外界引用时,其键值对就可以被垃圾回收期(GC)回收,被从WeakHashMap中移除.WeakHashMap提供最简单利用弱引用的方

法,这对实现”registry-like”数据结构非常有用.

并发实现

└ConcurrentHashMap是一个高并发高性能的基于哈希表的实现,当检索元素时永不会阻塞,并且当执行update允许客户端选定执行并发级别更新.它是HashMap的替代,ConcurrentHashMap除了实现ConcurrentMap还支持HashTable所有遗留的独有的操作.

 

注：线程安全就是多线程访问                        时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

解决哈希冲突的办法

1.开放定制法

2.链地址法

3.公共溢出区法

建立一个特殊存储空间，专门存放冲突的数据。此种方法适用于数据和冲突较少的情况。

4.再散列法

准备若干个hash函数，如果使用第一个hash函数发生了冲突，就使用第二个hash函数，第二个也冲突，使用第三个……

 

细说 HashMap

 

 

还有一个条件是存储的元素大于64

 

 

 

 

 

 

 

通过 链地址法解决散列冲突的实现方式 ，发生冲突之后在数据上加一个指针

指向下一个结点

四种访问权限

访问权限	本类	本包的类	子类	非子类的外包类
public	是	是	是	是
protected	是	是	是	否
default	是	是	否	否
private	是	否	否	否

 

四种引用类型

所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。

一，强引用

Java中默认声明的就是强引用，比如：

Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收

obj = null;  //手动置null

只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了

二，软引用

软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。

下面以一个例子来进一步说明强引用和软引用的区别：
在运行下面的Java代码之前，需要先配置参数 -Xms2M -Xmx3M，将 JVM 的初始内存设为2M，最大可用内存为 3M。

首先先来测试一下强引用，在限制了 JVM 内存的前提下，下面的代码运行正常

public class TestOOM {         public static void main(String[] args) {          testStrongReference();     }     private static void testStrongReference() {         // 当 new byte为 1M 时，程序运行正常         byte[] buff = new byte[1024 * 1024 * 1];     } } 但是如果我们将 byte[] buff = new byte[1024 * 1024 * 1]; 替换为创建一个大小为 2M 的字节数组 byte[] buff = new byte[1024 * 1024 * 2];

则内存不够使用，程序直接报错，强引用并不会被回收

接着来看一下软引用会有什么不一样，在下面的示例中连续创建了 10 个大小为 1M 的字节数组，并赋值给了软引用，然后循环遍历将这些对象打印出来。

public class TestOOM {     private static List<Object> list = new ArrayList<>();     public static void main(String[] args) {          testSoftReference();     }     private static void testSoftReference() {         for (int i = 0; i < 10; i++) {             byte[] buff = new byte[1024 * 1024];             SoftReference<byte[]> sr = new SoftReference<>(buff);             list.add(sr);         }                 System.gc(); //主动通知垃圾回收                 for(int i=0; i < list.size(); i++){             Object obj = ((SoftReference) list.get(i)).get();             System.out.println(obj);         }             }     }

打印结果：

我们发现无论循环创建多少个软引用对象，打印结果总是只有最后一个对象被保留，其他的obj全都被置空回收了。
这里就说明了在内存不足的情况下，软引用将会被自动回收。
值得注意的一点 , 即使有 byte[] buff 引用指向对象, 且 buff 是一个strong reference, 但是 SoftReference sr 指向的对象仍然被回收了，这是因为Java的编译器发现了在之后的代码中, buff 已经没有被使用了, 所以自动进行了优化。
如果我们将上面示例稍微修改一下：

private static void testSoftReference() {         byte[] buff = null;           for (int i = 0; i < 10; i++) {             buff = new byte[1024 * 1024];             SoftReference<byte[]> sr = new SoftReference<>(buff);             list.add(sr);         }           System.gc(); //主动通知垃圾回收                 for(int i=0; i < list.size(); i++){             Object obj = ((SoftReference) list.get(i)).get();             System.out.println(obj);         }           System.out.println("buff: " + buff.toString());     }

则 buff 会因为强引用的存在，而无法被垃圾回收，从而抛出OOM的错误。

如果一个对象惟一剩下的引用是软引用，那么该对象是软可及的（softly reachable）。垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。

三，弱引用

弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
我们以与软引用同样的方式来测试一下弱引用：

private static void testWeakReference() {         for (int i = 0; i < 10; i++) {             byte[] buff = new byte[1024 * 1024];             WeakReference<byte[]> sr = new WeakReference<>(buff);             list.add(sr);         }                 System.gc(); //主动通知垃圾回收                 for(int i=0; i < list.size(); i++){             Object obj = ((WeakReference) list.get(i)).get();             System.out.println(obj);         }     }

 

打印结果：
 

可以发现所有被弱引用关联的对象都被垃圾回收了。

四，虚引用

虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。

public class PhantomReference<T> extends Reference<T> {     /**      * Returns this reference object's referent.  Because the referent of a      * phantom reference is always inaccessible, this method always returns      * <code>null</code>.      *      * @return  <code>null</code>      */     public T get() {         return null;     }     public PhantomReference(T referent, ReferenceQueue<? super T> q) {         super(referent, q);     } }

那么传入它的构造方法中的 ReferenceQueue 又是如何使用的呢？

五，引用队列（ReferenceQueue）

引用队列可以与软引用、弱引用以及虚引用一起配合使用，当垃圾回收器准备回收一个对象时，如果发现它还有引用，那么就会在回收对象之前，把这个引用加入到与之关联的引用队列中去。程序可以通过判断引用队列中是否已经加入了引用，来判断被引用的对象是否将要被垃圾回收，这样就可以在对象被回收之前采取一些必要的措施。

与软引用、弱引用不同，虚引用必须和引用队列一起使用。

 

字符串拼接

原理分析

1.加号拼接

打开编译后的字节码我们可以发现加号拼接字符串jvm底层其实是调用StringBuilder来实现的，也就是说”a” + “b”等效于下面的代码片。

 

String a = "a"; StringBuilder sb = new StringBuilder(); sb.append(a).append("b"); String str = sb.toString();

 

 

 

但并不是说直接用“+”号拼接就可以达到StringBuilder的效率了，因为用“+”号每拼接一次都会新建一个StringBuilder对象，并且最后toString()方法还会生成一个String对象。在循环拼接十万次的时候，就会生成十万个StringBuilder对象，十万个String对象，这简直就是噩梦。

 

2.concat拼接

concat的源代码如下，可以看到，concat其实就是申请一个char类型的buf数组，将需要拼接的字符串都放在这个数组里，最后再转换成String对象。

public String concat(String str) {         int otherLen = str.length();         if (otherLen == 0) {             return this;         }         int len = value.length;         char buf[] = Arrays.copyOf(value, len + otherLen);         str.getChars(buf, len);         return new String(buf, true);     }

 

   

 

3.StringBuilder/StringBuffer

这两个类实现append的方法都是调用父类AbstractStringBuilder的append方法，只不过StringBuffer是的append方法加了sychronized关键字，因此是线程安全的。append代码如下，他主要也是利用char数组保存字符，通过ensureCapacityInternal方法来保证数组容量可用还有扩容。

 

public AbstractStringBuilder append(String str) {         if (str == null)             return appendNull();         int len = str.length();         ensureCapacityInternal(count + len);         str.getChars(0, len, value, count);         count += len;         return this;     }

他扩容的方法的代码如下，可见，当容量不够的时候，数组容量右移1位（也就是翻倍）再加2，以前的jdk貌似是直接写成int newCapacity = (value.length * 2) + 2，后来优化成了右移，可见，右移的效率还是比直接乘更高的。

 

private int newCapacity(int minCapacity) {         // overflow-conscious code         int newCapacity = (value.length << 1) + 2;         if (newCapacity - minCapacity < 0) {             newCapacity = minCapacity;         }         return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)             ? hugeCapacity(minCapacity)             : newCapacity; }

原因分析

1.循环拼接字符串

通过实验我们发现，在循环拼接同一个字符串的时候，他们效率的按快慢排序是

StringBulider > StringBuffer >> String.concat > “+”。

StringBulider比StringBuffer更快这个容易理解，因为StringBuffer的方法是sychronized修饰的，同步的时候会损耗掉一些性能。StringBulider和String.concat的区别，主要在扩容上，String.concat是需要多少扩多少，而StringBulider是每次翻两倍，指数级扩容。在10万次拼接中，String.concat需要扩容10万次，而StringBuilder只需要扩容log100000次（大约17次），除此之外，concat每次都会生成一个新的String对象，而StringBuilder则不必，那StringBuilder如此快就不难解释了。至于直接用“+”号连接，之前已经说了，它会产生大量StringBuilder和String对象，当然就最慢了。

2.大量字符串拼接

在只拼接少量字符串的情况下的时候，他们效率的按快慢排序是

String.concat > StringBulider > StringBuffer > “+”。

为什么在拼接少量字符串的时候，String.concat就比StringBuilder快了呢，原因大致有两点，一是StringBuilder的调用栈更深，二是StringBuilder产生的垃圾对象更多，并且它重写的toString方法为了做到不可变性采用了“保护性拷贝”，因此效率不如concat。

 

StringBuilder和StringBuffer的初始容量都是16,程序猿尽量手动设置初始值。以避免多次扩容所带来的性能问题；
StringBuilder和StringBuffer的扩容机制是这种：首先试着将当前数组容量count扩充为2*count+2，如果2*count+2<count+str.length() 则扩充为count+ str.length()

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
• 浮点数的默认类型为double类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；
• 例子：double d1 = 123.4。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

char：

• char类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（即为0）；
• 最大值是 \uffff（即为65,535）；
• char 数据类型可以储存任何字符；

浅拷贝

　　我们看如下这段代码：

转存失败重新上传取消

package com.ys.test;   public class Person implements Cloneable{     public String pname;     public int page;     public Address address;     public Person() {}         public Person(String pname,int page){         this.pname = pname;         this.page = page;         this.address = new Address();     }         @Override     protected Object clone() throws CloneNotSupportedException {         return super.clone();     }         public void setAddress(String provices,String city ){         address.setAddress(provices, city);     }     public void display(String name){         System.out.println(name+":"+"pname=" + pname + ", page=" + page +","+ address);     }       public String getPname() {         return pname;     }       public void setPname(String pname) {         this.pname = pname;     }       public int getPage() {         return page;     }       public void setPage(int page) {         this.page = page;     }     } 转存失败重新上传取消 转存失败重新上传取消 package com.ys.test;   public class Address {     private String provices;     private String city;     public void setAddress(String provices,String city){         this.provices = provices;         this.city = city;     }     @Override     public String toString() {         return "Address [provices=" + provices + ", city=" + city + "]";     }     } 转存失败重新上传取消

　　

这是一个我们要进行赋值的原始类 Person。下面我们产生一个 Person 对象，并调用其 clone 方法复制一个新的对象。

　　注意：调用对象的 clone 方法，必须要让类实现 Cloneable 接口，并且覆写 clone 方法。

　　测试：

View Code

　　打印结果为：

　　

　　首先看原始类 Person 实现 Cloneable 接口，并且覆写 clone 方法,它还有三个属性，一个引用类型 String定义的 pname，一个基本类型 int定义的 page，还有一个引用类型 Address ，这是一个自定义类，这个类也包含两个属性 pprovices 和 city 。

　　接着看测试内容，首先我们创建一个Person 类的对象 p1，其pname 为zhangsan,page为21，地址类 Address 两个属性为 湖北省和武汉市。接着我们调用 clone() 方法复制另一个对象 p2，接着打印这两个对象的内容。

　　从第 1 行和第 3 行打印结果:

　　p1:com.ys.test.Person@349319f9

　　p2:com.ys.test.Person@258e4566

　　可以看出这是两个不同的对象。

　　从第 5 行和第 6 行打印的对象内容看，原对象 p1 和克隆出来的对象 p2 内容完全相同。

　　代码中我们只是更改了克隆对象 p2 的属性 Address 为湖北省荆州市（原对象 p1 是湖北省武汉市） ，但是从第 7 行和第 8 行打印结果来看，原对象 p1 和克隆对象 p2 的 Address 属性都被修改了。

　　也就是说对象 Person 的属性 Address，经过 clone 之后，其实只是复制了其引用，他们指向的还是同一块堆内存空间，当修改其中一个对象的属性 Address，另一个也会跟着变化。

　　

 

　　浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。

回到顶部

6、深拷贝

　　弄清楚了浅拷贝，那么深拷贝就很容易理解了。

　　深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。

　　

　　那么该如何实现深拷贝呢？Object 类提供的 clone 是只能实现 浅拷贝的。

回到顶部

7、如何实现深拷贝？

　　深拷贝的原理我们知道了，就是要让原始对象和克隆之后的对象所具有的引用类型属性不是指向同一块堆内存，这里有三种实现思路。

　　①、让每个引用类型属性内部都重写clone() 方法

　　既然引用类型不能实现深拷贝，那么我们将每个引用类型都拆分为基本类型，分别进行浅拷贝。比如上面的例子，Person 类有一个引用类型 Address(其实String 也是引用类型，但是String类型有点特殊，后面会详细讲解)，我们在 Address 类内部也重写 clone 方法。如下：

　　Address.class:

转存失败重新上传取消  1 package com.ys.test; 2  3 public class Address implements Cloneable{ 4     private String provices; 5     private String city; 6     public void setAddress(String provices,String city){ 7         this.provices = provices; 8         this.city = city; 9     } 10     @Override 11     public String toString() { 12         return "Address [provices=" + provices + ", city=" + city + "]"; 13     } 14     @Override 15     protected Object clone() throws CloneNotSupportedException { 16         return super.clone(); 17     } 18     19 } 转存失败重新上传取消 　　Person.class 的 clone() 方法： 转存失败重新上传取消 1     @Override 2     protected Object clone() throws CloneNotSupportedException { 3         Person p = (Person) super.clone(); 4         p.address = (Address) address.clone(); 5         return p; 6     }

转存失败重新上传取消

　　测试还是和上面一样，我们会发现更改了p2对象的Address属性，p1 对象的 Address 属性并没有变化。

　　但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

　　②、利用序列化

public class Student implements Serializable {     private transient String name;     private int age;     public Student() {     }       public Student(String name, int age) {         this.name = name;         this.age = age;     }       public String getName() {         return name;     }       public void setName(String name) {         this.name = name;     }       public int getAge() {         return age;     }       public void setAge(int age) {         this.age = age;     } }

 

可以将其声明为 transient，即将其排除在克隆属性之外。

转存失败重新上传取消

//深度拷贝 public Object deepClone() throws Exception{     // 序列化     ByteArrayOutputStream bos = new ByteArrayOutputStream();     ObjectOutputStream oos = new ObjectOutputStream(bos);       oos.writeObject(this);       // 反序列化     ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());     ObjectInputStream ois = new ObjectInputStream(bis);       return ois.readObject(); }

转存失败重新上传取消

 　　因为序列化产生的是两个完全独立的对象，所有无论嵌套多少个引用类型，序列化都是能实现深拷贝的。

 

抽象类与接口的区别

区别一：抽象类中可以存在非抽象的方法        VS       接口中的方法被默认的变成抽象方法,只要是定义了接口,接口中的方法 就全部变成了抽象类即使你不写 abstract  它也是抽象的方法    (jdk1.8 之后接口增加default 类型的方法可以定义方法体 )

区别二:实现抽象类的方法时, 如果方法是抽象的,子类必须重写抽象的方法. 如果方法不是抽象的, 子类可以选择继承         VS       实现了接口 就必须实现接口中的所有方法, 因为接口中的方法默认的全部都是抽象的方法（除非类是抽象类） 

区别三: 抽象类允许非static和非final字段，允许方法是public、private或protected，而接口的字段类型本质上是public的、static的和final的，所有接口方法本质上都是公共的。

区别四:一个类只能继承一个抽象类                 VS         一个类可以实现多个接口  ,接口可以实现多继承   举例:interface display extends aa ,bb,cc ...等等    然后让类去实现 display的接口 就可以实现 display aa bb  cc接口

对面向对象的理解

 

在我理解,面向对象是向现实世界模型的自然延伸，这是一种“万物皆对象”的编程思想。在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动，所以程序=对象+消息。

面向对象有三大特性，封装、继承和多态。

封装就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，提高了数据的隐秘性的同时，使代码模块化。这样做使得代码的复用性更高。

是进一步将一类事物共有的属性和行为抽象成一个父类，而每一个子类是一个特殊的父类--有父类的行为和属性，也有自己特有的行为和属性。这样做扩展了已存在的代码块，进一步提高了代码的复用性。

不同类的对象对同一消息作出不同的响应以及一个类实例（对象）的相同方法在不同情形有不同表现形式 叫做多态 。编译时多态，方法的重载 --运行时多态，方法的重写。多态的作用----简单来说：解藕。详细点就是，多态是设计模式的基础(既然是基础，那么一些设计模式中肯定有多态的下面三个条件)
多态存在的三个条件-----有继承关系，子类重写了父类方法，父类引用指向子类对象 Father son = new Son();

如果说封装和继承是为了使代码重用，那么多态则是为了实现接口重用。多态的一大作用就是为了解耦--为了解除父子类继承的耦合度。

总结一下，如果说封装和继承是面向对象的基础，那么多态则是面向对象最精髓的理论。掌握多态必先了解接口，只有充分理解接口才能更好的应用多态。

 

 

反射

一、什么是JAVA的反射

1、在运行状态中，对于任意一个类，都能够知道这个类的属性和方法。

2、对于任意一个对象，都能够调用它的任何方法和属性。

这种动态获取信息以及动态调用对象的方法的功能称为JAVA的反射。

二、反射的作用

在JAVA中，只有给定类的名字，就可以通过反射机制来获取类的所有信息，可以动态的创建对象和编译。

三、反射的原理

JAVA语言编译之后会生成一个.class文件，反射就是通过字节码文件找到某一个类、类中的方法以及属性等。

反射的实现主要借助以下四个类：

Class：类的对象

Constructor：类的构造方法

Field：类中的属性对象

Method：类中的方法对象

    java一个接口可以继承另外一个接口吗

一个接口可以继承多个接口.

interface C extends A, B {}是可以的.

一个类可以实现多个接口:

class D implements A,B,C{}

但是一个类只能继承一个类,不能继承多个类

class B extends A{}

在继承类的同时,也可以继承接口:

class E extends D implements A,B,C{}

这也正是选择用接口而不是抽象类的原因

static关键字

static关键字的基本作用，简而言之，一句话来描述就是：

　　方便在没有创建对象的情况下来进行调用（方法/变量）。

类中static部分是发生在类加载时期的，并且只初始化一次。

 

1）static方法

　　static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

2）static变量

　　static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

　　static成员变量的初始化顺序按照定义的顺序进行初始化。

3）static代码块

　　static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

　　为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:

4）static class 静态类（Java）

一般情况下是不可以用static修饰类的。如果一定要用static修饰类的话，通常static修饰的是匿名内部类。

只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。这是静态内部类都有的一个特性

 

equals()方法与 “=="号 的区别：

1、超类Object的equals()底层原理：

在超类Object中有一个equals()的基本方法，源码如下：

public boolean equals(Object obj) {   return (this == obj);     }

实际上我们知道所有的对象都拥有标识（内存地址）和状态（数据），同时“==”比较的是两个对象的内存地址，在Object的equals方法底层调用的是==号，所以说Object的equals()方法是比较两个对象的内存地址是否相等，如果为true，则表示的引用的是同一个对象。

2、equals()与"==" 的区别：

（1）== 号在比较基本数据类型时比较的是数据的值，而用 == 号比较两个对象时比较的是两个对象的地址值；

（2）equals()不能用于基本的数据类型，对于基本的数据类型要用其包装类。

（3）默认情况下，也就是从Object继承而来的 equals 方法与 “==” 是完全等价的，比较的都是对象的内存地址，因为底层调用的是 “==” 号，但我们可以重写equals方法，使其按照我们的需求方式进行比较，如String类重写equala()方法，使其比较的是字符的内容，而不再是内存地址。

3、equals()的重写规则：

我们在重写equals方法时，还是需要注意如下几点规则的。

    自反性。对于任何非null的引用值x，x.equals(x)应返回true。

    对称性。对于任何非null的引用值x与y，当且仅当：y.equals(x)返回true时，x.equals(y)才返回true。

    传递性。对于任何非null的引用值x、y与z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也应返回true。

    一致性。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。

    对于任何非空引用值x，x.equal(null)应返回false。

equals()与hashCode()方法：

1、认识HashCode()方法：

 

hashCode的意思就是散列码，也就是哈希码，是由对象导出的一个整型值，散列码是没有规律的，如果x与y是两个不同的对象，那么x.hashCode()与y.hashCode()基本是不会相同的，下面通过String类的hashCode()计算一组散列码：

 

    package com.zejian.test;

    public class HashCodeTest {

    public static void main(String[] args) {

         int hash=0;

         String s="ok";

         StringBuilder sb =new StringBuilder(s);

        

         System.out.println(s.hashCode()+"  "+sb.hashCode());

        

         String t = new String("ok");

         StringBuilder tb =new StringBuilder(s);

         System.out.println(t.hashCode()+"  "+tb.hashCode());

    }

    }

 

    运行结果：

    3548  1829164700

    3548  2018699554

 

我们可以看出，字符串s与t拥有相同的散列码，这是因为字符串的散列码是由内容导出的。而字符串缓冲sb与tb却有着不同的散列码，这是因为StringBuilder没有重写hashCode方法，它的散列码是由Object类默认的hashCode方法计算出来的对象存储地址，所以散列码自然也就不同了。那么我们该如何重写出一个较好的hashCode方法呢，其实并不难，我们只要合理地组织对象的散列码，就能够让不同的对象产生比较均匀的散列码。例如下面的例子：

 

  

package com.zejian.test;     public class Model {     private String name;     private double salary;     private int sex;         @Override     public int hashCode() {          return name.hashCode()+new Double(salary).hashCode()                    + new Integer(sex).hashCode();     }     }

 

 

上面的代码我们通过合理的利用各个属性对象的散列码进行组合，最终便能产生一个相对比较好的或者说更加均匀的散列码，当然上面仅仅是个参考例子而已，我们也可以通过其他方式去实现，只要能使散列码更加均匀（所谓的均匀就是每个对象产生的散列码最好都不冲突）就行了。不过这里有点要注意的就是java 7中对hashCode方法做了两个改进，首先java发布者希望我们使用更加安全的调用方式来返回散列码，也就是使用null安全的方法Objects.hashCode（注意不是Object而是java.util.Objects）方法，这个方法的优点是如果参数为null，就只返回0，否则返回对象参数调用的hashCode的结果。Objects.hashCode 源码如下：

 

    public static int hashCode(Object o) {

            return o != null ? o.hashCode() : 0;

        }

 

因此我们修改后的代码如下：

 

 

package com.zejian.test;     import java.util.Objects;     public  class Model {     private   String name;     private double salary;     private int sex;     @Override     public int hashCode() {          return Objects.hashCode(name)+new Double(salary).hashCode()                    + new Integer(sex).hashCode();     }     }

 

 

java 7还提供了另外一个方法java.util.Objects.hash(Object... objects),当我们需要组合多个散列值时可以调用该方法。进一步简化上述的代码：

 

 

package com.zejian.test;     import java.util.Objects;     public  class Model {     private   String name;     private double salary;     private int sex;     //   @Override     //   public int hashCode() {     //        return Objects.hashCode(name)+new Double(salary).hashCode()     //                 + new Integer(sex).hashCode();     //   }         @Override     public int hashCode() {          return Objects.hash(name,salary,sex);     }     }

 

 

 好了，到此hashCode()该介绍的我们都说了，还有一点要说的，如果我们提供的是一个数组类型的变量的话，那么我们可以调用Arrays.hashCode()来计算它的散列码，这个散列码是由数组元素的散列码组成的。

2、equals()与hashCode()的联系：

 

Java中的equals()方法和hashCode()方法是Object超类中的，所以每个对象都有这两个方法的，有时候我们实现特定的需求，可能要重写这两个方法，下面介绍一下这两个方法的作用。

 

equals()和hashCode()方法是用来在同一类中做比较用的，尤其是在容器里如set存放同一类对象时用来判断放入的对象是否重复。

 

如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。

如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。

3、hashCode()方法的作用：

 

想要明白Java中hashCode()方法的作用，就必须先知道Java中的集合。下面先通过一个问题逐步说明：

 

如果想查找一个集合中是否包含有某个对象，大概的程序代码怎样写呢？

 

你通常是逐一取出每个元素与要查找的对象进行比较，当发现某个元素与要查找的对象进行equals方法比较的结果相等时，则停止继续查找并返回肯定的信息，否则，返回否定的信息。如果一个集合中有很多个元素，比如有一万个元素，并且没有包含要查找的对象时，则意味着你的程序需要从集合中取出一万个元素进行逐一比较才能得到结论。

 

这时，有人发明了一种哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组(使用不同的hash函数来计算的)，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域，HashSet就是采用哈希算法存取对象的集合，它内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域；Object类中定义了一个hashCode()方法来返回每个Java对象的哈希码，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode()方法获得该对象的哈希码，然后根据哈希吗找到相应的存储区域，最后取得该存储区域内的每个元素与该对象进行equals方法比较；这样就不用遍历集合中的所有元素就可以得到结论，可见，HashSet集合具有很好的对象检索性能。

 

所以，总结一下，hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap，HashSet等，hashCode是用来在散列存储结构中确定对象的存储地址的；

4、为什么重写equals()的同时要重写hashCode()方法：

 

在将这个问题的答案之前，我们先了解一下将元素放入集合的流程，如下图：

 

将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。回过来说，在get的时候，集合类也先调key.hashCode()算出数组下标，然后看equals()的结果，如果是true就是找到了，否则就是没找到。

 

以上面的第2节的HashSet为例可知，HashSet集合具有很好的对象检索性能，但是，HashSet集合存储对象的效率相对要低些，因为向HashSet集合中添加一个对象时，要先计算出对象的哈希码和根据这个哈希码确定对象在集合中的存放位置，为了保证一个类的实例对象能在HashSet正常存储，要求这个类的两个实例对象用equals()方法比较的结果相等时，他们的哈希码也必须相等；也就是说，如果 obj1.equals(obj2) 的结果为true,那么obj1.hashCode() == obj2.hashCode() 表达式的结果也要为true；

 

换句话说：当我们重写一个对象的equals方法，就必须重写他的hashCode方法，如果不重写他的hashCode方法的话，Object对象中的hashCode方法始终返回的是一个对象的hash地址，而不同对象的这个地址是永远不相等的。所以这时候即使是重写了equals方法，也不会有特定的效果的，因为hashCode方法如果都不想等的话，就不会调用equals方法进行比较了，所以重写equals()就没有意义了。

 

如果一个类的hashCode()方法没有遵循上述要求，那么，当这个类的两个实例对象用equals()方法比较的结果相等时，他们本来应该无法被同时存储进set集合中，但是，如果将他们存储进HashSet集合中时，由于他们的hashCode()方法的返回值不同(Object中的hashCode方法返回值是永远不同的)，第二个对象首先按照哈希码计算可能被放进与第一个对象不同的区域中，这样，它就不可能与第一个对象进行equals方法比较了，也就可能被存储进HashSet集合中了；所以，Object类中的hashCode()方法不能满足对象被存入到HashSet中的要求，因为它的返回值是通过对象的内存地址推算出来的，同一个对象在程序运行期间的任何时候返回的哈希值都是始终不变的，所以，只要是两个不同的实例对象，即使他们的equals方法比较结果相等，他们默认的hashCode方法的返回值是不同的。

 

接下来，我们就举几个小例子测试一下：

 

测试一：覆盖equals（Object obj）但不覆盖hashCode（）,导致数据不唯一性。

 

 

public class HashCodeTest {          public static void main(String[] args) {              Collection set = new HashSet();              Point p1 = new Point(1, 1);              Point p2 = new Point(1, 1);                    System.out.println(p1.equals(p2));              set.add(p1);   //(1)              set.add(p2);   //(2)              set.add(p1);   //(3)                    Iterator iterator = set.iterator();              while (iterator.hasNext()) {                  Object object = iterator.next();                  System.out.println(object);              }          }      }            class Point {          private int x;          private int y;                public Point(int x, int y) {              super();              this.x = x;              this.y = y;          }                @Override          public boolean equals(Object obj) {              if (this == obj)                  return true;              if (obj == null)                  return false;              if (getClass() != obj.getClass())                  return false;              Point other = (Point) obj;              if (x != other.x)                  return false;              if (y != other.y)                  return false;              return true;          }                @Override          public String toString() {              return "x:" + x + ",y:" + y;          }      }        输出结果：     true     x:1,y:1      x:1,y:1

 

 

 

原因分析：

 

（1）当执行set.add(p1)时（1），集合为空，直接存入集合；

 

（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，因为没有覆盖hashCode方法，所以jdk使用默认Object的hashCode方法，返回内存地址转换后的整数，因为不同对象的地址值不同，所以这里不存在与p2相同hashCode值的对象，因此jdk默认不同hashCode值，equals一定返回false，所以直接存入集合。

 

 （3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，继续判断equals是否返回true，因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。

 

测试二：覆盖hashCode方法，但不覆盖equals方法，仍然会导致数据的不唯一性。

 

修改Point类：

class Point {          private int x;          private int y;                public Point(int x, int y) {              super();              this.x = x;              this.y = y;          }                @Override          public int hashCode() {              final int prime = 31;              int result = 1;              result = prime * result + x;              result = prime * result + y;              return result;          }                @Override          public String toString() {              return "x:" + x + ",y:" + y;          }            }        输出结果：     false     x:1,y:1      x:1,y:1

 

原因分析：

 

（1）当执行set.add(p1)时（1），集合为空，直接存入集合；

 

（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，这里覆盖了hashCode方法，p1和p2的hashCode相等，所以继续判断equals是否相等，因为这里没有覆盖equals，默认使用'=='来判断，所以这里equals返回false，jdk认为是不同的对象，所以将p2存入集合。

 

 （3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，并且equals返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。

 

综合上述两个测试，要想保证元素的唯一性，必须同时覆盖hashCode和equals才行。

 

（注意：在HashSet中插入同一个元素（hashCode和equals均相等）时，会被舍弃，而在HashMap中插入同一个Key（Value 不同）时，原来的元素会被覆盖。）

5、重写equals()中 getClass 与 instaceof 的区别：

 

在重写equals() 方法时，一般都是推荐使用 getClass 来进行类型判断（除非所有的子类有统一的语义才使用instanceof），不是使用 instanceof。我们都知道 instanceof 的作用是判断其左边对象是否为其右边类的实例，返回 boolean 类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。

 

下来我们来看一个例子：父类Person

public class Person {             protected String name;             public String getName() {                 return name;             }             public void setName(String name) {                 this.name = name;             }             public Person(String name){                 this.name = name;             }             public boolean equals(Object object){                 if(object instanceof Person){                     Person p = (Person) object;                     if(p.getName() == null || name == null){                         return false;                     }                     else{                         return name.equalsIgnoreCase(p.getName ());                     }                 }                 return false;            }         }   子类 Employee：       public class Employee extends Person{             private int id;             public int getId() {                 return id;             }             public void setId(int id) {                 this.id = id;             }             public Employee(String name,int id){                 super(name);                 this.id = id;             }             /**              * 重写equals()方法              */             public boolean equals(Object object){                 if(object instanceof Employee){                     Employee e = (Employee) object;                     return super.equals(object) && e.getId() == id;                 }                 return false;             }         }

 

上面父类 Person 和子类 Employee 都重写了 equals(),不过 Employee 比父类多了一个id属性,而且这里我们并没有统一语义。测试代码如下：

 

  

public class Test {             public static void main(String[] args) {                 Employee e1 = new Employee("chenssy", 23);                 Employee e2 = new Employee("chenssy", 24);                 Person p1 = new Person("chenssy");                 System.out.println(p1.equals(e1));//true                 System.out.println(p1.equals(e2));//true                 System.out.println(e1.equals(e2));//false             }         }

 

 

上面代码我们定义了两个员工和一个普通人，虽然他们同名，但是他们肯定不是同一人，所以按理来说结果应该全部是 false，但是事与愿违，结果是：true、true、false。对于那 e1!=e2 我们非常容易理解，因为他们不仅需要比较 name,还需要比较 ID。但是 p1 即等于 e1 也等于 e2，这是非常奇怪的，因为 e1、e2 明明是两个不同的类，但为什么会出现这个情况？首先 p1.equals(e1)，是调用 p1 的 equals 方法，该方法使用 instanceof 关键字来检查 e1 是否为 Person 类，这里我们再看看 instanceof：判断其左边对象是否为其右边类的实例，也可以用来判断继承中的子类的实例是否为父类的实现。他们两者存在继承关系，肯定会返回 true 了，而两者 name 又相同，所以结果肯定是 true。所以出现上面的情况就是使用了关键字 instanceof，这是非常容易导致我们“钻牛角尖”。故在覆写 equals 时推荐使用 getClass 进行类型判断。而不是使用 instanceof（除非子类拥有统一的语义）。

6、由hashCode()造成的内存泄露问题：

 

   

package com.weijia.demo;          public class RectObject {     public int x;     public int y;     public RectObject(int x,int y){          this.x = x;          this.y = y;     }     @Override     public int hashCode(){          final int prime = 31;          int result = 1;          result = prime * result + x;          result = prime * result + y;          return result;     }     @Override     public boolean equals(Object obj){          if(this == obj)               return true;          if(obj == null)               return false;          if(getClass() != obj.getClass())               return false;          final RectObject other = (RectObject)obj;          if(x != other.x){               return false;          }          if(y != other.y){               return false;          }          return true;     }     }

 

 我们重写了父类Object中的hashCode和equals方法，看到hashCode和equals方法中，如果两个RectObject对象的x,y值相等的话他们的hashCode值是相等的，同时equals返回的是true;

 

  

package com.weijia.demo;     import java.util.HashSet;     public class Demo {     public static void main(String[] args){          HashSet<RectObject> set = new HashSet<RectObject>();          RectObject r1 = new RectObject(3,3);          RectObject r2 = new RectObject(5,5);          RectObject r3 = new RectObject(3,3);          set.add(r1);          set.add(r2);          set.add(r3);          r3.y = 7;          System.out.println("删除前的大小size:"+set.size());//3          set.remove(r3);          System.out.println("删除后的大小size:"+set.size());//3     }     }       运行结果：     删除前的大小size:3     删除后的大小size:3

 

在这里，我们发现了一个问题，当我们调用了remove删除r3对象，以为删除了r3,但事实上并没有删除，这就叫做内存泄露，就是不用的对象但是他还在内存中。所以我们多次这样操作之后，内存就爆了。看一下remove的源码：  

public boolean remove(Object o) {             return map.remove(o)==PRESENT;         }

 

然后再看一下map的remove方法的源码：

public V remove(Object key) {             Entry<K,V> e = removeEntryForKey(key);             return (e == null ? null : e.value);         }

 

再看一下removeEntryForKey方法源码：

/**          * Removes and returns the entry associated with the specified key          * in the HashMap.  Returns null if the HashMap contains no mapping          * for this key.          */         final Entry<K,V> removeEntryForKey(Object key) {             int hash = (key == null) ? 0 : hash(key);             int i = indexFor(hash, table.length);             Entry<K,V> prev = table[i];             Entry<K,V> e = prev;                  while (e != null) {                 Entry<K,V> next = e.next;                 Object k;                 if (e.hash == hash &&                     ((k = e.key) == key || (key != null && key.equals(k)))) {                     modCount++;                     size--;                     if (prev == e)                         table[i] = next;                     else                         prev.next = next;                     e.recordRemoval(this);                     return e;                 }                 prev = e;                 e = next;             }                  return e;         }

 

 

我们看到，在调用remove方法的时候，会先使用对象的hashCode值去找到这个对象，然后进行删除，这种问题就是因为我们在修改了 r3 对象的 y 属性的值，又因为RectObject对象的hashCode()方法中有y值参与运算,所以r3对象的hashCode就发生改变了，所以remove方法中并没有找到 r3，所以删除失败。即 r3的hashCode变了，但是他存储的位置没有更新，仍然在原来的位置上，所以当我们用他的新的hashCode去找肯定是找不到了.

 

上面的这个内存泄露告诉我一个信息：如果我们将对象的属性值参与了hashCode的运算中，在进行删除的时候，就不能对其属性值进行修改，否则会导致内存泄露问题。

7、基本数据类型和String类型的hashCode()方法和equals()方法：

 

其中8中基本类型的hashCode很简单就是直接返回他们的数值大小，String对象是通过一个复杂的计算方式，但是这种计算方式能够保证，如果这个字符串的值相等的话，他们的hashCode就是相等的。8种基本类型的equals方法就是直接比较数值，String类型的equals方法是比较字符串的值的。

 

 final 

　　在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）。下面将对其详细介绍。

1.1 修饰类

　　当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意：

final类中所有的成员方法都会隐式的定义为final方法。

1.2 修饰方法

使用final方法的原因主要有两个：

　　(1) 把方法锁定，以防止继承类对其进行更改。

　　(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。

final方法意味着“最后的、最终的”含义，即此方法不能被重写。

注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。

转存失败重新上传取消

class A{     private final void getName(){       } }   public class B extends A{     public void getName(){       }       public static void main(String[]args){         System.out.println("OK");     } }

转存失败重新上传取消

　　

1.3 修饰变量

 　　final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。

　　当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。　

　　final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

 

　　当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

 

　　　

 

　　在java中，String被设计成final类，那为什么平时使用时，String的值可以被改变呢？

　　字符串常量池是java堆内存中一个特殊的存储区域，当我们建立一个String对象时，假设常量池不存在该字符串，则创建一个，若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候，例如 String a="A"; a="B" 。a是String对象的一个引用（我们这里所说的String对象其实是指字符串常量），当a=“B”执行时，并不是原本String对象("A")发生改变，而是创建一个新的对象("B")，令a引用它。

2. finally

 　　finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）

　　很多人都认为finally语句块一定会执行，但真的是这样么？答案是否定的，例如下面这个例子：

　　

 

　　当我们去掉注释的三行语句，执行结果为：

　　

 　　为什么在以上两种情况下都没有执行finally语句呢，说明什么问题？

　　只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常，所以try对应的finally语句并没有执行。

　　但是，在某些情况下，即使try语句执行了，finally语句也不一定执行。例如以下情况：

　　

　　finally 语句块还是没有执行，为什么呢？因为我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK ！没有问题，我们不调用 System.exit(0) 这个方法，那么 finally 语句块就一定会执行吗？

　　再一次让大家失望了，答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。

 

易错点

　　在try-catch-finally语句中执行return语句。我们看如下代码：

　　

　　答案：4,4,4  。    为什么呢？

　　首先finally语句在改代码中一定会执行，从运行结果来看，每次return的结果都是4（即finally语句），仿佛其他return语句被屏蔽掉了。

　　事实也确实如此，因为finally用法特殊，所以会撤销之前的return语句，继续执行最后的finally块中的代码。 

　　

3. finalize　　

　　finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。 
特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。 
　　使用finalize还需要注意一个事，调用super.finalize();

　　一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。