lsplibrary的神秘应用成就介绍，

found = true;

break;

}

}

29. 面向对象的三大特性

l 封装：属性私有化，对外提供公开的SET、GET方法，使程序更加健壮

l 继承：子类可以继承父类的东西，这样有利于代码的重用。

l 多态：指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。使用多态不但能减少编码的工作量，还能使代码之间的耦合度降低，大大提高程序的可维护性及可扩展性。

关于java语言中向上转型和向下转型

1.向上转型(upcasting)自动类型转换:子--->父Animal a1=new Cat();父类型的引用指向子类型对象

2.向下转型(downcasting)强制类型转换:父--->子Catc1=(Cat)a2;

l 多态的条件是：

a) 有继承或实现

b) 有方法的覆盖或实现

c) 父类对象（接口）指向子类对象

30. 五大原则

<1> 单一职责原则SRP(Single Responsibility Principle)

是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

<2> 开放封闭原则OCP(Open－Close Principle)

一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

<3> 里氏替换原则LSP(the Liskov Substitution Principle LSP)

子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

<4> 依赖倒置原则DIP(the Dependency Inversion Principle DIP)

传统的结构化编程中，最上层的模块通常都要依赖下面的子模块来实现，也称为高层依赖低层！所以DIP原则就是要逆转这种依赖关系，让高层模块不要依赖低层模块，所以称之为依赖倒置原则！

<5> 接口分离原则ISP(the Interface Segregation Principle ISP)

模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来

1. 覆盖（Override）

继承最基本的作用：代码重用。继承最重要的作用：方法可以重写。

l 方法名，返回值类型，参数列表必须相同

l 修饰符：重写的方法不能比被重写的方法拥有更低的访问权限。

l 重写的方法不能比被重写的方法抛出更宽泛的异常。

l 私有的方法不能被覆盖。(多态之后讲)

l 构造方法无法被覆盖。因为构造方法无法被继承。

l 静态的方法不存在覆盖。(多态之后讲)

l 覆盖指的是成员方法，和成员变量无关。

2. 重载（Overload）

l 方法名必须相同，

l 参数列表必须不同（类型、个数、顺序）

l 返回类型、修饰符也可以不同

3. 构造方法

<1> 不能有返回值

<2> 构造方法的作用

a) 创建对象：new构造方法名（实参）；在堆中开辟空间存储对象

b) 初始化成员变量

<3> 如果一个类没有提供任何构造方法，则系统默认提供无参构造方法。

如果手动提供提供构造方法，系统将不再提供任何构造方法。

<4> 构造方法无法被继承，可以被重载，但不可以被覆盖

4. 传值与引用

<1> 不管参数类型是什么，全部是传递参数的副本。

如果参数是基本数据类型，则传递的是值的副本，如果参数是对象，则传递的是该对象引用的副本，因为对象存放在堆里，较基本数据类型，占内存比较大。

<2> 成员变量在什么时候赋值？只有在调用构造方法时才会赋值。

<3> 若把引用的副本看作是值，则有以下说法：不管是基本类型还是对象类型都值传递，

<4> 按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。

5. static

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块。

类名.静态方法名(参数列表...)

类名.静态变量名

<1> static变量

被static修饰的变量，叫静态变量或类变量，没有修饰的变量，叫实例变量。

n 静态变量在类加载时初始化，静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

n 实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

所以一般在需要实现以下两个功能时使用静态变量：

1) 在对象之间共享值时

2) 方便访问变量时

<2> 静态方法

a) 静态方法可以直接通过类名调用，任何的实例也都可以调用。

b) 一般情况下，工具类中的方法都是静态方法。

c) 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

d) 它们仅能调用其他的static方法、static数据，在一个static方法中引用任何实例变量都是非法的

e) 它们不能以任何方式引用this或super

f) static方法是类方法，在编译时静态绑定的（private、static、final修饰的方法是静态绑定的），所以他们修饰的方法不能实现多态,当然不需要被子类覆盖了（子类覆盖父类方法是为了实现多态）。能被继承。而其他的方法在运行时动态绑定。

<3> static代码块

static代码块也叫静态代码块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

实例语句块，{system.out.print（“A“）}在构造方法前执行。

<4> static和final一块用表示什么？

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！

对于变量，表示一旦给值就不可修改，并且通过类名可以访问。

对于方法，表示不可覆盖，并且可以通过类名直接访问。

6. this，super

<1> this

l this是引用类型，在堆中的每一个对象上都有this，保存内存地址指向自身

this不能用在静态环境中（static变量,static方法，static语句块），只能用在成员方法和构造方法中，代表当前对象，静态方法的执行根本就不需要对象的存在

l this( )用在构造方法中，用来调用另外一个构造方法，必须在第一行

l this可以用来区分成员变量与局部变量 this.age=age;

<2> super

l super不能应用在静态方法中，只能应用在成员方法和构造方法中，（和this是一样的）

l super(参数列表 )可以在子类构造方法中调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

l super.方法名(参数列表)可以在子类中调用父类的成员方法，子类的成员方法覆盖了父类的成员方法时，此时，用“super.方法名(参数列表)”的方式访问父类的方法。

l 区分变量：当子类方法中的局部变量或成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

l 子类中没有显示调用构造方法，会默认调用直接父类的无参构造方法，此种情况下如果父类中没有无参构造方法，那么编译时将会失败。

l 一个构造方法第一行如果没有this(...);也没有显示的去调用super(...);系统会默认调用super();

l super(....)和this(....)不能共存。

l super(...);调用了父类中的构造方法，但是并不会创建父类对象。

<3> this和super的异同

l super( )和this( )类似,区别是，super( )从子类中调用父类的构造方法，this( )调用同一类的构造方法。

l this( )和super( )不能同时出现在一个构造函数里面，因为this( )必然会调用其它的构造函数，其它的构造函数必然也会有super( )语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

7. 使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：

final StringBuffer a=new StringBuffer("immutable"); 执行如下语句将报告编译期错误：

a=new StringBuffer(""); 但是，执行如下语句则可以通过编译：

a.append(" broken!");

有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：

public void method(final StringBuffer param){

}

实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：

param.append("a");

8. final、finalize、finally

通常考试时给一张纸，写答案。三个词的概念完全不一样

<1> final

n final用来修饰类，无法被继承（用final修饰的类叫做最终类！！！）

n final用来修饰方法，无法被覆盖

n final用来修局部变量，一旦赋值，无法被改变

n final用来修成员变量，需要手动赋值

n final修成员变量与static连用，称为常量，常量全部大写

<2> finalize( )

是Object一个方法的名字，垃圾回收器在回收java对象之前会先自动调用java对象的finalize方法。

<3> finally

异常处理机制中的语句块，finally语句块总是会执行。

9. 抽象类

1. 抽象类不能被final修饰

2. 抽象类无法被实例化，但是有构造方法，构造方法，给子类创建对象用

4. 抽象类中可以定义抽象方法abstract void m1();到了一个强制的约束作用，要求子类必须实现

5. 非抽象类中不可以有抽象方法

6. 一个非抽象类继承抽象类，必须将其抽象方法全部实现

10. 接口

1. 接口是特殊类型的抽象类，特殊在接口是完全抽象的

2. 接口中没有构造方法，无法被实例化

3. 接口与接口之间可以实现多继承interface emplements A，B，C{}，但接口之间不可以实现，解决了Java单继承的问题

4. 一个类可以实现多个接口

5. 一个非抽象类实现接口，必须把接口中全部方法实现&覆盖&重写

6. 使项目分层，所有层均面向接口编程，开发效率高，降低耦合

11. 接口和抽象类的区别

l 接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

l 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

l 抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。

同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

l 接口可继承接口，并可多继承接口，但类只能单根继承。

12. abstract的method是否可同时是static, native，synchronized?

Abctract：是用来继承的

另外两个必须有方法体

13. Object基类的方法

方法名

返回类型

作用

clone( )

Object

创建并返回此对象的一个副本

equals( )

boolean

指示其他某个对象是否与此对象“相等”

finalize( )

void

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

getClass( )

Object

返回此Object的运行时类

hashCode( )

Int

返回该对象的哈希码值

notify( )

Void

唤醒在此对象监视器上等待的单个线程

notify All( )

Void

唤醒在此对象监视器上等待的所有线程

toString( )

String

返回该对象的字符串表示

Wait( )

void

在其他线程调用此对象的notify()方法或notify

写clone()方法时，通常都有一行代码，是什么？

clone 有缺省行为，

super.clone();

因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

14. HashCode和Equals方法

1、如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；

2、如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)。

为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，这对比需要比较的数量很大的效率提高是很明显的，一个很好的例子就是在集合中的使用；set集合是无序的，因此是不能重复的，那么怎么能保证不能被放入重复的元素呢，但靠equals方法一样比较的

话，如果原来集合中以后又10000个元素了，那么放入10001个元素，难道要将前面的所有元素都进行比较，看看是否有重复，欧码噶的，这个效率可想而知，因此hashcode就应遇而生了，java就采用了hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。

继续上面的话题，为什么必须要重写hashcode方法，其实简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的

15. 内部类

1. 静态内部类

1) 静态内部类可以等同看做静态变量，可用访问控制权限的修饰符修饰。

2) 内部类重要的作用：可以访问外部类中私有的数据。

3) 静态内部类可以直接访问外部类的静态数据,无法直接访问成员。

2. 成员内部类

1) 成员内部类可以等同看做成员变量，可用访问控制权限的修饰符修饰

2) 成员内部类中不能有静态声明.

3) 成员内部类可以访问外部类所有的数据.

3. 局部内部类

1) 局部内部类等同于局部变量，不能用访问控制权限修饰符修饰。

2) 重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰。

3) 局部内部类不能有静态声明

4. 匿名内部类

指的是类没有名字的类

.

16. 异常定义

常见的运行时异常（RuntimeException）

java.lang.ArithmeticException

算术异常

5/0

ClassCastException

类型转化异常

Cat cat=new Dog( );

IllegalArgumentException

非法参数异常

IndexOutOfBoundsException

下表越界异常）

NullPointerException

空指针异常

SecurityException

由安全管理器抛出的异常，指示存在安全侵犯。

1.异常是什么？

第一，异常模拟的是现实世界中“不正常的”事件。

第二，java中采用“类”去模拟异常。

第三，类是可以创建对象的。

NullPointerExceptione=0x1234;

e是引用类型，e中保存的内存地址指向堆中的“对象”，这个对象一定是NullPointerException类型。

这个对象就表示真实存在的异常事件（实例）。

NullPointerException是一类异常。

“抢劫”就是一类异常。----->类

“张三被抢劫”就是一个异常事件---->对象

2.异常机制的作用？

java语言为我们提供一种完善的异常处理机制，

作用是：程序发生异常事件之后，为我们输出详细的信息，

程序员通过这个信息，可以对程序进行一些处理，使程序更加健壮。

本质：程序执行过程中发生了算数异常这个事件，JVM为我们创建了一个ArithmeticException类型的对象。

并且这个对象中包含了详细的异常信息，并且JVM将这个对象中的信息输出到控制台。

17. 异常的分类

18. 处理异常的两种方式

<1> 声明抛出throws

以下程序演示第一种方式:声明抛出，在方法声明的位置上使用throws关键字向上抛出异常。

1. 深入throws

2. 底层实现原理

<2> try...catch...

语法：

try{

可能出现异常的代码;

}catch(异常类型1变量){

处理异常的代码;

}catch(异常类型2变量){

处理异常的代码;

}....

1) catch语句块可以写多个.

2) try中的代码出现异常时，出现异常下面的代码不会执行

3) 但是从上到下catch,必须从小类型异常到大类型异常进行捕捉。

4) try...catch...中最多执行1个catch语句块。执行结束之后try...catch...就结束了。

19. getMessage和printStackTrace

何取得异常对象的具体信息，常用的方法主要有两种：

取得异常描述信息：getMessage()

取得异常的堆栈信息(比较适合于程序调试阶段)：printStackTrace()

20. 关于finally语句块

1.finally语句块可以直接和try语句块联用。try....finally...

2.try...catch....finally也可以.

3.在finally语句块中的代码是一定会执行的。

4.System.exit(0);//正常退出JVM只要在执行finally语句块之前退出了

JVM，则finally语句块不会执行

5. finally例题

6. finally语句块是一定会执行的，所以通常在程序中为了保证某资源一定会释放，所以一般在finally语句块中释放资源。

7．try和finally中都有return语句，执行哪一个return？

执行try块，执行到return语句时，先执行return的语句，但是不返回到main 方法，接下来执行finally块，遇到finally块中的return语句，执行,并将值返回到main方法，这里就不会再回去返回try块中计算得到的值

8.重写的方法不能比被重写的方法抛出更宽泛的异常.

21. 受控异常和非受控异常

受控异常：CheckedException，这类异常必须写try{}catch{}，或者throw抛出，否则编译通不过。

非受控异常：UncheckedException，这类异常也叫做运行时异常（与非受控异常字数相等），这类异常不需要try{}catch{}，也不需要throw抛出，编译能通过。

为什么要使用非受控异常？为了简化代码。试想一下，如果所有可能出现异常的地方（比如访问数组元素可能会越界、调用对象方法，对象可能为null），我们都写try{}catch{}，或者throw抛出，那么代码肯定冗余的不成样子了。也就是说，采用非受控异常（运行时异常）可以减少代码的污染。

对于非受控异常（运行时异常），因为不需要额外处理，也能编译通过，我们可以进行预先检查，比如访问数组元素时，我们预先检查是否越界，调用对象方法时，预先检查对象是否为null

22. throw和throws

<1> throws出现在方法声明的后面，异常由方法的调用者处理；而throw出现在方法体，由方法体内的语句来处理。

<2> throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常，是一个实例。

<3> 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

23. String和StringBuffer和StringBuilde

<1> String

String类是不可变类，也就是说String对象声明后，将不可修改。

1.如果是采用双引号引起来的字符串常量，首先会到常量池（方法区）中去查找，如果存在就不再分配，如果不存在就分配，常量池中的数据是在编译期赋值的，也就是生成class文件时就把它放到常量池里了，所以s1和s2都指向常量池中的同一个字符串“abc”

2.关于s3，s3采用的是new的方式，在new的时候存在双引号，所以他会到常量区中查找“abc”，而常量区中存在“abc”，所以常量区中将不再放置字符串，而new关键子会在堆中分配内存，所以在堆中会创建一个对象abc，s3会指向abc

3.如果比较s2和s3的值必须采用equals，String已经对eqauls方法进行了覆盖 。

31. String s = new String("abc");

32. String s1 = "abc";

33. String s2 = new String("abc");

34.

35. System.out.println(s == s1);

36. System.out.println(s == s2);

37. System.out.println(s1 == s2);

请问以上程序执行结果是什么？

第一句执行后内存中有两个 对象，而不是一个。一个由new String("abc")中的"abc"在String Pool里生成一个值为"abc"的对象；第二个由new在堆里产生一个值为"abc"的对象，该对象完全是String Pool里的"abc"的一个拷贝。变量s最后指向堆中产生的"abc"对象；

第二句执行时，s1先去String Pool找是否有值为"abc"的对象，很显然在上一步中java已经在String Pool里生成一个"abc"对象了，所以s1直接指向String Pool中的这个"abc"；

第三句中又有一个new，在java中凡遇到new时，都会在堆里产生一个新的对象。因此，该句执行后堆里又多了一个"abc"对象，这与执行第一句后生成的"abc"是不同的两个对象，s2最后指向这个新生成的对象。

因此，执行后面的打印语句的结果是三个false

String常用方法

endWith判断字符串是否以指定的后缀结束startsWith判断字符串是否以指定的前缀开始equals字符串内容比较equalsIgnoreCase字符串内容比较，忽略大小写indexOf取得指定字符串在字符串的位置lastIndexOf返回最后一次出现的位置length取得字符串长度replaceAll替换字符串中指定的内容split根据指定的表达式拆分字符串substring截子串tirm去前尾空格valueOf将其他类型转换成字符串

<2> StringBuffer

先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。StringBuffer是可变对象，这个是String最大的不同。

<3> StringBuilder

用法同StringBuffer，StringBuilder和StringBuffer的区别是StringBuffer中所有的方法都是同步的，是线程安全的，但速度慢，StringBuilder的速度快，但不是线程安全的。

24. java中replace()和replaceAll()区别

<1> replace的参数是char和CharSequence（串）,即可以支持字符的替换,也支持字符串的替换

<2> replaceAll的参数是regex,即基于规则表达式的替换,比如,可以通过replaceAll("\\d","*")把一个字符串所有的数字字符都换成星号;

<3> 相同点：都是全部替换,即把源字符串中的某一字符或字符串全部换成指定的字符或字符串

<4> replaceFirst()：如果只想替换第一次出现的,可以使用replaceFirst(),这个方法也是基于规则表达式的替换,但与replaceAll()不同的是,只替换第一次出现的字符串;

<5> 如果replaceAll()和replaceFirst()所用的参数据不是基于规则表达式的,则与replace()替换字符串的效果是一样的,即这两者也支持字符串的操作;

<6> 还有一点注意:执行了替换操作后,源字符串的内容是没有发生改变的.

举例如下:

关于字符串中的"\"替换：

'\'在java中是一个转义字符，所以需要用两个代表一个。例如System.out.println("\\");只打印出一个"\"。但是'\'也是正则表达式中的转义字符（replaceAll的参数就是正则表达式），需要用两个代表一个。所以：\\\\被java转换成\\,\\又被正则表达式转换成\。

将字符串中的'/'替换成'\':

25. 枚举类型

需求：定义一个方法，该方法的作用是计算两个int类型数据的商。

如果计算成功则该方法返回1,如果执行失败则该方法返回0

程序执行成功，但是该程序存在风险，分析：存在什么风险？返回类型int范围太广

程序中的问题能在编译阶段解决的，绝对不会放在运行期解决。所以以下程序可以引入“枚举类型”。

三、Java容器框架

Java容器类库一共有两种主要类型Collection（单列集合）和Map（双列集合）。

所有的java容器类都可以自动调整自己的尺寸。

26. Collection

Collection接口是Set、List和Queue接口的父接口。

27. List

List:代表有序、可重复的集合。所以与Set相比，增加了与索引位置相关的操作；

1. ArrayList集合底层是数组。数组是有下标的。擅长随机访问，但在List中间插入、删除、移动元素较慢。

ArrayList集合底层默认初始化容量是10.扩大之后的容量是原容量的1.5倍.

2. LinkedList：插入、删除、移动元素方便，随机访问比较差。

3. Vector集合底层是数组,默认初始化容量也是10.扩大之后的容量是原容量的2倍，线程安全，效率较低

4. ArrayList与Vector区别：

线程不安全VS线程安全：对于单线程的程序选用ArrayList，效率高

扩容1.5VS扩容2

5. 如果优化ArrayList和Vector?

尽量减少扩容操作，因为扩容需要数组拷贝。数组拷贝很耗内存。

一般推荐在创建集合的时候指定初始化容量。

28. List list=new和ArrayList list=new这两种方式有什么区别，为什么大多数情况下会用第一种。

List是一个接口，而ArrayList 是一个类。

List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。

为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？

问题就在于List有多个实现类，如 LinkedList或者Vector等等，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类呢？，这时你只要改变这一行就行了：List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList(); ,便于程序代码的重构. 这就是面向接口编程的好处。

29.

30. Set

Set代表无序、不可重复的集合，判断两个对象是否相同则是根据equals方法。

1. HashSet：底层是HashMap，HashMap底层采用了哈希表数据结构，查找插入优于TreeSet。

HashSet其实是HashMap中的key部分。HashSet有什么特点，HashMap中的key应该具有相同的特点。

HashMap和HashSet初始化容量都是16,默认加载因子是0.75。

存储在HashSet集合或者HashMap集合key部分的元素，需要同时重写hashCode+equals

2. TreeSet：实现SortedSet集合接口，其中的元素自动排序。因为被存储的元素实现了Comparable接口，SUN编写TreeSet集合在添加元素的时候，会调用compareTo方法完成比较。

3. LinkedHashSet：使用链表结合散列函数。

4. Queue新增的体系集合，代表一种队列集合实现。

31. Iterator

<1> list删除元素操作

错误的方法：

如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：

for(inti=0;i<list.size();i++){

list.remove(...);

}

循环过程中list.size()的大小变化了，就导致了错误。

正确的方法：

如果你想在循环语句中正确并安全的删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。

32. 看需求选集合

是否是键值对象形式:

是：Map

键是否需要排序:

是：TreeMap

否：HashMap

不知道，就使用HashMap。

否：Collection

元素是否唯一:

是：Set

元素是否需要排序:

是：TreeSet

否：HashSet

不知道，就使用HashSet

否：List

要安全吗:

是：Vector(其实我们也不用它,后面我们讲解了多线程以后，我在给你回顾用谁)

否：ArrayList或者LinkedList

增删多：LinkedList

查询多：ArrayList

不知道，就使用ArrayList

不知道，就使用ArrayList

33. 集合的常见方法及遍历方式

Collection:

add()

remove()

contains()

iterator()

size()

遍历：

增强for

迭代器

|--List

get()

遍历：

普通for

|--Set

Map:

put()

remove()

containskey(),containsValue()

keySet()

get()

values()

entrySet()

size()

遍历：

根据键找值

根据键值对对象分别找键和值

34. Map

Map代表具有映射关系的集合，实现将唯一键映射到特定的值上。

关于Map集合中常用的方法：

clear()清空MapisEmpty()判断该集合是否为空size()获取Map中键值对的个数put(Object key,Object value)向集合中添加键值对get(Object key)通过key获取valuecontainsKey(Object key)判断Map中是否包含这样的keycontainValue(Object value)判断Map中是否包含这样的valueremove(Object key)通过key将键值对删除values（）获取Map集合中所有的valuekeySet()获取Map中所有的keyentrySet()返回此映射中包含的映射关系的Set视图

注意：存储在Map集合key部分的元素需要同时重写hashCode+equals方法.

Hash家族嘛,高逼格,必须一次性两个值存储,就是所谓的键值对.

但是呢,Hash家族内部分为了几个小家族,分别是HashMap,Hashtable,TreeMap. LinkedHashMap

这几个家族呢,对键值对能不能存储null这种不是很安全的"买卖"有不一样的行动.

其中的HashMap家族与Hashtable、TreeMap不同,认为没有风险就没有利润!于是乎,准许自己的键值对都可以为null!

Hashtable与TreeMap一看SUN国王居然默许了HashMap的冒险行为,使得HashMap家族的利润大大增加,这两个家族也不甘寂寞,于是乎也就允许了自己的键值对可以为"",但是不能触碰null的界限.

1. HashMap：HashMap中的key就是HashSet，底层是哈希表/散列表，用于快速查找

HashMap默认初始化容量是16,默认加载因子0.75，键值均可以为null，线程不安全

2. Hashtable默认初始化容量是11,默认加载因子是0.75，键值均不可以为null，线程安全

3. Properties;也是由key和value组成，但是key和value都是字符串类型

dbinfo这样的文件我们称作配置文件，

配置的文件的作用就是：使程序更加灵活。

注意：一般在程序中可变的东西不要写死。推荐写到配置文件中。

运行同样的程序得到不同的结果。

像dbinfo这样一个具有特殊内容的配置文件我们又叫做：属性文件。

java规范中要求属性文件以“.properties”

属性文件中数据要求：

key和value之间可以使用“空格”，“冒号”，“等号”。

如果“空格”，“等号”，“冒号”都有，按最前的作为分隔符。

4. LinkedHashMap：是HashMap的一个子类，保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比 LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。

5. TreeMap：SortedMap中的key特点：无序不可重复，但是存进去的元素可以按照大小自动排列。如果想自动排序：key部分的元素需要，1,实现Comparable接口.2.单独写一个比较器.

35. 解决哈希（HASH）冲突的主要方法（？？？？）

不同的key用同样的Hash算法,可能会得到相同的hash值

<1> 开放定址法

（1）线性探查法(Linear Probing)

插入元素时，如果发生冲突，算法会简单的从该槽位置向后循环遍历hash表，直到找到表中的下一个空槽，并将该元素放入该槽中（会导致相同hash值的元素挨在一起和其他hash值对应的槽被占用）。查找元素时，首先找到散列值所指向的槽，如果没有找到匹配，则继续从该槽遍历hash表，直到：（1）找到相应的元素；（2）找到一个空槽，指示查找的元素不存在，（所以不能随便删除元素）；（3）整个hash表遍历完毕（指示该元素不存在并且hash表是满的）用线性探测法处理冲突，思路清晰，算法简单，但存在下列缺点：

Ø 处理溢出需另编程序。一般可另外设立一个溢出表，专门用来存放上述哈希表中放不下的记录。此溢出表最简单的结构是顺序表，查找方法可用顺序查找。

Ø 按上述算法建立起来的哈希表，删除工作非常困难。假如要从哈希表HT中删除一个记录，按理应将这个记录所在位置置为空，但我们不能这样做，而只能标上已被删除的标记，否则，将会影响以后的查找。

Ø 线性探测法很容易产生堆聚现象。所谓堆聚现象，就是存入哈希表的记录在表中连成一片。按照线性探测法处理冲突，如果生成哈希地址的连续序列愈长(即不同关键字值的哈希地址相邻在一起愈长)，则当新的记录加入该表时，与这个序列发生冲突的可能性愈大。因此，哈希地址的较长连续序列比较短连续序列生长得快，这就意味着，一旦出现堆聚(伴随着冲突)，就将引起进一步的堆聚。

（2）线性补偿探测法

将线性探测的步长从1改为Q，即将上述算法中的hash ＝ (hash ＋ 1) % m 改为：hash ＝ (hash ＋ Q) % m = hash % m + Q % m，而且要求 Q 与 m 是互质的，以便能探测到哈希表中的所有单元。

【例】PDP-11小型计算机中的汇编程序所用的符合表，就采用此方法来解决冲突，所用表长m＝1321，选用Q＝25。

（3）随机探测

将线性探测的步长从常数改为随机数，即令： hash ＝ (hash ＋ RN) % m ，其中 RN 是一个随机数。在实际程序中应预先用随机数发生器产生一个随机序列，将此序列作为依次探测的步长。这样就能使不同的关键字具有不同的探测次序，从而可以避 免或减少堆聚。基于与线性探测法相同的理由，在线性补偿探测法和随机探测法中，删除一个记录后也要打上删除标记。

<2> 拉链法

将所有关键字为同义词的结点链接在同一个单链表中。

若选定的散列表长度为m，则可将散列表定义为一个由m个头指针组成的指针数组T<0..m-1>。凡是散列地址为i的结点，均插入到以T为头指针的单链表中。T中各分量的初值均应为空指针。在拉链法中，装填因子α可以大于1，但一般均取α≤1。