Java基础学习总结

Java基础学习总结

1、 Java简介（官网：www.oracle.com）

Java是一种电脑编程语言，拥有跨平台、面向对象、泛型编程的特性。 任职于太阳微系统的詹姆斯·高斯林（James Gosling）等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，太阳公司放弃了该项计划。随着1990年代互联网的发展，太阳公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

Java编程语言的风格十分接近C++语言。继承了C++语言面向对象技术的核心，Java舍弃了C++语言中容易引起错误的指針，改以引用取代，同时移除原C++与原来运算符重载，也移除多重继承特性，改用接口取代，增加垃圾回收器功能。在Java SE 1.5版本中引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱特性。太阳公司对Java语言的解释是：“Java编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言”

Java不同于一般的编译语言和解释语言。它首先将源代码编译成字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编译、到处执行”的跨平台特性。在早期JVM中，这在一定程度上降低了Java程序的运行效率。但在J2SE1.4.2发布后，Java的运行速度有了大幅提升。

与传统型态不同太阳公司在推出Java时就将其作为开放的技术。全球数以万计的Java开发公司被要求所设计的Java软件必须相互兼容。“Java语言靠群体的力量而非公司的力量”是太阳公司的口号之一，并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同，此外，微软公司后来推出了与之竞争的.NET平台以及模仿Java的C#语言。后来太阳公司被甲骨文公司并购，Java也随之成为甲骨文公司的产品。

2、 JDK、JRE

Java Development Kit (JDK)是Sun公司针对Java开发人员发布的免费软件开发工具包(SDK，Software development kit)。自从Java推出以来，JDK已经成为使用最广泛的Java SDK。由于JDK的一部分特性采用商业许可证，而非开源^[2]。因此，2006年Sun公司宣布将发布基于GPL协议的开源JDK，使JDK成为自由软件。在去掉了少量闭源特性之后，Sun公司最终促成了GPL协议的OpenJDK的发布。

JDK包含了一批用于Java开发的组件，其中包括：

· javac –编译器，将后缀名为.java的源代码编译成后缀名为.class的字节码

· java – 运行工具，运行.class的字节码

· jar – 打包工具，将相关的类文件打包成一个文件

· javadoc – 文档生成器，从源码注释中提取文档，注释需符合规范

· jdb debugger，调试工具

· jps – 显示当前java程序运行的进程状态

· javap – 反编译程序

· appletviewer – 运行和调试applet程序的工具，不需要使用浏览器

· javah – 从Java类生成C头文件和C源文件。这些文件提供了连接胶合，使 Java 和 C 代码可进行交互。^[3]

· javaws – 运行JNLP程序

· extcheck – 一个检测jar包冲突的工具

· apt – 注释处理工具^[4]

· jhat – java堆分析工具

· jstack – 栈跟踪程序

· jstat – JVM检测统计工具

· jstatd – jstat守护进程

· jinfo – 获取正在运行或崩溃的java程序配置信息

· jmap – 获取java进程内存映射信息

· idlj – IDL-to-Java编译器. 将IDL语言转化为java文件^[5]

· policytool – 一个GUI的策略文件创建和管理工具

· jrunscript – 命令行脚本运行

JDK中还包括完整的JRE(Java Runtime Environment)，Java运行环境，也被称为private runtime。包括了用于产品环境的各种库类，如基础类库rt.jar，以及给开发人员使用的补充库，如国际化与本地化的类库、IDL库等等。

JDK中还包括各种样例程序，用以展示Java API中的各部分。

Java执行环境（JavaRuntime Environment，简称JRE）是一个软件，由Sun所研发，JRE可以让电脑系统执行Java应用程式（JavaApplication）。

JRE的内部有一个Java虚拟机器（Java VirtualMachine，JVM）以及一些标准的类别函数库（Class Library）。

3、 Java入门程序

package org.zhanghua.javase.hw;

/**

* Java 入门程序

*

* @author ZhangHua

*

*/

public class HelloWorld {

public static void main(String[] args) {

// 打印出一句Hello World

System.out.println("Hello World!");

}

}

4、 基本数据类型

4类8种

/**

* 8种基本数据类型

*/

private byte b = 'a'; // 1字节 取值范围：Byte.MAX_VALUE 和 Byte.MIN_VALUE

private short s = 1; // 2字节 取值范围：Short.MAX_VALUE 和 Short.MIN_VALUE

private int i = 123; // 4 取值范围：Integer.MAX_VALUE 和 Integer.MIN_VALUE

private long l = 1234567890;// 8 取值范围：Integer.MAX_VALUE 和 Integer.MIN_VALUE

private char c = '中'; // 3字节 ...

private float f = 3.14f; // 4 ...

private double d = 3.14; // 8 ...

private boolean e = true;

/**

* 8种对应的封装类型

*/

private Byte bb = 'a';

private Short ss = 1;

private Integer ii = 1;

private Long ll = 1L;

private Character cc = '中';

private Float ff = 3.14f;

private Double dd = 3.14;

private Boolean bl = false;

/**

* String 是最常用的数据类型，但不属于基本数据类型

*/

private String str = "str";

按功能划分:基本数据类型和引用数据类型。

基本数据类型：整数类型（byte,short,int,long）、浮点型（float,double）、字符型（char）、布尔型（boolean）

引用数据类型：类（class）、接口、数组

注意：B是指byte，byte是字节的意思，是存储空间的基本计量单位，bit 是位的意思，也就是二进制的长度的意思，例如‘10011001’ 是一个8位（bit）的二进制数，bit同时是网速的基本计量单位bps中的bps，意思就是每秒传输多少位数。

二进制是计算机内部使用的基本表达语言，bit是计算机中的最小数据单位（1byte=8bit），说明1byte在计算机存储一个8位的二进制数，这是固定的

数据类型转换：

类型小--->类型大的转换：自动转换 byte,short,char->int->long->float-> double

类型大--->类型小的转换：加强制转换 比如：long ll = 1234; int ii = (int) ll;

运算时：byte,short,char 当int类型处理，整数编译器默认当int类型，小数默认当double

递归总结：

程序调用自身的编程技巧称为递归（ recursion）。

一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

/**

* 递归 顾名思义：就是对自己调用

* 求N! 求阶乘

*

* @param args

*/

public int testRecursion1(int i) {

if (i == 1) {

return 1;

}

else {

// i * testRecursion(i - 1)

// 对自己调用，假如i=5-->test(4)-->test(3)-->test(2)-->test(1),然后再返回

return i * testRecursion1(i - 1); // 5*testRecursion(4)=5*4*testRecursion(3)=5*4*3*testRecursion(2)=5*4*3*2*1=120

}

}

5、 面向对象总结

"一切皆为对象 " 一个系统，可以分为N个小应用，一个小应用中可以分为N个类（对象）。

类与类之间的关系：关联、继承、实现、聚合（聚集（松耦）、组合（密不可分））、多态

面向对象与面向过程的区别？

1、可复用性、可扩展性、可维护性等

2、复用层次不同的，还有面向组件的编程，都是追求代码复用，这也是多年来编程发展苦苦追求的境界

对象与类的区别？

类是描述同一类型的对象的一个抽象，对象可以看成该类的一个具体实例。例如：学生，是一个类（是一类事物描述和抽象）， 学生A ，是一个对象（某一个具体的实例）

opp 考虑问题方法：

1、考虑应该有哪些个类，哪些个对象

2、考虑这些个类，这些个对象应该具有哪些个方法、成员变量 （注意：合适的方法定义在合适的类中）

3、考虑这些个类这些对象关系

总结：重载，是指本类中的；重写，是指子类对父类的方法进行重写

重载（overload）

1、方法名相同，参数个数不同

2、方法名相同，参数个数相同，参数类型不同

3、方法名相同，参数个数相同，参数类型不同，参数顺序不同

4、方法名相同，返回值不同（但是同时参数个数或者参数类型也不同）

5、对访问权限 (private、public、protected、friendly)和方法抛出异常没有限制

重写（override）

1、方法名、参数个数、参数类型、返回值、抛出的异常与父类必须一样

2、对访问权限只能比父类大不能小（例如：父类是protected，子类只能是protected或public）

接口与抽象类的区别？

1、 声明：抽象类使用关键字：abstract，接口则使用interface

2、 成员变量：抽象类可以有普通的成员变量，而接口中的成员变量只能是public static final类型的，就算定义声明的时候不是publicstatic final 类型的，默认也是public staticfinal 类型的

3、 构造方法：抽象类可以有构造方法，而接口没有

4、 方法：抽象类可以有（普通的、抽象的，静态的）方法，而接口只能是public abstract 类型的，就算定义的时候不是publicabstract类型的，默认也是public abstract 类型的

5、 一个类可以实现多个接口，但只能继承一个抽象类

6、 接口本身也可以实现其他接口

Exception/runtimeException/error之间的区别？

三者都是继承java.lang.Throwable类，java.lang.Throwable有2个子类Error和Exception，Exception有RuntimeException

#1 Exception 是所有异常类的父类，是一种程序设计/实现的问题，如果程序运行正常则不会产生异常，设计良好的程序应该在异常发生时，提供处理这些错误的方法，使得程序因为异常的发生而阻断或产生不可预见的结果。比如：除0溢出，数组小标越界，读取文件不存在等等。

#2 RuntimeException 表示运行时异常，RuntimeException(是经常出现的错误可以不catch)，该类异常是不受程序控制的

#3Error分为运行时错误和编译时错误，是系统错误，是不可恢复的，也是程序本身无法处理的，如果是编译时的错误，只能通过修改代码通过编译才行，系统内存溢出，服务器崩溃等

6、 数组的总结

数组可以看成是多个相同数据类型的数据组合，对这些数据统一管理，数组属于引用类型，数组也可以看出是对象，数组中的每个元素相当于对该对象的成员变量。数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

数组的声明：int[] array; int array[]; 推荐使用int[] array;

数组的创建：int[] array=new int[5];使用new关键字创建。

数组的初始化：分为静态初始化和动态初始化

静态初始化：int[] array={1,3,5,7,9}

动态初始化：

for(int i=0;i<5;i++){

Array[i]=i;

}

二维数组

二维数组，可以看成以数组为元素的数组，多维数组，可以看成以数组为数组元素的数组的元素的数组

// 声明为4行5列的二维数组(动态声明)

int[][] arrays = new int[4][5];

// 赋值

for (int i = 0; i < arrays.length; i++) {

int[] inner = arrays[i];

for (int j = 0; j < inner.length; j++) {

arrays[i][j] = i + j;

}

}

// 读取

System.out.println("Two-dimensional：");

for (int i = 0; i < arrays.length; i++) {

int[] inner = arrays[i];

for (int j = 0; j < inner.length; j++) {

int data = arrays[i][j];

System.out.print(" " + data);

}

System.out.println();

}

数组的拷贝

/**

* 数组拷贝

*

* @param destArray

* 目标数组

* @param srcArray

* 源数组

* @return int[] destArray 目标数组

*/

public int[] arrayCopy(int[] destArray,int[] srcArray) {

if (destArray.length < srcArray.length) {

System.out.println("Error, destArray.length < srcArray.length");

return destArray;

}

System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);

return destArray;

}

数组的排序（冒泡排序、选择排序、快速排序）

/**

* 冒泡排序

*

* @param arrays

* 要排序的数组

*/

public void bubbingSort(int[] arrays) {

int swap = 0;

for (int i = 0; i < arrays.length; i++) {

for (int j = 0; j < arrays.length - i - 1; j++) {

if (arrays[j] > arrays[j + 1]) {

swap = arrays[j];

arrays[j] = arrays[j + 1];

arrays[j + 1] = swap;

}

}

}

}

/**

* 选择排序

*

* @param arrays

* 要排序的数组

*/

public void selectSort(int[] arrays) {

int index = 0;

int swap = 0;

for (int i = 1; i < arrays.length; i++) {

index = 0;

for (int j = 1; j <= arrays.length - i; j++) {

if (arrays[j] > arrays[index]) {

index = j;

}

}

// 交换在位置arrays.length-i和index(最大值)两个

swap = arrays[arrays.length - i];

arrays[arrays.length - i] = arrays[index];

arrays[index] = swap;

}

}

/**

* 快速排序

*

* @param arrays

* 要排序的数组

* @param start

* 起始位置

* @param end

* 结束位置

*/

public void quickSort(int[] arrays,int start, int end) {

int startIndex, endIndex, value;

if (start < end) { // 这个条件是否结束循环

startIndex = start;

endIndex = end;

value = arrays[startIndex];

while (startIndex < endIndex) {

while (startIndex < endIndex && arrays[endIndex] > value) {

// 从右向左找第一个小于value的数

endIndex--;

}

if (startIndex < endIndex) {

arrays[startIndex] = arrays[endIndex];

startIndex++;

}

while (startIndex < endIndex && arrays[startIndex] < value) {

// 从左向右找第一个大于value的数

startIndex++;

}

if (startIndex < endIndex) {

arrays[endIndex] = arrays[startIndex];

endIndex--;

}

}

arrays[startIndex] = value;

quickSort(arrays, start, startIndex - 1);

quickSort(arrays, startIndex + 1, end);

}

}

数组的查找（二分查找法）

/**

* 二分法

*

* @param arrays

* 要查找的数组

* @param value

* 要查找的值

* @return 返回查找值的下标

*/

public int binarySearch(int[] arrays,int value) {

int startIndex = 0;

int endIndex = arrays.length - 1;

int midIndex = (startIndex + endIndex) / 2;

if (0 == arrays.length) {

return -1;

}

while (startIndex <= endIndex) {

if (value == arrays[midIndex]) {

return midIndex;

}

if (value > arrays[midIndex]) {

startIndex = midIndex + 1;

}

if (value < arrays[midIndex]) {

endIndex = midIndex - 1;

}

midIndex = (startIndex + endIndex) / 2;

}

return -1;

}

7、 集合的总结

集合顾名思义，集合保存对象的引用，不产生新的对象(存放对象的对象)

Collection

├ List (可以重复)

│ ├LinkedList

│ ├ArrayList

│ └Vector

│　 └Stack

│

└ Set (不重复)

├TreeSet有序

└HashSet无序

└LinkedHashSet

Map

├ Hashtable

├ HashMap

└ TreeMap

Collection 如下是Collection的方法，List,Set要实现Collection接口，就要实现如下的方法(同时这些方法也是集合的共同所具有的方法，其中…表示常用的方法)

boolean	add(E e) 确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extendsE> c) 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear() 移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o) 比较此 collection 与指定对象是否相等。
int	hashCode() 返回此 collection 的哈希码值。
boolean	isEmpty() 如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator() 返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size() 返回此 collection 中的元素数。
Object[]	toArray() 返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

List<E>可以添加重复(值对象之间的equals相等)元素的集合

以下是List接口的方法（其中…表示List接口特有的方法）

boolean	add(E e) 向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extendsE> c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extendsE> c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear() 从列表中移除所有元素（可选操作）。
boolean	contains(Object o) 如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o) 比较指定的对象与列表是否相等。
E	get(int index) 返回列表中指定位置的元素。
int	hashCode() 返回列表的哈希码值。
int	indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean	isEmpty() 如果列表不包含元素，则返回 true。
Iterator<E>	iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
int	lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator<E>	listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E>	listIterator(int index) 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
E	remove(int index) 移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o) 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c) 从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
int	size() 返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray() 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
<T> T[]	toArray(T[] a) 返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

ArrayList 是大小可变，可以添加重复(值对象之间的equals相等)元素的集合，特点：查询速度快。

类 ArrayList<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.ArrayList<E>

以下是ArrayList的实现方法，其中…表示ArrayList特有的方法

boolean	add(E e) 将指定的元素添加到此列表的尾部。
void	add(int index, E element) 将指定的元素插入此列表中的指定位置。
boolean	addAll(Collection<? extendsE> c) 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean	addAll(int index, Collection<? extendsE> c) 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void	clear() 移除此列表中的所有元素。
Object	clone() 返回此 ArrayList 实例的浅表副本。
boolean	contains(Object o) 如果此列表中包含指定的元素，则返回 true。
void	ensureCapacity(int minCapacity) 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E	get(int index) 返回此列表中指定位置上的元素。
int	indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean	isEmpty() 如果此列表中没有元素，则返回 true
int	lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E	remove(int index) 移除此列表中指定位置上的元素。
boolean	remove(Object o) 移除此列表中首次出现的指定元素（如果存在）。
protected void	removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E	set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。
int	size() 返回此列表中的元素数。
Object[]	toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a) 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void	trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。

实例演示：

// ArrayList底层是以数组为实现

// 注意List<T> T 只能是引用类型的，不能是基本数据类型

List<Integer> list = new ArrayList<Integer>();

Random random = new Random();

// 初始化

for (int i = 0; i < 10; i++) {

list.add(random.nextInt(100));

}

// add

list.add(100);

System.out.println("List.get(1)=" + list.get(1));

// remove

list.remove("100");

// list.isEmpty() 判断集合是否为空，为空返回TRUE，反之返回FALSE

System.out.println("List is empty:" + list.isEmpty());

// 打印

System.out.println("ArrayList:");

for (Integer integer : list) {

System.out.print(integer + " ");

}

System.out.println();

// 集合大小

System.out.println("ArrayList size:");

System.out.println(list.size());

LinkedList底层是以链表结构实现的，线程不安全，对元素的增删速度快

类 LinkedList<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.AbstractSequentialList<E>

java.util.LinkedList<E>

以下是LinkedList的实现方法，其中…表示LinkedList特有的方法

boolean	add(E e) 将指定元素添加到此列表的结尾。
void	add(int index, E element) 在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection<? extendsE> c) 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean	addAll(int index, Collection<? extendsE> c) 将指定 collection 中的所有元素从指定位置开始插入此列表。
void	addFirst(E e) 将指定元素插入此列表的开头。
void	addLast(E e) 将指定元素添加到此列表的结尾。
void	clear() 从此列表中移除所有元素。
Object	clone() 返回此 LinkedList 的浅表副本。
boolean	contains(Object o) 如果此列表包含指定元素，则返回 true。
Iterator<E>	descendingIterator() 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element() 获取但不移除此列表的头（第一个元素）。
E	get(int index) 返回此列表中指定位置处的元素。
E	getFirst() 返回此列表的第一个元素。
E	getLast() 返回此列表的最后一个元素。
int	indexOf(Object o) 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int	lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
ListIterator<E>	listIterator(int index) 返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
boolean	offer(E e) 将指定元素添加到此列表的末尾（最后一个元素）。
boolean	offerFirst(E e) 在此列表的开头插入指定的元素。
boolean	offerLast(E e) 在此列表末尾插入指定的元素。
E	peek() 获取但不移除此列表的头（第一个元素）。
E	peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	poll() 获取并移除此列表的头（第一个元素）
E	pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E	pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	pop() 从此列表所表示的堆栈处弹出一个元素。
void	push(E e) 将元素推入此列表所表示的堆栈。
E	remove() 获取并移除此列表的头（第一个元素）。
E	remove(int index) 移除此列表中指定位置处的元素。
boolean	remove(Object o) 从此列表中移除首次出现的指定元素（如果存在）。
E	removeFirst() 移除并返回此列表的第一个元素。
boolean	removeFirstOccurrence(Object o) 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
E	removeLast() 移除并返回此列表的最后一个元素。
boolean	removeLastOccurrence(Object o) 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
E	set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。
int	size() 返回此列表的元素数。
Object[]	toArray() 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a) 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。

LinkedList<String> linkedList = new LinkedList<String>();

linkedList.add("B");

linkedList.add("C");

linkedList.add("D");

linkedList.add("E");

// 添加到最后

linkedList.addLast("Z");

// 添加到最前面

linkedList.addFirst("A");

// 打印

System.out.println(linkedList);

// 移除”C“

linkedList.remove("C");

// 移除下标为1的元素

linkedList.remove(1);

// 添加到下标为1值为"A1"

linkedList.add(1, "A1");

// 获取下标为1的值

linkedList.get(1);

// 重新设置下标为1的值

linkedList.set(1, "A2");

// 打印

System.out.println(linkedList);

Stack就如同子弹夹的原理(先进后出)

类 Stack<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

java.util.Vector<E>

java.util.Stack<E>

boolean	empty() 测试堆栈是否为空。
E	peek() 查看堆栈顶部的对象，但不从堆栈中移除它。
E	pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
E	push(E item) 把项压入堆栈顶部。
int	search(Object o) 返回对象在堆栈中的位置，以 1 为基数。

Stack<String> stack = new Stack<String>();

stack.push("One");

stack.push("Two");

stack.push("Three");

stack.push("Four");

System.out.println(stack);

// 查看堆栈顶部的对象，但不从堆栈中移除它。

System.out.println(stack.peek());

// 移除堆栈顶部的对象，并作为此函数的值返回该对象。

System.out.println(stack.pop());

System.out.println(stack.peek());

while (!stack.isEmpty()) {

// 出栈后，stack中的元素就移除了

System.out.println(stack.pop());

}

// 查看堆栈中的元素

System.out.println(stack);

Set<E>不可以添加重复元素的无序的集合，最多可包含一个Null元素.

boolean	add(E e) 如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean	addAll(Collection<? extendsE> c) 如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void	clear() 移除此 set 中的所有元素（可选操作）。
boolean	contains(Object o) 如果 set 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c) 如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o) 比较指定对象与此 set 的相等性。
int	hashCode() 返回 set 的哈希码值。
boolean	isEmpty() 如果 set 不包含元素，则返回 true。
Iterator<E>	iterator() 返回在此 set 中的元素上进行迭代的迭代器。
boolean	remove(Object o) 如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean	removeAll(Collection<?> c) 移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean	retainAll(Collection<?> c) 仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int	size() 返回 set 中的元素数（其容量）。
Object[]	toArray() 返回一个包含 set 中所有元素的数组。
<T> T[]	toArray(T[] a) 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

HashSet<E>不可以添加重复元素的无序的集合，由哈希表（实际上是一个 HashMap 实例）支持

类 HashSet<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractSet<E>

java.util.HashSet<E>

boolean	add(E e) 如果此 set 中尚未包含指定元素，则添加指定元素。
void	clear() 从此 set 中移除所有元素。
Object	clone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
boolean	contains(Object o) 如果此 set 包含指定元素，则返回 true。
boolean	isEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator<E>	iterator() 返回对此 set 中元素进行迭代的迭代器。
boolean	remove(Object o) 如果指定元素存在于此 set 中，则将其移除。
int	size() 返回此 set 中的元素的数量（set 的容量）。

public void hashSet() {

Set<String> strings1 = new HashSet<String>();

strings1.add("a");

strings1.add("b");

strings1.add("c");

strings1.add("d");

strings1.add("a");

System.out.println("strings1 init:" + strings1);

Set<String> strings2 = new HashSet<String>();

strings2.add("c");

strings2.add("d");

strings2.add("a");

strings2.add("e");

System.out.println("strings2 init:" + strings2);

// 去strings1与strings2的交集

strings1.retainAll(strings2);

System.out.println("strings1 and strings2 retain:" + strings1);

// 迭代

Iterator<String> iterator = strings1.iterator();

while (iterator.hasNext()) {

System.out.print(iterator.next() + " ");

}

}

LinkedHashSet 是set中有序的，哈希表和链接列表实现

类 LinkedHashSet<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractSet<E>

java.util.HashSet<E>

java.util.LinkedHashSet<E>

Set<String> linkedHashSet = new LinkedHashSet<String>();

linkedHashSet.add("a");

linkedHashSet.add("b");

linkedHashSet.add("c");

linkedHashSet.add("d");

// 如果要实现同步

linkedHashSet = Collections

.synchronizedSet(new LinkedHashSet<String>());

linkedHashSet.add("e");

Iterator<String> iterator = linkedHashSet.iterator();

while (iterator.hasNext()) {

System.out.println(iterator.next() + " ");

}

TreeSet

类 TreeSet<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractSet<E>

java.util.TreeSet<E>

boolean	add(E e) 将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
boolean	addAll(Collection<? extendsE> c) 将指定 collection 中的所有元素添加到此 set 中。
E	ceiling(E e) 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
void	clear() 移除此 set 中的所有元素。
Object	clone() 返回 TreeSet 实例的浅表副本。
Comparator<? super E>	comparator() 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
boolean	contains(Object o) 如果此 set 包含指定的元素，则返回 true。
Iterator<E>	descendingIterator() 返回在此 set 元素上按降序进行迭代的迭代器。
NavigableSet<E>	descendingSet() 返回此 set 中所包含元素的逆序视图。
E	first() 返回此 set 中当前第一个（最低）元素。
E	floor(E e) 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
SortedSet<E>	headSet(E toElement) 返回此 set 的部分视图，其元素严格小于 toElement。
NavigableSet<E>	headSet(E toElement, boolean inclusive) 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
E	higher(E e) 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
boolean	isEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator<E>	iterator() 返回在此 set 中的元素上按升序进行迭代的迭代器。
E	last() 返回此 set 中当前最后一个（最高）元素。
E	lower(E e) 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E	pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E	pollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
boolean	remove(Object o) 将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
int	size() 返回 set 中的元素数（set 的容量）。
NavigableSet<E>	subSet(E fromElement, boolean fromInclusive,E toElement, boolean toInclusive) 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
SortedSet<E>	subSet(E fromElement, E toElement) 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
SortedSet<E>	tailSet(E fromElement) 返回此 set 的部分视图，其元素大于等于 fromElement。
NavigableSet<E>	tailSet(E fromElement, boolean inclusive) 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

TreeSet<String> treeSet = new TreeSet<String>();

treeSet.add("a");

treeSet.add("b");

treeSet.add("c");

treeSet.add("d");

// 返回此 set 中当前最后一个（最高）元素。

treeSet.first();

// 返回此 set 中当前最后一个（最高）元素。

treeSet.last();

Iterator<String> iterator = treeSet.iterator();

while (iterator.hasNext()) {

System.out.println(iterator.next() + " ");

}

Map Map (key-value) 键值对存取，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

void	clear() 从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet() 返回此映射中包含的映射关系的 Set视图。
boolean	equals(Object o) 比较指定的对象与此映射是否相等。
V	get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode() 返回此映射的哈希码值。
boolean	isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet() 返回此映射中包含的键的 Set视图。
V	put(K key,V value) 将指定的值与此映射中的指定键关联（可选操作）。
void	putAll(Map<? extendsK,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	size() 返回此映射中的键-值映射关系数。
Collection<V>	values() 返回此映射中包含的值的 Collection视图。

HashMap map 不允许插入相同的key值，允许插入key=null和value=null值

类 HashMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

java.util.HashMap<K,V>

HashMap<Integer, String> hashMap = new HashMap<Integer, String>();

hashMap.put(1, new String("One"));

hashMap.put(2, new String("Two"));

hashMap.put(3, new String("Three"));

hashMap.put(4, new String("Four"));

hashMap.put(5, new String("Five"));

System.out.println(hashMap.size());

System.out.println(hashMap);

// 插入重复键值,会将之前的value的值覆盖掉，与set不同，set是不会插入，跳过

hashMap.put(1, new String("Six"));

System.out.println(hashMap.size());

System.out.println(hashMap);

// 插入key=null的值

hashMap.put(null, "Six");

System.out.println(hashMap);

// 插入key=null的值和value=null值

hashMap.put(null, null);

System.out.println(hashMap);

// 循环

// keySet()获取key值的set集合

Set<Integer> sets = hashMap.keySet();

for (Integer i : sets) {

System.out.print("key=" + i + " value=" + hashMap.get(i) + " ");

}

System.out.println();

// values()获取value值的集合

Collection<String> collection = hashMap.values();

for (String s : collection) {

System.out.print(s + " ");

}

/**

* map.entry 使用Map.Entry来遍历Map

*/

public void mapEntry() {

HashMap<Integer, String> hashMap = new HashMap<Integer, String>();

hashMap.put(1, new String("One"));

hashMap.put(2, new String("Two"));

hashMap.put(3, new String("Three"));

hashMap.put(4, new String("Four"));

hashMap.put(5, new String("Five"));

Set<Map.Entry<Integer, String>> set = hashMap.entrySet();

for (Iterator<Entry<Integer, String>> iterator = set.iterator(); iterator

.hasNext();) {

Entry<Integer, String> entry = iterator.next();

int key = entry.getKey();

String value = entry.getValue();

System.out.print(key + "-" + value + " ");

}

}

LinkedHashMap

类 LinkedHashMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

java.util.HashMap<K,V>

java.util.LinkedHashMap<K,V>

LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();

linkedHashMap.put(1, new String("One"));

linkedHashMap.put(2, new String("Two"));

linkedHashMap.put(3, new String("Three"));

linkedHashMap.put(4, new String("Four"));

linkedHashMap.put(5, new String("Five"));

for (Integer key : linkedHashMap.keySet()) {

System.out.print(key + "-" + linkedHashMap.get(key));

}

TreeMap

类 TreeMap<K,V>

java.lang.Object

java.util.AbstractMap<K,V>

java.util.TreeMap<K,V>

TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();

treeMap.put(1, new String("One"));

treeMap.put(2, new String("Two"));

treeMap.put(3, new String("Three"));

treeMap.put(4, new String("Four"));

treeMap.put(5, new String("Five"));

for (Integer key : treeMap.keySet()) {

System.out.print(key + "-" + treeMap.get(key));

}

Properties 也是一种键值对形式。

类 Properties

java.lang.Object

java.util.Dictionary<K,V>

java.util.Hashtable<Object,Object>

java.util.Properties

Properties p = new Properties();

p.put("One", "一");

p.put("Two", "二");

p.put("Three", "三");

p.put("Four", "四");

System.out.println(p.getProperty("One"));

System.out.println(p.getProperty("Five", "No find"));// getProperty还可以加以判断如果找了就返回对应的值，如果没有找到就返回你自己设定的值。

System.out.println("Write file...");

try {

p.store(new FileOutputStream("Temp/filedemo.properties"),

"hello properties");// 直接写入到指定的文件。

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("+++++++++++++++++++++++++++++");

for (Object key : p.keySet()) {

System.out.println(key + ":" + p.getProperty(key.toString()));

}

System.out.println("Read file...");

try {

File file = new File("Temp/filedemo.properties");

InputStream is = new FileInputStream(file);

p.load(is);

} catch (IOException e) {

e.printStackTrace();

}

System.out.println("+++++++++++++++++++++++++++++");

for (Object key : p.keySet()) {

System.out.println(key + ":" + p.getProperty(key.toString()));

}

EqualsAndHashcode

equals和hashCode在容器类对象调用remove、contains等方法时，需要比较对象是否相等，这会涉及到对象类型的

equals方法和hashCode方法；对于定义的对象，需要重写equals和hashCode方法一实现自定义对象相等规则

hashCode会在对象当前Map的键值的时候会用到

注意：相同的对象具有相同的hashCode，反之有相同的hashCode，但不一定对象相等

个人自我知识点的总结。