这辈子没办法做太多事情，所以每一件都要做到精彩绝伦！
People can't do too many things in my life,so everything will be wonderful
本资料只进行简单介绍说明以及相关重要问题的解答；关于类的详细说明及使用请参考java API文档
本文参考的依据是：JDK API 1.6.0 中文版，下载地址：
1. API
应用程序编程接口Application Programming Interface
就是jdk提供给我们的一些提高编程效率的java类
2. 常用类
2.1 Object类
Object类概述：类层次结构的根类；所有类都直接或间接的继承自该类
构造方法：public Object() 子类的构造方法默认访问的是父类的无参构造方法。
2.1.1 Object类的成员方法
查看API文档和源码：
2.1.1.1 hashCode
public int hashCode();
1，返回该对象的哈希码值。默认情况下，该方法会根据对象的地址值通过哈希算法计算出来一个整数值。
2，不同对象的，hashCode()一般不会相同；但是同一个对象的hashCode()值肯定相同。
public final Class getClass();//可以理解为：字节码文件类，编译后的class类
1，返回此Object的运行时类；（该类的对象）
2，可以通过Class类中的一个方法，获取对象的真实类的全名称：
public StringgetName();//以String的形式返回此Class对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
2.1.1.2 toString
public String toString();
1,返回该对象的字符串表示；底层源码：实际返回的值是：
public String toString() {
return getClass().getName() +"@" + Integer.toHexString(hashCode());
}
Integer.toHexString(hashCode())//将一个整数转化为16进制的字符串
2，默认情况下的数据对我们来说没有意义，一般重写该方法：手动重写或自动重写
2.1.1.3 equals
public boolean equals(Object obj);
源码：publicboolean equals(Object obj) {
return (this ==obj);
}
1，指示其他某个对象是否与此对象“相等”。
2，equals 方法在非空对象引用上实现相等关系： （默认情况下比较的是对象的引用是否相同，也就是比较地址值）
自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
对于任何非空引用值 x，x.equals(null) 都应返回 false。
Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。
3，由于比较对象的引用没有意义，一般重写该方法：手动或自动重写（比较类中的成员变量的值是否相同，String类重写了Object的equals方法，比较数值是否相同）
注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
protected void finalize();
1，当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写finalize方法，以配置系统资源或执行其他清除。
2，垃圾回收器不会马上回收垃圾，但是我们可以建议它尽快回收垃圾（System.gc()方法）
3，主要针对堆内存。
protected Object clone();
1， 创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离
2， 自定义实现克隆步骤：
自定义类实现Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆；
自定义类中重写Object类的clone（）方法；
重写clone（）方法时通过super.clone()调用Object的clone()方法得到该对象的副本，并返回副本。
3，注意：A:克隆和两个引用指向同一个对象的区别?地址值不一样
B:Object类clone()方法虽然简单，易用，但仅仅是一种”浅克隆”,它只克隆该对象所有的Field值，不会
对引用类型的Field所引用的对象进行克隆。开发中，我们也可以实现对象的”深度克隆”。
注意
直接输出一个对象名称，其实默认调用了该对象的toString()方法。
2.2 Scannaer类
(1)在JDK5以后出现的用于键盘录入数据的类。
(2)构造方法：
A:讲解了System.in这个东西。
它其实是标准的输入流,对应于键盘录入
B:构造方法
InputStreamis = System.in;
Scanner(InputStreamis)
C:常用的格式
Scannersc = new Scanner(System.in);
(3)基本方法格式：
A:hasNextXxx()判断是否是某种类型的
B:nextXxx() 返回某种类型的元素
(4)要掌握的两个方法
A:publicint nextInt()
B:publicString nextLine()
(5)需要注意的小问题
A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。
B:解决方案：
a:重新定义一个Scanner对象
b:把所有的数据都用字符串获取，然后再进行相应的转换
2.3 String类
String概述及构造方法
概述：字符串是由多个字符组成的一串数据（字符序列），字符串可以看成是字符数组
构造方法：
public String();
public String(byte[] bytes)
public String(byte[] bytes,int offset,intlength)
public String(char[] value)
public String(char[] value,int offset,intcount)
public String(String original)
String类代表字符串。Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。
例：String s=”abc” ; s也是一个对象。
2.3.1 String类特点
字符串是常量，它的值在创建之后不能更改
new字符串和直接复制的区别
前者创建2个对象，后者创建1个对象。
注意：字符串中的equals()方法重写了Object()的方法，比较的是内容。
内容相同，引用不同。
具体成员方法参考API
2.4 StringBuffer类
概述：如果对字符串进行拼接操作，每次拼接，都会构建义一个新的String对象，既耗时，又浪费空间。而StringBuffer可以解决这个问题。
它是线程安全的可变字符序列。
2.5 数组高级
排序
冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
public static void bubbleSort(int[] arr) {
for(intx=0; x<arr.length-1; x++) {
for(inty=0; y<arr.length-1-x; y++) {
if(arr[y]> arr[y+1]) {
inttemp = arr[y];
arr[y]= arr[y+1];
arr[y+1]= temp;
}
}
}
}
选择排序
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
public static void selectSort(int[] arr) {
for(intx=0; x<arr.length-1; x++) {
for(inty=x+1; y<arr.length; y++) {
if(arr[y]< arr[x]) {
inttemp = arr[x];
arr[x]= arr[y];
arr[y]= temp;
}
}
}
}
查找：
基本查找：数组元素无序
public static int getIndex(int[] arr,int value) {
intindex = -1;
for(intx=0; x<arr.length; x++) {
if(arr[x]== value) {
index= x;
break;
}
}
returnindex;
}
二分查找：数组元素有序
public static int binarySearch(int[] arr,int value) {
intmin = 0;
intmax = arr.length-1;
intmid = (min+max)/2;
while(arr[mid]!= value) {
if(arr[mid]> value) {
max= mid - 1;
}elseif(arr[mid] < value) {
min= mid + 1;
}
if(min> max) {
return-1;
}
mid= (min+max)/2;
}
returnmid;
}
2.6 Arrays类
概述：针对数组进行操作的工具类，提供了排序、查找等功能
常用方法：
把数组转成字符串：public static String toString(数组);
排序：public static void sort();底层是快速排序法
二分查找：public static int binarySearch(数组，key);
2.7 基本类型包装类概述
将基本数据类型封装成对象的好处在于：可以在对象中定义更多的功能方法操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换；
为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2.7.1 Integer
Integer成员方法：其中一部分可以进行常用的进制转换；（2~36进制）
JDK5的新特性：
自动拆装箱：
自动装箱 基本类型--引用类型
自动拆箱 引用类型--基本类型
Integer x = new Integer(4);可以直接写成
Integer x = 4;//自动装箱。
x = x + 5;//自动拆箱。通过intValue方法。
注意：在使用时，Integer x=null;上面的代码就会NPE异常。
2.8 正则表达式
是指一个用来描述或匹配一系列符合某个句法规则的字符串的单个字符串。
规则字符在java.util.regexPattern类中
常见规则
A:字符
x字符 x。举例：'a'表示字符a
\\反斜线字符。
\n新行（换行）符 ('\u000A')
\r回车符 ('\u000D')
B:字符类
[abc]a、b 或 c（简单类）
[^abc]任何字符，除了 a、b 或 c（否定）
[a-zA-Z]a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9]0到9的字符都包括
C:预定义字符类
.任何字符。我的就是.字符本身，怎么表示呢? \.
\d数字：[0-9]
\w单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成
D:边界匹配器
^行的开头
$行的结尾
\b单词边界
就是不是单词字符的地方。
举例：helloworld?haha;xixi
E:Greedy数量词
X?X，一次或一次也没有
X*X，零次或多次
X+X，一次或多次
X{n}X，恰好 n 次
X{n,}X，至少 n 次
X{n,m}X，至少 n 次，但是不超过 m 次
2.9 Calender类
(1)日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
CalendarrightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值publicint get(int field)
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值public void add(int field,int amount)
C:设置日历对象的年月日publicfinal void set(int year,int month,int date)
2.10对象数组
数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
3. 面试题
3.1 1，==和equals()的区别?
A:==
基本类型：比较的是值是否相同
引用类型：比较的是地址值是否相同
B:equals()
只能比较引用类型。默认情况下，比较的是地址值是否相同。
但是，我们可以根据自己的需要重写该方法。一般重写该方法比较的是成员变量是否相同。
3.2 2，字符串的面试题(看程序写结果)
A:==和equals()
Strings1 = new String("hello");
Strings2 = new String("hello");
System.out.println(s1== s2);// false
System.out.println(s1.equals(s2));//true
Strings3 = new String("hello");
Strings4 = "hello";
System.out.println(s3== s4);// false
System.out.println(s3.equals(s4));//true
Strings5 = "hello";
String s6 ="hello";
System.out.println(s5== s6);// true
System.out.println(s5.equals(s6));//true
B:字符串的拼接
Strings1 = "hello";
Strings2 = "world";
Strings3 = "helloworld";
System.out.println(s3== s1 + s2);// false
System.out.println(s3.equals((s1+ s2)));// true
System.out.println(s3== "hello" + "world");// false 这个我们错了，应该是true
System.out.println(s3.equals("hello"+ "world"));// true
3.3 3，String,StringBuffer,StringBuilder的区别（答案百度）
String:不可变的字符序列；
StringBuffer:线程安全的可变字符序列；
StringBuilder：线程不安全的可变字符序列；
三者在执行速度方面的比较：StringBuilder > StringBuffer > String
对于三者使用的总结： 1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer
3.4 4，-128到127之间的数据缓冲池问题
看程序，写结果：
Integer i1=128;
Integer i2=128;
i1=i2;//false
il.equals(i2);//true 重写了Object的equals方法，比较的是数值是否相同。
Integer i3=127;
Integer i4=127;
i3=i4;//true
查看Integer源码：
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
跟踪IntegerCache
IntegerCache.low=-128
IntegerCache.high=127
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i =parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size isInteger.MAX_VALUE
h = Math.min(i,Integer.MAX_VALUE - (-low) -1);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
上述代码延伸：
assert：断言
编写代码时，我们总是会做出一些假设，断言就是用于在代码中捕捉这些假设，可以将断言看作是异常处理的一种高级形式。断言表示为一些布尔表达式，程序员相信在程序中的某个特定点该表达式值为真。可以在任何时候启用和禁用断言验证，因此可以在测试时启用断言，而在部署时禁用断言。同样，程序投入运行后，最终用户在遇到问题时可以重新起用断言。
断言特性
前置条件断言：代码执行之前必须具备的特性
后置条件断言：代码执行之后必须具备的特性
前后不变断言：代码执行前后不能变化的特性