Java快速扫盲指南

摘要：不相等的对象要具有不相等的哈希码为了哈希表的操作效率，这一点很重要，但不是强制要求，最低要求是不相等的对象不能共用一个哈希码。方法和方法协同工作，返回对象的哈希码。这个哈希码基于对象的身份生成，而不是对象的相等性。

本文面向

刚学完Java的新手们。这篇文章不讲语法，而是一些除了语法必须了解的概念。

将要去面试的初级工程师们。查漏补缺，以免遭遇不测。

目前由于篇幅而被挪出本文的知识点：

浅析JVM之内存管理

Java多线程笔记

Java反射学习小记

简谈Java String

JVM：java 虚拟机，负责将编译产生的字节码转换为特定机器代码，实现一次编译多处执行；

JRE：java运行时环境，包含了java虚拟机jvm，java基础类库。是使用java语言编写的程序运行所需要的软件环境；

JDK：java开发工具包，是编写java程序所需的开发工具。JDK包含了JRE，同时还包含了编译器javac，调试和分析工具，JavaDoc。

上图表示了Java代码是怎么编译和加载的

整个流程从 Java 源码开始，经过 javac 程序处理后得到类文件，这个文件中保存的是编译源码后得到的 Java 字节码。类文件是 Java 平台能处理的最小功能单位，也是把新代码传给运行中程序的唯一方式。

新的类文件通过类加载机制载入虚拟机，从而把新类型提供给解释器执行。

所有类都直接或间接扩展 java.lang.Object 类。这个类定义了很多有用的方法，而且你可以根据需求来重写这些方法。

toString( ) 方法的作用是返回对象的文本表示形式。连接字符串或使用 System.out.println( ) 等方法时，会自动在对象上调用这个方法。给对象提供文本表示形式，十分利于调试或记录日志，而且精心编写的 toString( ) 方法还能给报告生成等任务提供帮助。

Object 类中的 toString( ) 方法返回的字符串由对象所属的类名和对象的十六进制形式哈希码（由 hashCode( ) 方法计算得到，本章节稍后会介绍）组成。这个默认的实现方式提供了对象的类型和标识两个基本信息，但一般并没什么用。

== 运算符测试两个引用是否指向同一个对象（比较两个内存单元的内容是否一样）。如果要测试两个不同的对象是否相等，必须使用 equals( ) 方法。任何类都能覆盖 equals( ) 方法，定义专用的相等比较方式。Object.equals( ) 方法直接使用 == 运算符，只有两个对象是同一个对象时，才判定二者相等。

很多类以及自定义类的equals方法都需要重写，是需要根据场景与需求来定制的。JDK自带的许多类往往都是：

对比一些简单的属性值

再对比复杂的属性值or对比业务上最快能区分对象的值

再对比其他的值or对比地址、长度

主要为了将那些不匹配的情况尽快排除

Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。 如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值，实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了。

另外注意，默认的hashCode会发起native调用，如果用hashCode对两个对象对比，会导致开销增大。
hashcode方法的作用

只要覆盖了 equals( ) 方法，就必须覆盖 hashCode( ) 方法。hashCode( ) 方法返回一个整数，用于哈希表数据结构。如果两个对象经 equals( ) 方法测试是相等的，它们就要具有相同的哈希码。不相等的对象要具有不相等的哈希码（为了哈希表的操作效率），这一点很重要，但不是强制要求，最低要求是不相等的对象不能共用一个哈希码。为了满足最低要求，hashCode( ) 方法要使用稍微复杂的算法或位操作。

Object.hashCode( ) 方法和 Object.equals( ) 方法协同工作，返回对象的哈希码。这个哈希码基于对象的身份生成，而不是对象的相等性。（如果需要使用基于身份的哈希码，可以通过静态方法 System.identityHashCode( ) 获取 Object.hashCode( ) 方法的返回值。）

hashCode和equal方法

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

如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；

如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；

两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object)方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们"存放在同一个篮子里"。

HashCode和equal方法

如果一个类实现了 Comparable 接口，就可以比较一个实例是小于、大于还是等于另一个实例。这也表明，实现 Comparable 接口的类可以排序。

因为 compareTo( ) 方法不在 Object 类中声明，所以由每个类自行决定实例能否排序。如果能排序就定义 compareTo( ) 方法，实现实例排序的方式。

compareTo( ) 方法返回一个 int 类型的值，这个值需要进一步说明。如果当前对象（this）小于传入的对象，compareTo( ) 方法应该返回一个负数；如果两个对象相等，应该返回 0；如果当前对象大于传入的对象，应该返回一个正数。

Object 类定义了一个名为 clone( ) 的方法，这个方法的作用是返回一个对象，并把这个对象的字段设为和当前对象一样。clone( ) 方法不常用，原因有两个。其一，只有类实现了 java.lang.Cloneable 接口，这个方法才有用。Cloneable 接口没有定义任何方法（是个标记接口），因此若想实现这个接口，只需在类签名的 implements 子句中列出这个接口即可。其二，clone( ) 方法声明为 protected，因此，如果想让其他类复制你的对象，你的类必须实现 Cloneable 接口，并覆盖 clone( ) 方法，而且要把 clone( ) 方法声明为 public。

clone( ) 方法很难正确实现，而副本构造方法实现起来更容易也更安全。

一种古老的资源管理技术叫终结（finalization），开发者应该知道有这么一种技术。然而，这种技术几乎完全废弃了，任何情况下，大多数 Java 开发者都不应该直接使用。

只有少数应用场景适合使用终结，而且只有少数 Java 开发者会遇到这种场景。如果有任何疑问，就不要使用终结，处理资源的 try 语句往往是正确的替代品。

终结机制的作用是自动释放不再使用的资源。垃圾回收自动释放的是对象使用的内存资源，不过对象可能会保存其他类型的资源，例如打开的文件和网络连接。垃圾回收程序不会为你释放这些额外的资源，因此，终结机制的作用是让开发者执行清理任务，例如关闭文件、中断网络连接、删除临时文件，等等。

终结机制的工作方式是这样的：如果对象有 finalize( ) 方法（一般叫作终结方法），那么不再使用这个对象（或对象不可达）后的某个时间会调用这个方法，但要在垃圾回收程序回收分配给这个对象的空间之前调用。终结方法用于清理对象使用的资源。

另外注意，这是一个实例方法。而在类上，没有等效的机制。

8种基本类型对应的包装类也是被final修饰。另外，String类和StringBuffer类也是被final修饰的。

引用类型和对象与基本类型和基本值有本质的区别。

八种基本类型由 Java 语言定义，程序员不能定义新基本类型。引用类型由用户定义，因此有无限多个。例如，程序可以定义一个名为 Point 的类，然后使用这个新定义类型的对象存储和处理笛卡儿坐标系中的 (x, y) 点。

基本类型表示单个值。引用类型是聚合类型（aggregate type），可以保存零个或多个基本值或对象。例如，我们假设的 Point 类可能存储了两个 double 类型的值，表示点的 x 和 y 坐标。char[ ] 和 Point[ ] 数组类型是聚合类型，因为它们保存一些 char 类型的基本值或 Point 对象。

基本类型需要一到八个字节的内存空间。把基本值存储到变量中，或者传入方法时，计算机会复制表示这个值的字节。而对象基本上需要更多的内存。创建对象时会在堆（heap）中动态分配内存，存储这个对象；如果不再需要使用这个对象了，存储它的内存会被自动垃圾回收。

把对象赋值给变量或传入方法时，不会复制表示这个对象的内存，而是把这个内存的引用存储在变量中或传入方法。

在 Java 中，引用完全不透明，引用的表示方式由 Java 运行时的实现细节决定。如果你是 C 程序员的话，完全可以把引用看作指针或内存地址。不过要记住，Java 程序无法使用任何方式处理引用。

似乎看的有点晕？来点儿代码吧！

下述代码处理 int 类型基本值：

int x = 42;
int y = x;

执行这两行代码后，变量 y 中保存了变量 x 中所存值的一个副本。在 Java 虚拟机内部，这个 32 位整数 42 有两个独立的副本。

现在，想象一下把这段代码中的基本类型换成引用类型后再运行会发生什么：

Point p = new Point(1.0, 2.0);
Point q = p;

运行这段代码后，变量 q 中保存了一份变量 p 中所存引用的一个副本。在虚拟机中，仍然只有一个 Point 对象的副本，但是这个对象的引用有两个副本----这一点有重要的含义。假设上面两行代码的后面是下述代码：

System.out.println(p.x);  // 打印p的x坐标：1.0
q.x = 13.0;               // 现在，修改q的x坐标
System.out.println(p.x);  // 再次打印p.x，这次得到的值是13.0

因为变量 p 和 q 保存的引用指向同一个对象，所以两个变量都可以用来修改这个对象，而且一个变量中的改动在另一个变量中可见。数组也是一种对象，所以对数组来说也会发生同样的事，如下面的代码所示：

// greet保存一个数组的引用
char[ ] greet = { "h","e","l","l","o" };
char[ ] cuss = greet;             // cuss保存的是同一个数组的引用
cuss[4] = "!";                   // 使用引用修改一个元素
System.out.println(greet);       // 打印“hell!”

把基本类型和引用类型的参数传入方法时也有类似的区别。假如有下面的方法：

void changePrimitive(int x) {
    while(x > 0) {
        System.out.println(x--);
    }
}

调用这个方法时，会把实参的副本传给形参 x。在这个方法的代码中，x 是循环计数器，向零递减。因为 x 是基本类型，所以这个方法有这个值的私有副本——这是完全合理的做法。

可是，如果把这个方法的参数改为引用类型，会发生什么呢？

void changeReference(Point p) {
    while(p.x > 0) {
        System.out.println(p.x--);
    }
}

调用这个方法时，传入的是一个 Point 对象引用的私有副本，然后使用这个引用修改对应的 Point 对象。例如，有下述代码：

Point q = new Point(3.0, 4.5); // 一个x坐标为3的点
changeReference(q);            // 打印3，2，1，而且修改了这个Point对象
System.out.println(q.x);       // 现在，q的x坐标是0！

调用 changeReference( ) 方法时，传入的是变量 q 中所存引用的副本。现在，变量 q 和方法的形参 p 保存的引用指向同一个对象。这个方法可以使用它的引用修改对象的内容。但是要注意，这个方法不能修改变量 q 的内容。也就是说，这个方法可以随意修改引用的 Point 对象，但不能改变变量 q 引用这个对象这一事实。

那么在用运算符：==时，也会有差别。

相等运算符（==）比较基本值时，只测试两个值是否一样（即每一位的值都完全相同）。而 == 比较引用类型时，比较的是引用而不是真正的对象。也就是说，== 测试两个引用是否指向同一个对象，而不测试两个对象的内容是否相同。

在 JDK1.2 后，Java 对引用概念扩充，分为强引用、软引用、弱引用、虚引用。强度渐弱。

在开始了解前，最好先稍微了解一下Java Memory Model。我的这篇文章中简单的讲了一下JMM

就是值在程序代码之中普遍存在的，类似 Object obj = new Object() 这类的引用，只要强引用还在，垃圾收集器永远不会回收掉被引用的对象。

它关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围内进行第二次回收。提供 SoftReference 类来实现软引用。

强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。提供 WeakReference 类来实现软引用。

一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来去的一个对象实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。提供 PhantomReference 类来实现软引用。

Java 7之基础 - 强引用、弱引用、软引用、虚引用

Java垃圾回收机制与引用类型

数组类型不是类，但数组实例是对象。这意味着，数组从 java.lang.Object 类继承了方法。数组实现了 Cloneable 接口，而且覆盖了 clone( ) 方法，确保数组始终能被复制，而且 clone( ) 方法从不抛出 CloneNotSupportedException 异常。数组还实现了 Serializable 接口，所以只要数组中元素的类型能被序列化，数组就能被序列化。而且，所有数组都有一个名为 length 的字段，这个字段的修饰符是 public final int，表示数组中元素的数量。

因为数组扩展自 Object 类，而且实现了 Cloneable 和 Serializable 接口，所以任何数组类型都能放大转换成这三种类型中的任何一种。而且，特定的数组类型还能放大转换成其他数组类型。如果数组中的元素类型是引用类型 T，而且 T 能指定给类型 S，那么数组类型 T[ ] 就能指定给数组类型 S[ ]。注意，基本类型的数组不能放大转换。例如，下述代码展示了合法的数组放大转换：

String[ ] arrayOfStrings;      // 创建字符串数组
int[ ][ ] arrayOfArraysOfInt;   // 创建int二维数组
Object[ ] oa = arrayOfStrings;// String可以指定给Object，因此String[ ]可以指定给Object[ ]
Comparable[ ] ca = arrayOfStrings;// String实现了Comparable接口,因此String[ ]可以视作Comparable[ ]
Object[ ] oa2 = arrayOfArraysOfInt;// int[ ]是Object类的对象，因此int[ ][ ]可以指定给Object[ ]
// 所有数组都是可以复制和序列化的对象
Object o = arrayOfStrings;
Cloneable c = arrayOfArraysOfInt;
Serializable s = arrayOfArraysOfInt[0];

因为数组类型可以放大转换成另一种数组类型，所以编译时和运行时数组的类型并不总是一样。这种放大转换叫作"数组协变"（array covariance）。

所以在某种意义上，集合框架比数组好用：

Object [] objectArray = new Long[1];
objectArray[0] = "I dont fit in"; //Throws ArrayStoreException

List