详尽笔记，用于复习和速查
　　将包含基础、进阶、高阶
　　目前更新到数据结构-JCF-Set

概述

• Java SE(Standard Edition) 面向PC级应用开发
• Java EE(Enterprise Edition) 面向企业级应用开发
• Java ME(Micro Edition) 面向嵌入式应用开发

环境搭建

JDK下载

搜索java archive，选择版本下载。（本文选择JDK1.8)
安装JDK时，会同时安装JRE。

配置环境变量

新增
JAVA_HOME
C:\Java\jdk1.8.0_73（jdk地址）
修改Path
新增%JAVA_HOME%\bin 上移到最高

打开cmd
java -version
有版本号输出
javac
有用法输出
即可。

配置Eclipse

修改字号
Window-Preferences-General-Appaerance-Colors and Fonts-右侧Java-Java Editor Text Font

显示行号
General-Editors-Text Editors-右侧show line numbers勾上

自动保存时间间隔
General-Workspace-右侧Workspace save interval(in minutes)（默认5分钟）
下方可以修改文本编码格式

复原视窗
Window-Perspective-Reset Perspective…

Eclipse使用教程

Java从编写到运行

编写：利用记事本/vi/IDE等完成代码文件(.java)编写
编译：利用JDK中javac.exe将代码(.java)编译成字节码文件(.class)
运行：java.exe读入并解释字节码文件(.class)，最终在JVM上运行

编程标准

• 类名首字母大写，后面单词驼峰命名
• 方法名和变量名首字母小写，后面单词驼峰命名
• 阿里巴巴编程标准

基础知识

class类

• java文件必须以.java作为扩展名
• 一个java文件只能有一个public class
• public class的名字必须和文件名字一样，大小写都要完全一致
• 一个文件可有多个class，但是只能有一个是public。不提倡一个文件里面放多个类（内部类除外）
• System.out.print 输出

• System.out.println 换行输出

• 类是Java中最基础逻辑单位
  Java所有内容都需放在类的范围中

• 类的构成
  成员变量/属性
  成员方法/函数

main函数

• 一个class最多只能有一个main函数（经指正，一个类可以有多个main函数-通过重载，但只能有一个入口函数）
  类可以没有main函数，没有main函数的类不能主动执行，但可以被动执行（被调用执行）
• 程序入口都是main函数
• main函数的形参和前缀修饰符public、static、void等都不能省略，是固定写法
  注意区别

  1 2 3 4 5 6 7 8

  public static void main(String[] args) { //PSVM，main函数 } public void main() { //普通main函数，不是入口函数 }

• 严格意义上说，main函数不属于这个类的所拥有函数。
  只是因为Java要求所有内容都必须放置在class范围内，所有main函数“寄居”在某一个class中。
• main函数无法被其它方法/类所调用。
• 一个Java程序可调用多个其它Java class。
• String[] args是main函数的形参，即在main函数中可使用args的值（这些值在main函数启动时输入）。

右键test.java，Run As->Run Configuration-右侧Arguments-输入Program arguments程序参数-Run
多个变量需用空格隔开

八种基本类型

• boolean 布尔
  true false(默认)

• byte 字节
  1 byte = 8 bits
  存储有符号的，以二进制补码表示的整数
  最小值-128，最大值127，默认值0
  该类型用在大型数组中可显著节约空间（占用空间只用int类型的四分之一），主要代替小整数
  在二进制文件读写中使用较多

  1 2 3 4

  byte a = (byte) -129; System.out.println(a);//127 byte b = (byte) 128; System.out.println(b);//-128

  怎么理解：
  标准值：-128~127
  两边可以延伸
  左延伸-384(-128)~-129(127)
  右延伸128(-128)~383(127)

• short/int/long 短整数/整数/长整数
  short 16位 2个字节 -32768~32767,-2^15~2^15-1，默认值0
  int 32位，4个字节 -2147483648~2147483647，-2^31~2^31-1，默认值0
  long 64位 8个字节 -9223372036854775808~9223372036854775807,-2^63~2^63-1,默认值0L

• float/double 浮点数
  float 单精度 32位 4个字节 1.410^-45~3.410^38 默认值0.0f
  double 双精度 64位 8个字节 4.910^-324~1.710^308 默认值0.0d
  float和double都不能用来表示很精确的数字

• char 字符
  16位 Unicode字符
  最小值是 \u0000(即为0)
  最大值是\uffff(即为65535)
  （\u4e00~\u9fa5两万多汉字）

运算符

>> 右移 除以2
<< 左移 乘以2

自定义函数

重载(overload)：同一个类中，函数名称可以相同，但函数参数的个数或者类型必须有所不同
不能以返回值来区分同名的函数

面向对象

对象=属性+方法
对象的规范=属性定义+方法定义

1

A obj = new A();

• obj可看作是内存中一个对象（包含若干个数据）的句柄
• 在C/C++中，obj称为指针，在Java中称为Reference
• 对象赋值是Reference赋值，基本类型是直接值拷贝
  理解：基本类型的变量值小，可直接拷贝；对象包含多个值，不容易复制，赋值采用共享同一块内存区域。

函数内的局部变量，编译器不会给默认值，需初始化；
类的成员变量，编译器会给默认值，可直接使用。

构造函数

• 构造函数名称必须和类名一样，且没有返回值
  public void A(int x)不是构造函数，而是普通函数。
• Java有构造函数，但没有析构函数
• 每个变量都有生命周期，它只能存储在离它最近的一对{}中（经指正，此条不够严谨）
• Java具有内存自动回收机制，当变量退出其生命周期后，JVM会自动回收所分配的对象的内存。
• 对象回收效率依赖于垃圾回收器GC(Garbage Collector)，其回收算法关系到性能好坏，是JVM研究热点。
• 每个Java类都必须有构造函数
• 若没有显式定义构造函数，Java编译器自动为该类产生一个空的无形参构造函数。若有显式构造函数，编译器就不会再产生构造函数
• 每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条
• 一个类可有多个构造函数，只要形参列表不同

多个class可写在一个.java文件中，但最多只有一个类是public class，并且public class类的名字必须和.java文件名相同。

信息隐藏原则

• 类的成员属性，是私有的private
• 类的方法，是共有的public，通过方法修改成员属性的值
• get和set方法是公有public的，统称为getter和setter
• 外界对类成员的操作只能通过get和set方法
• 可用Java IDE快速生成
  Source-Generate Getters and Setters…

this

• this负责指向本类中的成员变量

  1 2 3 4 5 6 7 8 9 10 11 12

  public class Test{ private int id; public Test(int id){ //在这个构造函数里，形参优先级更高 this.id = id; } public int getId(){ return id; } }

• this负责指向本类中的成员方法

  1	this.add(1,2);//调用本类的add方法，this可忽略

• this可代替本类的构造函数

  1	this(5);//调用本类的一个形参的构造函数

继承、接口和抽象类

继承

父类/基类/超类
Parent class/Base class/Super class
子类/派生类
Child class/Derived class

• 子类继承父类所有的属性和方法（但不能直接访问private成员）
• 根据信息隐藏原则：子类会继承父类所有的方法，可直接使用
• 子类也会继承父类的父类所有的属性和方法（但不能直接访问private成员）
  子类可以通过调用父类的方法来访问父类的私有的成员属性
  在同样方法名和参数情况下，本类的方法会比父类的方法优先级高

区别于C++，单根继承

• 单根继承原则：每个类都只能继承一个类
• 若不写extends，Java类默认继承java.lang.Object类
• Java所有类从java.lang.Object开始，构造出一个类型继承树

• Object类里面默认就有clone, equals, finalize, getClass, hashCode, toString等方法

• 每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条
  如果构造函数的第一句话不是super，编译器会自动增加一句super();。如果构造函数第一句是自己写的super语句，编译器就不会自动添加。

抽象类

若方法只有方法名字，形参列表，没有方法体，那所在的类就被定义为抽象类。
若一个类暂时有方法未实现，需被定义为抽象类。

• 一个类继承于抽象类，就不能继承于其他的（抽象）类
• 子类可继承于抽象类，但一定要实现父类们所有abstract的方法，若不能完全实现，子类也必须被定义为抽象类

接口

• 如果类的所有方法都没有实现，这个类就算是接口interface

  1 2 3 4

  public interface Animal{ public void eat(); public void move(); }

• 类只可以继承(extends)一个类，但可实现(implements)多个接口，继承和实现可以同时
• 接口不算类，或者说是特殊的类
• 接口可以继承（多个）接口，没有实现的方法将会叠加
• 类实现接口，就必须实现所有未实现的方法。若没有全部实现，只能成为一个抽象类
• 接口里可定义变量，但一般是常量 （经指正，成员变量只能是常量）

总结

抽象类和接口相同点：两者都不能被实例化，不能new操作
不同点：

• 抽象类abstract，接口interface
• 抽象类可有部分方法实现，接口所有方法不能有实现 （经指正，Java8后，接口可有默认实现）
• 一个类只能继承(extends)一个（抽象）类，实现(implenments)多个接口
• 接口可继承(extends)多个接口
• 抽象类有构造函数，接口没有构造函数
• 抽象类可有main，也能运行，接口没有main函数
• 抽象类方法可有private/protected，接口方法都是public

类转型

类型可相互转型，但只限制于有继承关系的类

• 子类可转换成父类（从大到小，向上转型），而父类不可转为子类（从小变大，向下转型）
• 父类转为子类有一种情况例外：这个父类本身就是从子类转化而来

  1 2	Human obj1 = new Man();//OK, Man extends Human Man obj2 = (Man) obj1;//OK, because obj1 is born from Man class

多态

• 类型转换带来的作用就是多态
• 子类继承父类的所有方法，但子类可重新定义一个名字，参数和父类样的方法，这种行为是重写（覆写，覆盖，overwrite/override,not overload(重载))
• 子类方法优先级高于父类

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  public class Man extends Human{ public void eat(){ System.out.println("I can eat more"); } public void plough() { } public static void main(String[] a){ Man obj1 = new Man(); obj1.eat();//call Man.eat() Human obj2 = (Human) obj1; obj2.eat();//call Man.eat() Man obj3 = (Man) obj2; obj3.eat();//call Man.eat() } }

契约设计：类不会直接使用另外一个类，而是采用接口的形式，外部可以“空投”这个接口下的任意子类对象

static、final和常量设计

static

static关键字可作用在：

• 变量
  static变量只依赖于类存在（通过类即可访问），不依赖于对象实例存在。
  所有对象实例，关于同一个变量的值都共享存储在一个共同的空间（栈）。

• 方法
  静态方法无需通过对象来引用，而通过类名可直接引用。
  静态方法中只能使用静态变量，不能使用非静态变量。
  静态方法禁止引用非静态方法。

• 类

• 匿名方法块
  static块只在类第一次被加载时调用，在程序运行期间，代码只运行一次
  执行顺序：static块 > 匿名块 > 构造函数

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  class StaticBlock { static { System.out.println("static 块"); } { System.out.println("匿名块"); } public StaticBlock() { System.out.println("构造函数"); } { System.out.println("匿名块"); } }

单例模式

• 又名单态模式，Singleton
• 限定某一个类在整个程序运行过程中，只能保留一个实例对象在内存空间
• GoF的23中设计模式(Design Pattern)（创建型、结构型、行为型）中经典的一种，属于创建型模式类型
• 采用static来共享对象实例
• 采用private构建函数，防止外界new操作

final

final关键字用来修饰

• 类
• 方法

• 字段

• final的类，不能被继承（不能有子类）

• 父类中若有final方法，子类不能改写此方法
  子类方法和父类方法在方法名和参数列表一样，就属于方法改写/重写/覆写，若参数列表不一样，就属于方法重载
• final的变量不能再次赋值
  若是基本类型的变量，不能修改其值
  若是对象实例，不能修改其指针（但可修改对象内部的值）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  class FinalObject { int a = 10; } public class FinalObjectTest{ public static void main(String[] args){ final FinalObject obj1 = new FinalObject(); System.out.println(obj1.a); obj1.a = 20; System.out.println(obj1.a);//正确，可以修改内部值 obj1 = new FinalObject();//报错，不能修改指针 } }

常量设计

• Java没有constant关键字
• 不能修改， final
• 不会修改/只读/只要一份， static
• 方便访问public

Java中的常量

• public static final
• 建议变量名字全大写，以连字符相连，如UPPER_BOUND
• 一种特殊的常量：接口内定义的变量默认是常量

常量池

• Java为很多基本类型的包装类/字符串都建立常量池
• 常量池：相同的值只存储一份，节省内存，共享访问

• 基本类型的包装类
  Boolean: true, false
  Byte:-128~127
  Short, Integer, Long:-128~127
  Character:0~127
  不包括Float, Double:没有缓存(常量池)

  1 2 3 4 5 6 7 8 9 10 11

  Long l1 = -128L; Long l2 = -128L; System.out.println(String.valueOf(l1==l2));//true Float f1 = 0.5f; Float f2 = 0.5f; System.out.println(String.valueOf(f1 == f2));//false Double d1 = 0.5; Double d2 = 0.5; System.out.println(String.valueOf(d1 == d2));//false

• Java为常量字符串都建立常量池缓存机制

• 基本类型的包装类和字符串有两种创建方式

1. 常量式（字面量）复制创建，放在栈内存（将被常量化）

   1 2	Integer a = 10; String b = "abc";

2. new对象进行创建，放在堆内存（不会常量化）

   1 2	Integer c = new Integer(10); String d = new String("abc");

   这两种创建方式导致创建的对象存放的位置不同
   栈内存读取速度快但容量小
   堆内存读取速度慢但容量大

• 基本类型和包装类比较，将对包装类自动拆箱
• 对象比较，比较地址

• 加法+会自动拆箱

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  int i1 = 10; Integer i2 = 10;//自动装箱 System.out.println(i1 == i2);//true //自动拆箱 基本类型和包装类进行比较，包装类自动拆箱 Integer i3 = new Integer(10); System.out.println(i1 == i3);//true //自动拆箱 基本类型和包装类进行比较，包装类自动拆箱 System.out.println(i2 == i3);//false //两个对象比较，比较其地址 //i2是常量，放在栈内存常量池中，i3是new出对象，放在堆内存中 Integer i4 = new Integer(5); Integer i5 = new Integer(5); System.out.println(i1 == (i4+i5));//true System.out.println(i2 == (i4+i5));//true System.out.println(i3 == (i4+i5));//true //i4+i5操作将会使得i4,i5自动拆箱为基本类型并运算得到10 //基础类型10和对象相比，将会使对象自动拆箱，做基本类型比较 Integer i6 = i4 + i5;//+操作使得i4,i5自动拆箱，得到10，因此i6 == i2 System.out.println(i1 == i6);//true System.out.println(i2 == i6);//true System.out.println(i3 == i6);//false

• 常量赋值（堆内存）和new创建（栈内存）不是同一个对象

• 编译器只会优化确定的字符串，并缓存

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  String s0 = "abcdef"; String s1 = "abc"; String s2 = "abc"; String s3 = new String("abc"); String s4 = new String("abc"); System.out.println(s1 == s2);//true常量池 System.out.println(s1 == s3);//false一个栈内存，一个堆内存 System.out.println(s3 == s4);//false两个都是堆内存 String s5 = s1 + "def";//设计到变量，编译器不优化 String s6 = "abc" + "def";//都是常量，编译器会自动优化成abcdef String s7 = "abc" + new String("def");//设计到new对象，编译器不优化 System.out.println(s5 == s6);//false System.out.println(s6 == s7);//false System.out.println(s0 == s6);//true String s8 = s3 + "def";//涉及到new对象，编译器不优化 String s9 = s4 + "def";//设计到new对象，编译器不优化 String s10 = s3 + new String("def");//涉及到new对象，编译器不优化 System.out.println(s8 == s9);//false System.out.println(s8 == s10);//false System.out.println(s9 == s10);//false

不可变对象和字符串

不可变对象

• 不可变对象(Immutable Object)
  一旦创建，该对象（状态/值）不能被更改
  其内在的成员变量的值不能修改
  如八个基本型别的包装类
  String, BigInteger和BigDecimal等

• 可变对象(Mutable Object)
  普通对象

  1 2 3 4 5

  String a = new String("abc"); String b = a; System.out.println(b);//abc a = "def"; System.out.println(b);//abc

  不可变对象是指值对象不再修改，即abc不会被修改，而指针（句柄/变量名）a的指向可以修改。
  不可变对象，也是传指针（引用）
  由于不可变，临时变量指向新内存，外部实参的指针不改动

  1 2 3 4 5 6 7

  public static void change(String b) { b = "def"; } a = new String("abc"); change(a); System.out.println(a);//abc

  a->abc
  b–^
  change(a)后
  a->abc
  b->def

• 如何创建不可变对象
  immutable对象是不可改变，改变要clone/new一个对象进行修改
  所有属性是final和private
  不提供setter方法
  类是final的，或所有方法都是final
  勒种包含mutable对象，那么返回拷贝需要深度clone

• 不可变对象(Immutable Object)优点
  只读，线程安全
  并发读，提高性能
  可重复使用

• 缺点
  制造垃圾，浪费空间

字符串

不可变对象
字符串内容比较：equals方法
是否指向同一个对象：指针比较==

• 字符串加法

  1 2	String a = "abc"; a = a + "def";//String不可修改，需新申请空间，效率差

  使用SrringBuffer/StringBuilder类的append方法进行修改
  StringBuffer/StringBuilder的对象都是可变对象
  StringBuffer(同步，线程安全，修改快速)，StringBuilder（不同步，线程不安全，修改更快）

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  public static void changeValue(int a) { a = 10; } public static void changeValue(String s1) { s1 = "def"; } public static void changeValue(StringBuffer s1) { s1.append("def"); } public static void main(String[] args) { int a = 5; String b = "abc"; StringBuffer c = new StringBuffer("abc"); changeValue(a); changeValue(b); changeValue(c); System.out.println(a);//5 System.out.println(b);//abc System.out.println(c);//abcdef }

package, import和classpath

package和import

• 若所有Java类都是放置在同一个目录下的，类之间相互调用无需显式声明调用
  同一个目录下，两个类的名字不能相同
  文件过多不方便查找
• Java支持多个目录放置Java，并通过package/import/classpath/jar等机制配合使用，可支持跨目录放置和调用Java类

  1 2 3 4

  package cn.edu.pku; public class PackageExample { }

  类全称cn.edu.pku.PackageExample，短名称PackageExample
  引用类时，必须采用全称引用；程序正文可用短名称
  PackageExample.java必须严格放置在cn/edu/pku目录下
• 包名尽量唯一
• 域名是唯一的，因此常用域名做包名
• 域名逆序：cn.edu.pku，范围通常从大到小
  类的完整名字：包名+类名，cn.edu.pku.PackageExample
  包名：和目录层次一样，cn\edu\pku\PackageExample.java
  包具体放在上面位置不重要，编译和运行时再制定

举个栗子

1
2
3
4
5
6
7
8
9
10
11
12

package cn.edu.pku;
import cn.edu.pku.PackageExample;
//或import cn.edu.pku.*
//但不能是import cn.*
//若PackageExample和当前类在同一个目录，可省略import

public class PackageExampleTest{
    public static void main(String[] args){
        PackageExample obj = new PackageExample();
        //此处可用类的短名称来引用
    }
}

import规则

• import必须全部放在package之后，类定义之前
  package必须是第一句话
• 多个import的顺序无关
• 可用来引入一个目录下的所有类，比如import java.lang.;
  注意：不能递归包含其下各个目录下的文件
• import尽量精确，不推荐*，以免新增同名程序会使老程序报错

jar

用于可执行程序文件的传播，实际上是一组class文件的压缩包
项目引入一个jar文件，就可以使用jar文件中所有类（.class文件），无需类的源码（.java文件）。
jar只包含.class文件，没有.java文件，不会泄露源码。不过Java里的一些反编译工具，可从class反编译到Java。

利用Eclipse的Export功能导出jar文件

• 选中项目，点击顶部菜单File-Export-Java-Jar File

classpath

手动创建c:\temp\cn\com\test\Man.java
编译：

1

javac c:\temp\cn\com\test\Man.java

1

java -classpath   .;c:\temp   cn.com.test.Man

编译和运行规则

• 编译一个类，需java文件全路径，包括拓展名
• 运行一个类，需写类名全称（非文件路径），无需写扩展名
• 编译类时，需给出这个类所依赖的类（包括依赖的类再次依赖的所有其他类）的所在路径
• 运行类时，需给出这个类，以及被依赖类的路径总和
• classpath参数也可以包含jar包。若路径内有空格，请将classpath参数整体加双引号。

  1	java -classpath ".;c:\test.jar;c:\temp;c:\a bc" cn.com.test.Man

Java访问权限

• private：私有，只能本类访问
• default（通常忽略不写）：同一个包内访问
• protected: 同一个包，子类均可以访问
• public：公开，所有类都可访问
  四种都可用来修饰成员变量、成员方法、构造函数
  default和public可修饰类

  1 2	class A { }//default class public class B{ }//public class

  权限表

  同一个类    同一个包    不同包的子类    不同包的非子类
  

  private √
  default √ √
  protected √ √ √
  public √ √ √ √

Java常用类

Java类库文档
https://docs.oracle.com/en/
https://docs.oracle.com/en/java/javase/13/docs/api/index.html
这些文档原先是程序中的注释。利用JavaDoc技术，将这些注释抽取出来，组织形成的以HTML为表现形式的API文档。

数字类

• Java数字类
  整数Short, Int, Long
  浮点数Float, Double
  大数类BigInteger(大整数), BigDecimal(大浮点数)
  大数类没有限制，可表示无穷大的数字

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  BigInteger b1 = new BigInteger("123456789"); BigInteger b2 = new BigInteger("987654321"); System.out.println(b2.add(b1));//加法操作 System.out.println(b2.subtract(b1));//减法操作 System.out.println(b2.multiply(b1));//乘法操作 System.out.println(b2.divide(b1));//除法操作 System.out.println(b2.max(b1));//求出最大数 System.out.println(b2.min(b1));//求出最小数 BigInteger result[] = b2.divideAndRemainder(b1);//求出余数的除法操作 System.out.println("商是：" + result[0] + "；余数是：" + result[1]);//求出余数的除法操作 System.out.println(b1.equals(b2));//是否等价 int flag = b1.compareTo(b2); if(flag == -1) System.out.println("比较操作：b1<b2"); else if(flag == 0) System.out.println("比较操作：b1==b2"); else System.out.println("比较操作：b1>b2");

  尽量采用字符串对BigDecimal赋值，这样精度更准确。

  1 2 3 4 5 6 7 8

  System.out.println(new BigDecimal("2.3")); System.out.println(new BigDecimal(2.3));//2.29999999999999 BigDecimal num1 = new BigDecimal("10"); BigDecimal num2 = new BigDecimal("3"); //需要指定位数，防止无限循环，或者包含在try-catch中 BigDecimal num3 = num1.divide(num2, 3, BigDecimal.ROUND_HALF_UP); System.out.println(num3);

  BigDecimal做除法操作，需要注意截断，防止出现无限循环小数。

随机数类Random
nextInt() 返回一个随机Int
nextInt(int a) 返回一个[0,a)之间的随机int
nextDouble() 返回一个[0.0,1.0]之间double
ints方法批量返回随机数数组
Math.random() 返回一个[0.0,1.0]之间double

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//第一种，采用Random类随机生成
Random rd = new Random();
System.out.println(rd.nextInt());
System.out.println(rd.nextInt(100));//0-100的随机数
System.out.println(rd.nextLong());
System.out.println(rd.nextDouble());

//第二种，生成一个范围内的随机数 例如0-10之间的随机数
System.out.println(Math.round(Math.random()*10));

//JDK 8 新增方法
rd.ints();//返回无限个int类型范围内的数据
int[] arr = rd.ints(10).toArray();//生成10个int范围类的个数
for(int i = 0;i < arr.length; i++){
    System.out.println(arr[i]);
}

arr = rd.ints(5, 10, 100).toArray();//5个10-100的随机数
for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

arr = rd.ints(10).limit(5).toArray();
for(int i = 0;i < arr.length; i++){
    System.out.println(arr[i]);
}

字符串相关类

String
Java使用频率最高的类
一个不可变对象，加减操作性能较差
常用：
charAt, concat, contains, endsWith, equals, equalsIgnoreCase, hashCode, indexOf, length, matches, replace, replaceAll, split, startsWith, subString, trim, valueOf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

String a = "123;456,789,123 ";
System.out.println(a.charAt(0));//返回第0个元素
System.out.println(a.indexOf(";"));//返回第一个;的位置
System.out.println(a.concat(";000"));//连接一个新字符串并返回，a不变
System.out.println(a.contains("000"));//判断a是否包含000
System.out.println(a.endWith("000"));//判断a是否以000结尾
System.out.println(a.equals("000"));//判断是否等于000
System.out.println(a.equalsIgnoreCase("000"));//判断在忽略大小写情况下是否等于000
System.out.println(a.length());//返回a长度
System.out.println(a.trim());//返回a去除前后空格后的字符串，a不变
String[] b = a.split(";");//将a字符串按照;分割成数组
for(int i = 0; i < b.length; i++){
    System.out.println(b[i]);
}

System.out.println(a.substring(2, 5));//截取a的第2个到第5个字符 a不变
System.out.println(a.replace("1", "a"));
System.out.println(a.replaceAll("1", "a");//replaceAll第一个参数是正则表达式

String s1 = "123456789";
String s2 = s1.replace("?", "a");
String s3 = s1.replaceAll("[?]", "a");
//这里的[?]才表示字符问号，这样才能正常替换。不然在正则中会有特殊的意义就会报异常

• 可变字符串
  StringBuffer(字符串加减，同步，性能好)
  StringBuilder(字符串加减，不同步，性能更好)

• StringBuffer/StringBuilder：方法一样，区别在同步
  append/insert/delete/replace/substring
  length字符串实际大小，capacity字符串占用空间大小
  trimToSize()：去除空隙，将字符串存储压缩到实际大小
  如有大量append，事先预估大小，再调用相应构造函数

时间类

• java.util.Date（基本废弃，Deprecated）
  getTime()，返回自1970.1.1以来的毫秒数
• java.spl.Date（和数据库对应的时间类）
• Calendar是目前程序中最常用的，但是是抽象类
  Calendar gc = Calendar.getInstance();
  Calendar gc = new GregorianCalendar();
  简单工厂模式
  查看CalendarClassTest.java

• Calendar
  get(Field) 来获取时间中每个属性的值，注意，月份0-11
  getTime() 返回相应的Date对象
  getTimeInMillis() 返回自1970.1.1以来的毫秒数
  set(Field) 设置时间字段
  add(field, amount) 根据指定字段增加/减少时间
  roll(field, amount) 根据指定字段增加/减少时间，但不影响上一级的时间段

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

  Calendar calendar = Calendar.getInstance(); public void test1(){ //获取年 int year = calendar.get(Calendar.YEAR); //获取月 int month = calendar.get(Calendar.MONTH) + 1; //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); //获取时 int hour = calendar.get(Calendar.HOUR); //获取分 int minute = calendar.get(Calendar.MINUTE); //获取秒 int second = calendar.get(Calendar.SECOND); //星期，从星期日算起 int weekday = calendar.get(Calendar.DAY_OF_WEEK); } //一年后的今天 public void test2(){ calendar.add(Calendar.YEAR, 1); //获取年 int year = calendar.get(Calendar.YEAR); //获取月 int month = calendar.get(Calendar.MONTH) + 1; //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); } //获取任意一个月的最后一天 public void test3(){ //假设求6月的最后一天 int currentMonth = 6; //先求出7月份的第一天 calendar.set(calendar.get(Calendar.YEAR), currentMonth, 1); calendar.add(Calenadr.DATA, -1); //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); } //设置日期 public void test4(){ calendar.set(Calendar.YEAR, 2000); System.out.println("现在是" + calendar.get(Calendar.YEAR) + "年"); calendar.set(2018, 1, 2); //获取年 int year = calendar.get(Calendar.YEAR); //获取月 int month = calendar.get(Calendar.MONTH) + 1; //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); } public void test5(){ calendar.set(2018, 7, 8); calendar.add(Calendar.DAY_OF_MONTH, -8); //获取年 int year = calendar.get(Calendar.YEAR); //获取月 int month = calendar.get(Calendar.MONTH) + 1; //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); System.out.println("2018.7.8，用add减少8天，现在是" + year + "." + month + "." + day); //2018.7.31 calendar.set(2018, 7, 8); calendar.roll(Calendar.DAY_OF_MONTH, -8); //获取年 int year = calendar.get(Calendar.YEAR); //获取月 int month = calendar.get(Calendar.MONTH) + 1; //获取日 int day = calendar.get(Calendar.DAY_OF_MONTH); System.out.println("2018.7.8，用roll减少8天，现在是" + year + "." + month + "." + day); //2018.8.31只改变天数，不改变月份 }

  roll函数做加减法，只影响当前字段，不影响进位。add函数则会影响进位。

• Java 8 退出新的时间API
  java.time包
  旧的设计不好（重名的类、线程不安全等）
  新版本优点：不变性，在多线程环境下；遵循设计模式，设计得更好，可扩展性强

• Java 8 时间包概述
  java.time包：新的Java日期/时间API的基础包
  主要类：LocalDate日期类
  LocalTime时间类（时分秒-纳秒）
  LocalDateTime：LocalDate + LocalTime
  Instant时间戳
  java.time.chrono包：为非ISO的日历系统定义了一些泛化的API
  java.time.format包：格式化和解析日期时间对象的类
  java.time.temporal包：包含一些时态对象，可以用其找出关于日期/时间对象的某个特定日期或时间
  java.time.zone包：包含支持不同时区以及相关规则的类

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

  //当前时间 LocalDate today = LocalDate.now(); //根据指定时间创建LocalDate LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1); //给定错误时间参数，将报异常java.time.DateTimeException //LocalDate firstDay_2014 = LocalDate.of(2014, Month.FEBRUARY, 29); //可更改时区 LocalDate todayBeijing = LocalDate.now(ZoneId.of("Asia/Shanghai")); //从纪元日01/01/1970开始365天 LocalDate dateFromBase = LocalDate.ofEpochDay(365); //2014年的第100天 LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100); //当前时间 时分秒 纳秒 LocalTime time = LocalTime.now(); //根据时分秒 LocalTime specificTime = LocalTime.of(12, 20, 25, 40); //错误的时间参数 将报DateTimeException //LocalTime invalidTime = LocalTime.of(25,20); //上海时间 LocalTime timeSH = LocalTime.mow(ZoneId.of("Asia/Shanghai")); //一天当中第几秒 LocalTime specificSecondTime = LocalTime.ofSecondOfDay(10000); //当前时间戳 Instant timestamp = Instant.now(); //从毫秒数来创建时间戳 Instant specificTime = Instant.ofEpochMilli(timestamp.toEpochMilli()); Date date = Date.from(timestamp); LocalDate today = LocalDate.now(); //判断是否是闰年 System.out.println("Year " + today.getYear() + "is Leap Year" + today.isLeapYear()); //今天和01/01/2015比较 System.out.println("Today is before 01/01/2015" + today.isBefore(LocalDate.of(2015,1,1))); //当前时分秒 System.out.println("Current Time =" + today.atTime(LocalTime.now())); //加减时间 System.out.println("10 days after today will be " + today.plusDays(10)); System.out.println("3 weeks after today will be " + today.plusWeeks(3)); System.out.println("20 months after today will be " + today.plusMonths(20)); System.out.println("10 days after today will be " + today.minusDays(10)); System.out.println("3 weeks after today will be " + today.minusWeeks(3)); System.out.println("3 weeks after today will be " + today.minusMonths(20)); //调整时间 System.out.println("First date of this month = " + today.with(TemporalAdjusters.firstDayOfMonth())); LocalDate lastDayOfYear = today.with(TemporalAdjusters.lastDayOfYear()); System.out.println("Last date of this year = " + lastDayOfYear); //时间段计算 Period period = today.until(lastDayOfYear); System.out.println("Period Format = " + period); System.out.println("Months remaining in the year = " + period.getMonths());

  格式化（Format）相关类

• java.text包java.text.Format的子类
  NumberFormat：数字格式化，抽象类
  – DecimalFormat 工厂模式
  例如：将1234567格式化输出为1,234,567

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  DecimalFormat df1,df2; //整数部分为0，#认为整数不存在，可不写；0认为没有，但至少写一位，写0 df1 = new DecimalFormat("#.00"); df2 = new DecimalFormat("0.00"); System.out.println(df1.format(0.1));//.10 System.out.println(df2.format(0.1));//0.10 df1 = new DecimalFormat("0.00"); df2 = new DecimalFormat("0.##"); System.out.println(df1.format(0.1));//0.10 System.out.println(df2.format(0.1));//0.1 df1 = new DecimalFormat("0.00"); df2 = new DecimalFormat("#.00"); System.out.println(df1.format(2));//2.00 System.out.println(df2.format(2));//2.00 System.out.println(df1.format(20));//20.00 System.out.println(df2.format(20));//20.00 System.out.println(df1.format(200));//200.00 System.out.println(df2.format(200));//200.00

  MessageFormat：字符串格式化
  支持多个参数-值对位复制文本S
  支持变量的自定义格式
  例如将“Hello {1}”根据变量值格式化为Hello World

  1 2 3 4 5 6 7

  String message = "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}"; object[] array = new Object[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q"}; String value = MessageFormat.format(message, array); System.out.println(value); message = "oh, {0,number,#.##} is a good number"; array = new Object[]{new Double(3.1415)}; value = MessageFormat.format(message, array);

  输出

  1 2	ABCDEFGHIJKLMNOPQ oh, 3.14 is a good number

  DateFormat：日期/时间格式化，抽象类
  – SimpleDateFormat 工厂模式
  parse：将字符串格式化为时间对象
  format：将时间对象格式化为字符串
  如将当前时间转为YYYY-MM-DD HH24:MI:SS输出

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  String strDate = "2008-10-19 10:11:30.345"; //准备第一个模板，从字符串中提取出日期数字 String pat1 = "yyyy-MM-dd HH:mm:ss.SSS"; //准备第二个模板，将提取后的日期数字变为指定的格式 String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒"; SimpleDateFormat sdf1 = new SimpleDateFormat(pat1); SimpleDateFormat sdf2 = new SimpleDateFormat(pat2); Date d = null; try{ d = sdf1.parse(strDate);//将给定的字符串中的日期提取出来 }catch(Exception e){//如果提供的字符串格式有错误，则进行异常处理 e.printStackTrace();//打印异常信息 } System.out.println(sdf2.format(d));//将日期变为新的格式

• java.time.format包下
  java.time.format.DateFormatter：时间格式化
  JDK 8 发布，线程安全（vs SimpleDateFormat 线程不安全）
  ofPattern：设定时间格式
  parse：将字符串格式化为时间对象
  format：将时间对象格式化为字符串
  如将当前时间转为YYYY-MM-DD HH24:MI:SS输出

  1 2 3 4 5 6 7 8 9 10 11

  //将字符串转化为时间 String dateStr = "2020年1月1日"; DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日"); LocalDate date = LocalDate.parse(dateStr, formatter); System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth()); //将日期转换为字符串输出 LocalDateTime now = LocalDateTime.now(); DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm:ss"); String nowStr = now.format(format); System.out.println(nowStr);

  LocalDate类的月份是1-12，不用加1；Calendar类的月份是0-11，需要加1。

异常和异常处理

异常

Java异常分成Exception（程序相关）和Error（系统相关）。

Exception分为RuntimeException程序自身的错误（如5/0，空指针，数组越界）和非RuntimeException外界相关的错误（如打开一个不存在的文件，加载一个不存在的类）。
IOException是非RuntimeException的典型示例。
另一种分类方法：
Unchecked Exception：（编译器不会辅助检查的，需要管理员自己管的）异常，包括Error子类和RuntimeException子类。
非RuntimeException的Exception的子类：（编译器会辅助检查的）异常，checked exception。
注意：编译器会检查程序是否为checked exception配置了处理。若没有处理，会报错。

异常处理

• try-catch-finally：一种保护代码正常运行的机制。
• 异常结构
  try…catch（catch可以有多个，下同）
  try…catch…finally
  try…finally
• try必须有，catch和finally至少要有一个
  try：正常业务逻辑代码
  catch：当try发生异常，将执行catch代码。若无异常，绕之。
  finally：当try或catch执行结束后，必须要执行finally。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

  try { int a = 5/2; System.out.println(a); } catch(Exception ex) { ex.printStackTrace(); } finally { System.out.println("1 over"); } try { int a = 5/0; System.out.println(a); } catch(Exception ex) { ex.printStackTrace(); } finally { System.out.println("2 over"); } try { int a = 5/0; System.out.println(a); } catch(Exception ex) { ex.printStackTrace(); int a = 5/0; } finally { System.out.println("3 over"); }

  3中，第一个异常执行完finally后再执行第二个异常。（catch内部再次发生异常也不影响finally的正常运行。）
  进入catch块后，并不会返回到try发生异常的位置，也不会执行后续的catch块，一个异常只能进入一个catch块。
  一般将小异常（具体的异常子类，如ArithmeticException）写在前面，大（宽泛）的异常（如Exception）写在末尾。
  允许包含：

  1 2 3 4 5 6 7 8 9

  try{ try-catch-finally结构 } catch(){ try-catch-finally结构 } finally{ try-catch-finally结构 }

• 方法存在可能异常的语句，但不处理，可使用throws来声明异常。
• 调用带有throws异常（checked exception）的方法，要么处理这些异常，或者再次向外throws，直到main函数为止。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  public class ThrowsDemo { public static void main(String [] args) { try { int result = new Test().divide(3,1); System.out.println("1 result:" + result); } catch(ArithmeticException ex) { ex.printStackTrace(); } int result = new Test().divide(3,0); System.out.println("2 result:" + result); } } class Test { //ArithmeticException is a RuntimeException, not checked exception public int divide(int x, int y) throws ArithmeticException { int result = x/y; return x/y; } }

• 一个方法被覆盖，覆盖它的方法不限抛出相同的异常，或者异常的子类。
• 如果父类的方法抛出多个异常，那么重写的子类方法必须抛出那些异常的子集，也就是不能抛出新的异常。
  Father.java

  1 2 3 4 5 6

  public class Father{ public void f1() throws ArithmeticException { } }

  Son.java

  1 2 3

  public class Son extends Father{ public void f1() throws Exception//错误 }

  自定义异常

• 自定义异常需要继承Exception类或其子类。
  继承自Exception，就变成Checked Exception。
  继承自RuntimeException，就变成Unchecked Exception。
  （非RuntimeException，是Checked Exception，IDE辅助检查；RuntimeException，是Unchecked Exception，IDE不会辅助检查，是程序员自行处理。）
• 自定义重点在构造函数
  调用父类Exception的message构造函数
  可自定义自己的成员变量
• 在程序中采用throw主动抛出异常
  MyException.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  public class MyException extends Exception{ private String returnCode;//异常对应的返回码 private String returnMsg;//异常对应的描述信息 public MyException(){ super(); } public MyException(String returnMsg){ super(returnMsg); this.returnMsg = returnMsg; } public MyException(String returnCode, String returnMsg){ super(returnMsg); this.returnCode = returnCode; this.returnMsg = returnMsg; } public String getReturnCode(){ return returnCode; } public String getReturnMsg(){ return returnMsg; } }

  在方法内部程序中，抛出异常采用throw关键字；在方法头部声明中，声明异常采用throws关键字。
  MyExceptionTest.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  public class MyExceptionTest { public static void testException() throws MyException { throw new MyException("10001", "The reason of myException"); } public static void main(String[] args) { //MyExceptionTest.testException();注释1 要报错需注释掉下方代码 try { MyExceptionTest.testException(); } catch (MyException e) { e.printStackTrace(); System.out.println("returnCode:" + e.getReturnCode()); System.out.println("returnCode:" + e.getReturnMsg()); } } }

  注释1：main函数里调用了一个声明MyException异常的方法，但没处理。因为MyException继承Exception，是属于非RuntimeException，也就是Checked Exception，因此编译器会检查到程序没处理而报错。解法：1）采用try-catch-finally结构 2）main函数也throws MyException。
  DivideByMinusException.java

  1 2 3 4 5 6 7 8 9 10 11 12

  public class DivideByMinusException extends Exception { int divisor; public DivideByMinusException(String msg, int divisor) { super(msg); this.divisor = divisor; } public int getDevisor() { return this.getDevisor(); } }

  Student.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

  public class Student { public int divide(int x, int y) { return x/y; } public static void main(String[] args) throws DivideByMinusException { Student newton = new Student(); //newton.divide2(5,0); newton.divide5(5,-2); } public int divide2(int x,int y) { int result; try { result = x/y; System.out.println("result is " + result); } catch(ArithmeticException ex) { System.out.println(ex.getMessage()); return 0; } catch(Exception ex) { ex.printStackTrace(); return 0; } } public int divide3(int x,int y) throws ArithmeticException//unchecked exception { return x/y; } public int divide4(int x, int y) { // try // { // return divide3(x,y); // } // catch(ArithmeticException ex) // { // ex.printStackTrace(); // return 0; // } return divide3(x,y);//尽管divide3报告异常，但divide4无需处理。 //若调用divide5(x,y);就需要做try-catch处理。 } public int divide5(int x,int y) throws DivideByMinusException { try { if(y < 0) { throw new DivideByMinusException("The divisor is negative", y); } return divide3(x,y); } catch(ArithmeticException ex) { ex.printStackTrace(); return 0; } } }

  对于CheckedException，编译器要求调用者处理，要么采用try-catch-finally处理，要么采用throws声明异常。

数据结构

数组

• 数组是一个存放多个数据的容器
  数据是同一种类型
  所有数据是线性规则排列
  可通过位置索引来快速定位访问数据
  需明确容器的长度

• Java数组定义和初始化

  1 2 3 4 5 6 7 8 9 10 11 12 13

  int a[];//还没有new操作，实际上是null，也不知道内存位置 int[] b; int[] c = new int[2];//c有2个元素，都是0 c[0] = 1, c[1] = 2;//初始化 int d[] = new int[]{1,2,3};//同时定义和初始化 int d1[] = {1,2,3};//同时定义和初始化 //声明变量时没有分配内存，不需要指定大小，以下是错误的 //int a[2]; //int[2] b; //int[2] c = new int[2]; //int d[2] = new int[2];

• 数组索引
  数组的length属性标识数组的长度
  从0开始，到length-1

  1	int[] a = new int[5];//a[0]~a[4],a.length是5

  数组不能越界访问，否则会报ArrayIndexOutOfBoundsException异常

• 数组遍历：两种方法

  1 2 3 4 5 6 7 8 9 10 11

  //需控制索引位置 for(int i = 0; i < d.length; i++) { System.out.println(d[i]); } //无需控制索引位置 for(int e : d) { System.out.println(e); }

• 多维数组
  数组的数组
  存储按照行存储原则

  1 2 3 4 5 6 7 8

  //规则数组 int a[][] = new int[2][3]; //不规则数组 int b[][]; b = new int[3][]; b[0] = new int[3]; b[1] = new int[4]; b[2] = new int[5];

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  int k = 0; for(int i = 0; i < a.length; i++) { for(int j = 0; j < a[i].length; j++) { a[i][j] = ++k; } } for(int[] items : a) { for(int item : items) { System.out.println(item + ", "); } System.out.println(); }

JCF

Java Collection Framework

• 容器：能够存放数据的空间结构
  数组/多维数组，只能线性存放
  列表/散列集/树/…
• 容器框架：为表示和操作容器而规定的一种标准体系结构
  对外的接口：容器中所能存放的抽象数据类型
  接口的实现：可复用的数据结构
  算法：对数据的查找和排序
• 容器框架优点：提高数据存取效率，避免程序员重复劳动

• C++的STL, Java的JCF

• Java 1.1和以前的数据结构
  Vector, Stack, Hashtable, Enumeration等

• Java 1.2和以后，JCF集合框架
  功能更强大，易于学习
  接口和实现分离，多种设计模式更灵活
  泛型设计

主要由列表（List）、散列集合（Set）、映射（Map）组成。（还有Arrays和Collection工具类）
Dictionary和Hashtable属于JDK1.1的类，已经较少使用了。

• 早期接口Enumeration
• JCF的集合接口是Collection
  add, contains, remove, size
  iterator

• JCF的迭代器接口Iterator
  hasNext, next, remove

• JCF主要的数据结构实现类
  列表（List, ArrayList, LinkedList）
  集合（Set, HashSet, TreeSet, LinkedHashSet）
  映射（Map, HashMap, TreeMap, LinkedHashMap）

• JCF主要的算法类
  Arrays: 对数组进行查找和排序等操作
  Collections: 对Collection及其子类进行排序和查找操作

List

• List 列表
  有序的Collection
  允许重复元素
  {1, 2, 3, {1, 2}, 1, 3}

• List主要实现
  ArrayList（非同步）
  LinkedList（非同步）
  Vector（同步）

• ArrayList
  以数组实现的列表，不支持同步
  利用索引位置可以快速定位访问
  不适合指定位置的插入、删除操作
  适合变动不大，主要用于查询的数据
  和Java数组相比，其容量是可动态调整的//Java数组是静态的，长度确定不可修改
  ArrayList在元素填满容器时会自动扩充容器大小的50%

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

import java.util.ArrayList;
//Vector几乎和ArrayList一样，除了Vector本身是同步的

public class ArrayListTest{
    public static void main(String[] a){
        ArrayList<Integer> al = new ArrayList<Integer>();//ArrayList<Integer> al 是泛型表示，意思是al这个数据结构里只能容纳Integer的对象，其它对象无法放入
        al.add(1);//ArrayList只能装对象，当add(1)时，会自动将普通int变量1自动装箱为Integer(1)的对象，然后放入ArrayList容器中
        al.add(2);
        al.add(3);
        al.add(4);
        al.add(new Integer(6));

        System.out.println(al.get(3));
        al.remove(3);//删除第4个元素，后面元素往前挪
        al.add(3, 0);//将0插入到第3个元素，后面元素往后挪

        //遍历方法
        ArrayList<Integer> as = new ArrayList<Integer>(100000);
        for(int i = 0; i < 100000; i++)
        {
            as.add(i);
        }
        traverseByIterator(as);
        traverseByIndex(as);
        traverseByFor(as);
    }
    //迭代器遍历
    public static void traverseByIterator(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        Iterator<Integer> iter1 = al.iterator();
        while(iter1.hasNext()){
            iter1.next();
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //随机索引值遍历
    public static void traverseByIndex(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        for(int i = 0; i< al.size(); i++)
        {
            al.get(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //for循环遍历
    public static void traverseByFor(ArrayList<Integer> al)
    {
        long startTime = System.namoTime();
        for(Integer item : al)
        {
            ;
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

结果表明：for循环遍历最快，随机索引值遍历和for差距不大，迭代器最慢。

• LinkedList
  以双向链表实现的列表，不支持同步
  可被当作堆栈、队列和双端队列进行操作
  顺序访问高效、随机访问较差，中间插入和删除高效
  适用于经常变化的数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

import java.util.ArrayList;


public class LinkedListTest{
    public static void main(String[] a){
        LinkedList<Integer> ll = new LinkedList<Integer>();
        ll.add(1);
        ll.add(2);
        ll.add(3);
        ll.add(4);
        System.out.println(ll.size());
        ll.addFirst(0);//在头部增加0
        ll.add(3,5);//将5插入到第四个元素，四及后续元素往后挪
        ll.remove(3);//将第四个元素删除

        LinkedList<Integer> list = new LinkedList<Integer>();
        for(int i = 0; i < 100000; i++)
        {
            list.add(i);
        }
        traverseByIterator(list);
        traverseByIndex(list);
        traverseByFor(list);       
    }
    //迭代器遍历
    public static void traverseByIterator(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        Iterator<Integer> iter1 = list.iterator();
        while(iter1.hasNext()){
            iter1.next();
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //随机索引值遍历
    public static void traverseByIndex(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        for(int i = 0; i< list.size(); i++)
        {
            list.get(i);
        }
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
    //for循环遍历
    public static void traverseByFor(LinkedList<Integer> list)
    {
        long startTime = System.namoTime();
        for(Integer item : list)
        {
            ;
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

结果：for循环最快，迭代器稍微慢一些，随机索引特别慢。

性能比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

import java.util.ArrayList;

public class ListCompareTest {
    public static void main(String[] args) {
        int times = 10 * 1000;

        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        LinkedList<Integer> linkedList = new LinkedList<Integer>();

        //ArrayList add
        long startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.add(0, i);//add到头部
        }
        long endTime = System.namoTime();
        long duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList add
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.add(0, i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //ArrayList get
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.get(i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList get
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.get(i);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //ArrayList remove
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            arrayList.remove(0);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");

        //LinkedList remove
        startTime = System.nanoTime();

        for(int i = 0; i < times; i++) {
            linkedList.remove(0);
        }
        endTime = System.namoTime();
        duration = endTime - startTime;
        System.out.println(duration + "纳秒");
    }
}

结论：ArrayList适用于较多查询的（静态）数据，LinkedList适用于频繁增删的数据。

• Vector(同步)
  和ArrayList类似，可变数组实现的列表
  Vector同步，适合在多线程下使用
  原先不属于JCF框架，属于Java最早的数据结构，性能较差
  从JDK 1.2开始，Vector被重写，并纳入到JCF
  官方文档建议在非同步情况下，优先采用ArrayList

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

  import java.util.ArrayList; public class VectorTest { public static void main(String[] args) { Vector<Integer> v = new Vector<Integer>(); v.add(1); v.add(2); v.add(3); v.remove(2); v.add(1, 5); System.out.println(v.size()); //遍历方法 Vector<Integer> v2 = new Vector<Integer>(100000); for(int i = 0; i < 100000; i++) { v2.add(i); } traverseByIterator(v2); traverseByIndex(v2); traverseByFor(v2); traverseByEnumeration(v2); } //迭代器遍历 public static void traverseByIterator(Vector<Integer> v) { long startTime = System.namoTime(); Iterator<Integer> iter1 = v.iterator(); while(iter1.hasNext()){ iter1.next(); } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } //随机索引值遍历 public static void traverseByIndex(Vector<Integer> v) { long startTime = System.namoTime(); for(int i = 0; i< v.size(); i++) { v.get(i); } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } //for循环遍历 public static void traverseByFor(Vector<Integer> v) { long startTime = System.namoTime(); for(Integer item : v) { ; } long endTime = System.namoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } //Enumeration遍历 public static void traverseByEnumeration(Vector<Integer> v) { long startTime = System.namoTime(); for(Enumeration<Integer> enu = v.elements(); enu.hasMoreElements();) { enu.nextElement(); } long endTime = System.namoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } }

  结果：for循环是最快的，位置索引第二名，Enumeration第三，迭代器最慢。

Set

确定性：对任意对象都能判定其是否属于某一个集合
互异性：集合内每个元素都是不相同的，内容互异
无序性：集合内的顺序无关
集合接口Set

• HashSet 基于散列函数的集合，无序，不支持同步
  基于HashMap实现的，可以容纳null元素，不支持同步
  但以下方法可以实现同步

  1	Set s = Collections.synchronizedSet(new HashSet(...));

  add 添加一个元素
  clear 清除整个HashSet
  contains 判定是否包含一个元素
  remove 删除一个元素 size 大小
  retainAll 计算两个集合交集
• TreeSet 基于树结构的集合，可排序的，不支持同步
• LinkedHashSet 基于散列函数和双向链表的集合，可排序的，不支持同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest {
	public static void main(String[] args) {
		HashSet<Integer> hs = new HashSet<Integer>();
		hs.add(null);
		hs.add(1);
		hs.add(2);
		hs.add(3);
		hs.add(40000);
		hs.add(5000000);
		hs.add(3);                      //3 重复
		hs.add(null);                   //null重复
		System.out.println(hs.size());  //6
		if(!hs.contains(6))
		{
			hs.add(6);
		}
		System.out.println(hs.size());  //7
		hs.remove(4);
		System.out.println(hs.size());  //6
		//hs.clear();
		//System.out.println(hs.size());  //0
		
		//or循环遍历
	    for(Integer item : hs)
	    {
	    	System.out.println(item);
	    }
	    
	    //测试集合交集	    
	    HashSet<String> set1 = new HashSet<String>();
	    HashSet<String> set2 = new HashSet<String>();

        set1.add("a");
        set1.add("b");
        set1.add("c");

        set2.add("c");
        set2.add("d");
        set2.add("e");

        //交集
        set1.retainAll(set2);
        System.out.println("交集是 "+set1);
        
        //测试遍历方法速度		
		HashSet<Integer> hs2 = new HashSet<Integer>();
		for(int i=0;i<100000;i++)	{
			hs2.add(i);
		}
		traverseByIterator(hs2);
		traverseByFor(hs2);		
	}
	
	public static void traverseByIterator(HashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//迭代器遍历 
	    Iterator<Integer> iter1 = hs.iterator();  
	    while(iter1.hasNext()){  
	        iter1.next();  
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
	public static void traverseByFor(HashSet<Integer> hs)
	{
		long startTime = System.nanoTime();
		//for循环遍历
	    for(Integer item : hs)
	    {
	    	;
	    }
		long endTime = System.nanoTime();
	    long duration = endTime - startTime;
	    System.out.println(duration + "纳秒");
	}
}

迭代器慢于for循环。

• LinkedHashSet
  继承HashSet，也是基于HashMap实现的，可容纳null元素
  不支持同步

  1	Set s = Collections.synchronizedSet(new LinkedHashSet(...));

• 方法和HashSet基本一致
  add,clear,contains,remove,size
  通过一个双向链表维护插入顺序

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

  import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; public class LinkedHashSetTest { public static void main(String[] args) { LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>(); lhs.add(null); lhs.add(1000); lhs.add(20); lhs.add(3); lhs.add(40000); lhs.add(5000000); lhs.add(3); //3 重复 lhs.add(null); //null 重复 System.out.println(lhs.size()); //6 if(!lhs.contains(6)) { lhs.add(6); } System.out.println(lhs.size()); //7 lhs.remove(4); System.out.println(lhs.size()); //6 //lhs.clear(); //System.out.println(lhs.size()); //0 //for循环遍历 for(Integer item : lhs) { System.out.println(item); } LinkedHashSet<Integer> lhs2 = new LinkedHashSet<Integer>(); for(int i=0;i<100000;i++) { lhs2.add(i); } traverseByIterator(lhs2); traverseByFor(lhs2); } public static void traverseByIterator(LinkedHashSet<Integer> hs) { long startTime = System.nanoTime(); //迭代器遍历 Iterator<Integer> iter1 = hs.iterator(); while(iter1.hasNext()){ iter1.next(); } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } public static void traverseByFor(LinkedHashSet<Integer> hs) { long startTime = System.nanoTime(); //for循环遍历 for(Integer item : hs) { ; } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } }

  LinkedHashSet是保留顺序的，其遍历顺序和插入顺序一致；而HashSet没有保留顺序，其遍历顺序无序。

• TreeSet
  基于TreeMap实现的，不可以容纳null元素，不支持同步

  1	SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

  add 添加一个元素
  clear 清除整个TreeSet
  contains 判定是否包含一个元素
  remove 删除一个元素
  size 大小
  根据compareTo方法或指定Comparator排序

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

  import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.TreeSet; public class TreeSetTest { public static void main(String[] args) { TreeSet<Integer> ts = new TreeSet<Integer>(); // ts.add(null); 错误，不支持null ts.add(1000); ts.add(20); ts.add(3); ts.add(40000); ts.add(5000000); ts.add(3); //3 重复 System.out.println(ts.size()); //5 if(!ts.contains(6)) { ts.add(6); } System.out.println(ts.size()); //6 ts.remove(4); System.out.println(ts.size()); //5 //lhs.clear(); //System.out.println(lhs.size()); //0 //for循环遍历 for(Integer item : ts) { System.out.println(item); } TreeSet<Integer> ts2 = new TreeSet<Integer>(); for(int i=0;i<100000;i++) { ts2.add(i); } traverseByIterator(ts2); traverseByFor(ts2); } public static void traverseByIterator(TreeSet<Integer> hs) { long startTime = System.nanoTime(); //迭代器遍历 Iterator<Integer> iter1 = hs.iterator(); while(iter1.hasNext()){ iter1.next(); } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } public static void traverseByFor(TreeSet<Integer> hs) { long startTime = System.nanoTime(); //for循环遍历 for(Integer item : hs) { ; } long endTime = System.nanoTime(); long duration = endTime - startTime; System.out.println(duration + "纳秒"); } }

  HashSet是无序输出的
  LinkedHashSet是按照插入的顺序进行遍历输出的
  TreeSet是按照所存储对象大小升序输出的

• HashSet, LinkedHashSet, TreeSet的元素都只能是对象

• HashSet和LinkedHashSet判定元素重复的原则
  判定两个元素的hashCode返回值是否相同，不同则返回false
  若两者hashCode相同，判定equals方法，不同则返回false
  hashCode和equals方法是所有类都有的，因为Object类有
• TreeSet判定元素重复的原则
  需要元素继承自Comparable接口
  比较两个元素的compareTo方法
  HashSetJudgeRuleTest.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  import java.util.HashSet; public class HashSetJudgeRuleTest { public static void main(String[] args) { HashSet<Cat> hs = new HashSet<Cat>(); hs.add(new Cat(1)); hs.add(new Cat(2)); hs.add(new Cat(3)); hs.add(new Cat(3)); System.out.println(hs.size()); //4 } }

  Cat.java

  1 2 3 4 5 6 7 8 9 10

  class Cat { private int size; public Cat(int size) { this.size = size; } }

  Dog.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  class Dog { private int size; public Dog(int s) { size = s; } public int getSize() { return size; } public boolean equals(Object obj2) { System.out.println("Dog equals()~~~~~~~~~~~"); if(0==size - ((Dog) obj2).getSize()) { return true; } else { return false; } } public int hashCode() { System.out.println("Dog hashCode()~~~~~~~~~~~"); return size; } public String toString() { System.out.print("Dog toString()~~~~~~~~~~~"); return size + ""; } }

  Tiger.java

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  public class Tiger implements Comparable{ private int size; public Tiger(int s) { size = s; } public int getSize() { return size; } public int compareTo(Object o) { System.out.println("Tiger compareTo()~~~~~~~~~~~"); return size - ((Tiger) o).getSize(); } }

  Tiger实现Comparable接口，所以必须实现compareTo方法来比较大小。
  compareTo方法具体规则如下：

  1	int a = obj1.compareTo(obj2);

  若a>0，则obj1>obj2；
  若a==0，则obj1==obj2；
  若a<0，则obj1<obj2。