小葱ban豆腐g
小葱ban豆腐g

Java核心技术 卷 I 读书笔记

Java基础

Java位运算符

与(&)、或(|)、非(~)、异或(^)

  • 与(&)：两个操作数中位都为1，结果才为1，否则结果为0
  • 或(|)：两个位只要有一个为1，那么结果就是1，否则就为0
  • 非(~)：如果位为0，结果是1，如果位为1，结果是0
  • 异或(^)：两个操作数的位中，相同则结果为0，不同则结果为1
public class Count{
     
  public static void main(String[] args){
     
	int a=129;   // a转换为二进制是10000001
	int b=128;   // b转换为二进制是10000000
	System.out.println("a 和b 与的结果是："+(a&b));   // 128
    System.out.println("a 和b 或的结果是："+(a|b));   // 129
    System.out.println("a 非的结果是："+(~a));   // 0b1111110
    System.out.println("a 与 b 异或的结果是："+(a^b));   // 1
  }
}

String类常用API

方法 说明
int length() 返回当前字符串长度
int indexOf(int ch)或int indexOf(String str) 查找字符或字符串在该字符串中第一次出现的位置
int indexOf(int ch, int fromIndex)或int indexOf(String str, int fromIndex) fromIndex:开始搜索的索引位置
int lastIndexOf(int ch)或intlastIndexOf(String str) 查找字符或字符串在该字符串最后一次出现的位置
int lastIndexOf(int ch, int fromIndex)或int lastIndexOf(String str, int fromIndex) fromIndex:开始搜索的索引位置
String substring(int beginIndex)或String substring(int beginIndex, int endIndex) 获取从beginIndex位置开始到结束或endIndex位置的子字符串
String trim() 去除字符串里的空格
boolean equals(Object obj) 将该字符串与指定对象比较
String toLowerCase() / String toUpperCase() 将字符串转换为小 / 大写
char charAt(int index) 获取字符串中指定位置的字符
String[] split(String regex, int limit) 将字符串分割为子字符串，返回字符串数组
byte[] getBytes() 将该字符串转换为byte数组

StringBuilder类常用API

StringBuilder线程不安全！！StringBuffer安全！！

Java编译器对String做了特殊处理，使得我们可以直接用+拼接字符串。

考察下面的循环代码：

String s = "";
for (int i = 0; i < 1000; i++) {
     
    s = s + "," + i;
}

然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。

为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++) {
     
    sb.append(',');
    sb.append(i);
}
String s = sb.toString();
方法 说明
StringBuilder() 构造一个空的字符串构建器
int length() 返回构建器字符串长度
StringBuilder append(String str)或StringBuilder append(char c) 追加一个字符串并返回this
StringBuilder appendCodePoint(int cp) 追加一个代码点，并将其转换为一个或两个代码单元并返回this
void setCharAt(int i,char c) 将第i个代码单元设置为c
StringBuilder insert(int offset,String str) 在offset位置插入一个字符串并返回this
StringBuilder delete(int startIndex,int endIndex) 删除从索引为startIndex到索引为endIndex-1的字符串
String toString() 返回一个构建器内容相同的字符串

Scanner类常用API

方法 说明
Scanner() 新建一个Scanner类对象，参数可以是字符串或是File对象
void close() 关闭此扫描器
boolean hasNextXXX() 判断是否还有下一个输入项，其中Xxx可以是Int，Double等，如果需要判断是否包含下一个字符串，则可以省略Xxx
boolean nextXXX() 获取下一个输入项，Xxx的含义和上一个方法中的Xxx相同，默认情况下，Scanner使用空格，回车等作为分隔符
String nextLine() 此扫描器执行当前行，并返回跳过的输入信息。
String toString() 返回此Scanner的字符串表示形式

文件输入与输出

想要对文件进行读取，就需要一个用File对象构造一个Scanner对象：

Scanner in = new Scanner(Paths.get("my.txt"), "UTF-8");

想对文件进行写入，就需要构造一个PrintWriter对象：

PrintWriter out = new PrintWriter("my.txt", "UTF-8");  //若文件不存在则创建该文件

注：严禁用一个不存在的文件构造Scanner或用一个不能被创建的文件名构造一个PrintWriter，Java解释器认为这类异常比“零除”更严重

实现类似Python的try-except操作：

public static void main(String[], args) throw IOException
{
     
	Scanner in = new Scanner(Paths.get("my.txt"), "UTF-8");
	...
}

Java数组

int[] a;   // 声明a为整型数组
int[] a = new int[100];   // 创建长度为100的数组

for each循环

基本格式：for (iterable : collection) statement

collection这一集合表达式必须是一个数组或是实现了Iterable接口的类对象

for(int element : a)
    System.out.println(element);

数组初始化及匿名函数

int[] array1 = {
     2, 3, 5, 7, 13};   // 不需要调用new
array1 = new int[] {
     2, 3, 5, 7, 13};   // 两种方法作用相同

// 直接初始化一个匿名数组
for (int e : new int[] {
     2, 3, 5, 7, 13}) System.out.println(e);

数组拷贝

int[] array2 = array1;
array[2] = 9;   // 此时array1的结果也会改变

在Java中，允许将一个数组变量拷贝给另一个数组变量。这是两个变量将引用同一个数组。

若要有值拷贝到一个新的数组中，可以调用Arrays类的copyOf方法：

int[] array2 = Arrays.copyOf(array1, array1.length);

第二个参数是新数组的长度，多余元素将被赋值为0，如果数组为boolean类型，多余元素则为false，如果长度小于原数组长度，则只拷贝最前面的元素。

数组排序

int[] a = new int[10000];
...
Arrays.sort(a);   // 快速排序算法

常用API

方法 说明
String toString(type[] a) 返回包含数组元素的字符串，并用，和括号分隔
type copyOf(type[] a, int length) 拷贝长度为length的数组
type copyOfRange(type[] a, int start, int end) 拷贝长度为length的数组，可根据start和end设置起始终止下标
void sort(type[] a) 采用优化的快速排序算法对数组进行排序
int binarySearch(type[] a, int start, int end, type v) 二分查找发查找值v，成功则返回对应下标值，某则返回负数-r，可根据start和end设置起始终止下标
void fill(type[] a, type v) 将数组所有元素值设置为v
boolean equals(type[] a, type[] b) 如果两个数组大小、下标、对应元素都相同，返回true

对象与类

  • 类之间的关系

    • 依赖——“uses-a“，依赖关系例如一个类的方法操纵这另一个类对象（应尽量减少）

    • 聚合——”has-a”，聚合关系意味着例如类A对象包含于类B对象

    • 继承——”is-a“

  • 构造器
    • 构造器与类名同名
    • 每个类可以有一个以上的构造器
    • 构造器可以有0个、1个或多个参数
    • 构造器没有返回值
    • 构造器总是伴随着new操作一起调用

注：必须注意在所有的方法中不要命名与实例域同名的变量

警告：不要编写返回引用可变对象的访问器方法

class Employee
{
     
    private Date hireDay;
    private String name;
    ...
    public Date getHireDay()
    {
     
        return hireDay;   // not good
    }
    ...
}

Employee harry = ...;
Date d = harry.getHireDay();
d.setTime(d.getTime() - 60 * 60 * 1000.0);   // WRONG!!!

在上述代码中，d和harry.harryDay其实引用了同一个对象！！

对d使用更改其方法就会破坏hireDay的私有状态！！！

如需返回一个可变对象的引用，应当先对其克隆(clone)

public Date getHireDay()
{
     
    return (Date) hireDay.clone();   // good use
}

基于类的访问权限

class Employee
{
     
    ...
    public boolean equals(Employee other)
    {
     
        return name.equals(other.name);
    }
}

// 调用上述方法
if (harry.equals(boss)) ...   // correct!

同一个类的方法可以访问该类不同对象的私有域

final修饰符大多修饰基本类型域或不可变类的域，对于可变的类，使用final可能会造成混乱

静态域与静态方法——static

class Employee
{
     
    public static final int nextId = 1;
    ...
}

静态类也被称为类域，对该类的所有对象而言只有唯一一个属于类的拷贝；

静态方法是一种不能向对象实施操作的方法，例如Math.sqrt()

静态方法可以访问自身类中的静态域，例如：

public static int getNextId()
{
     
    return nextId;   // return static field
}

只推荐在一下两种情况使用静态方法：

  • 一个方法不需要访问对象状态，其所需参数都是通过显示参数提供（例如:Math.sqrt()）
  • 一个方法只需要访问类的静态域（例如:Employee.getNextId()）

静态方法也可以当作工厂方法来构造对象

LocalDate t = LocalDate.now();

main方法也是一个静态方法。main方法不对任何对象进行操作。事实上，在启动程序时还没有任何一个对象。静态的main方法将执行并创建程序所需的对象。

注：每一个类可以有一个main方法。这是一个常用于对类进行单元测试的技巧。

《Java核心技术 卷I》第119页 方法参数

对于一个方法的参数，一般有两种类型(1、基本数据类型，2、对象引用)

  • 基本数据类型——作为方法参数不会被修改
  • 对象引用——方法得到的是对象引用的拷贝，对象引用及其拷贝同时引用同一个对象

注：这就意味着当该对象引用的拷贝发生改变时，其引用的对象也会发生改变

Java方法参数总结
  • 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）
  • 一个方法可以改变一个对象参数的状态
  • 一个方法不能让对象参数引用一个新的对象

对象构造

  • 显式域初始化
class Employee
{
     
    private String name= "";   // 在执行构造器之前，先执行赋值操作
    ...
}
  • 参数名
// 命名小技巧
public Employee(String aName, double aSalary)
{
     
    name = aName;
    salary = aSalary;   // 在每个参数前加一个前缀a
}
  • 不同构造器之间相互调用
public Employee(double aSalary)
{
     
    // calls Employee(String, double)
    this("John", aSalary);
}
  • 初始化模块(initialization block)
class Employee{
     
    private static int nextId;
    
    private int id;
    private String name;
    private double salary;
    
    {
       // Runs each time you instantiate an object
        id = nextId;
        nextId++;
    }
    ...
}
  • 静态初始化模块与运行顺序
public class Initialization {
     
  public static void main(String[] args) {
     

    InitClass t1 = new InitClass();
    InitClass t2 = new InitClass();
  }
}

class InitClass {
     
  static int a = 100;

  public InitClass() {
     
    System.out.println("我是构造器");
  }

  {
     
    System.out.println("我是普通初始化块");
  }

  static {
     
    System.out.println("我是静态初始化块");
  }
}

/*
我是静态初始化块
我是普通初始化块
我是构造器
我是普通初始化块
我是构造器
*/

结论：先执行静态初始化模块(只执行一次)，再执行普通初始化模块，最后执行构造器

类设计技巧
  • 一定要保证数据私有
  • 一定要对数据初始化
  • 不要再类中使用过多的基本类型
  • 不是所有的域都需要独立的域访问器和域更改器
  • 优先使用不可变的类

继承

类、子类和超类

  • 定义子类
public class Manager extends Employee
{
     
	添加方法和域...
}

Manager类也就是新类成为子类、派生类或孩子类，已存在的类成为超类、父类、基类

  • 子类构造器
public Manager(String aName, double aSalary, double aBonus){
     
    super(aName, aSalary);
    this.bonus = aBonus;
  }
  • 覆盖超类方法
@Override
public double getSalary()
{
     
    return super.getSalary() + this.bonus;
}

通过特定的关键字super来调用超类的getSalary()方法，如果要覆盖父类方法，要在方法前加@Override

  • 多态

超类对象的任何地方都可以用子类对象置换

Employee e;
e = new Employee(...);
e = new Manager(...);   // 可以将一个子类对象赋给超类

Manager boss = new Manager(...);
Employee staff = new Employee[3];
// staff[0]与boss引用同一个对象，但编译器将staff[0]看成Employee对象
staff[0] = boss;
// 假设set_bonus是Manager子类的方法
boss.set_bonus(5000);   // OK
staff[0].set_bonus(5000);   // ERROR

子类数组的引用可以转换成超类数组的引用，而不需要强制类型转换

注：严禁出现以下错误！！

Manager[] managers = new Manager[10];
Employee[] staff = managers;   // 合法操作
staff[0] = new Employee("George", ...);   // 合法操作
staff[0].setBonus(10000);   // 一个不存在的实例域被调用，会搅乱相邻存储空间的内容
  • 阻止继承：final类和方法
public final class Executive extends Manager
{
     
	...
}

在定义类时加上final修饰符就表明这个类是final类，不允许扩展

public class Employee{
     
	...
    public final String getName(){
     
        return name;
    }
}

将方法或类声明为final主要目的是：确保它们在子类中不会改变语义

  • Java动态绑定与静态绑定

Q：当子类和父类存在同一个方法，子类重写了负类的方法，程序在运行是调用的是父类的方法还是子类的重写方法呢？

Q：当一个类中存在方法名相同但参数不同（重载）的方法，程序在执行时该如何判别区分使用哪种方法呢？

绑定

将一个方法的调用与方法所在的类关联起来。即决定调用哪个方法和变量。在Java中，绑定分为静态绑定与动态绑定。

静态绑定

在Java的方法中只有final、static、private修饰的方法是静态绑定的

private修饰的方法：不能被继承，因此子类无法访问父类的private修饰的方法，只能通过父类的对象来调用。因此可以说private方法和这个类绑定在了一起

final修饰的方法：可以被子类继承，但不能被子类重写

static修饰的方法：可以被子类继承，但不能被子类重写

动态绑定

动态绑定过程1、虚拟机提取对象实际类型的方法表 2、虚拟机搜索方法签名 3、调用方法

  • 强制类型转换
Employee staff = new Employee[10];
Manager boss = (Manager) staff[0];

将一个超类的引用赋给一个子类变量，必须进行类型转换

可以用instanceof操作符实现对类型转换异常的检测

if (staff[1] instanceof Manager)
{
     
    boss = (Manager) staff[1];
    ...
}

如果这个类型转换不可能成功，那么编译器会报出编译错误，例子如下

String c = (String) staff[1];   // Error

综上所述：

  • 强制类型转换只能在继承层次内进行类型转换
  • 在将超类转换为子类之前，应该用instanceof进行检查

抽象类与抽象方法

抽象类更多的体现的是一个模板的作用，以该抽象类作为子类的模板可以避免子类设计的随意性

  • 抽象方法和抽象类的规则

    • 抽象方法和抽象类必须由abstract修饰符修饰，同时，修饰方法不能有实际方法体

    • 抽象类不能实例化，不能由new来调用抽象类的构造器来创建实体

    • 含有抽象方法的类只能被定义为抽象类

抽象类

abstract class Staff {
     
  private double salary;
  private String name;

  {
     
    System.out.println("Staff初始化模块被调用");
  }

  public Staff() {
     
  }

  public Staff(String aName, double aSalary) {
     
    this.salary = aSalary;
    this.name = aName;
    System.out.println("执行Staff的构造器");
  }

  public void setName(String aName) {
     
    this.name = aName;
  }

  public void setSalary(double aSalary) {
     
    this.salary = aSalary;
  }

  public String getName() {
     
    return this.name;
  }

  public double getSalary() {
     
    return this.salary;
  }

  public abstract String getType();

  public abstract void showInfo();
}

子类

class Supervisor extends Staff {
     
  private double bonus = 0;
  private double performance = 1;

  {
     
    System.out.println("Supervisor初始化模块被调用");
  }

  public Supervisor(String aName, double aSalary, double aBonus, double aPerformance) {
     
    super(aName, aSalary);
    this.bonus = aBonus * aPerformance;
    this.performance = aPerformance;
    System.out.println("执行Supervisor的构造器1");
  }

  public Supervisor(String aName, double aSalary) {
     
    super(aName, aSalary);
    System.out.println("执行Supervisor的构造器2");
  }

  public void setBonus(double aBonus) {
     
    this.bonus = aBonus * this.performance;
  }

  public void setPerformance(double aPerformance) {
     
    this.performance = aPerformance;
    this.bonus *= aPerformance;
  }

  @Override
  public String getType() {
     
    return "Supervisor";
  }

  @Override
  public void showInfo() {
     
    System.out.println("员工姓名：" + super.getName());
    System.out.println("员工岗位：" + this.getType());
    System.out.println("员工基本工资：" + super.getSalary());
    System.out.println("员工绩效提成百分比：" + (this.performance - 1) * 100 + "%");
    System.out.println("员工提成：" + super.getSalary() * this.performance);
  }
}
受保护访问

java中用于控制可见性的4个访问修饰符

  • private——仅对本类可见
  • public——对所有类可见
  • protected——对本包和所有子类可见
  • default(默认，不需要写明)——对本包可见

Object：所有类的超类

Object类是Java所有类的始祖，在Java中每个类都是由它扩展而来

  • equals方法

    Object类中的euqals方法用于检测一个对象是否等于另外一个对象

泛型数组列表

在Java中，解决运行时动态更改数组问题最简单的方法是使用**ArrayList类，它是一个采用类型参数的泛型类**。

声明和构造一个保存Employee对象的数组列表：

ArrayList<Emoloyee> staff = new ArrayList<>();   // Java SE7

使用add方法将元素添加到数组列表中：

staff.add(new Employee("George", 13000, ...));

如果已经清楚或能估计数组大小，可以在填充数组之前调用ensureCapacity方法：

staff.ensureCapacity(100);

这个方法将分配一个包含100个对象的内部数组。下100次调用add将不用重新分配空间

ArrayList常用API

方法 说明
ArrayList() 构造一个空数组列表
ArrayList(int initialCapacity) 用指定容量构造一个空数组列表
boolean add(E obj) 在数组列表末尾添加一个元素。永远返回**true**
boolean add(int index, E obj) 在某个位置插入新元素，位于index之后的所有元素都要向后移一个位置
int size() 返回存储在数组列表中的当前元素数量
void ensureCapacity(int capacity) 分配存储空间
void trimToSize() 将数组列表的存储容量削减到当前尺寸

访问数组列表元素

ArrayList类使用set和get方法实现改变或访问数组元素的操作。

方法 说明
void set(int index, E obj) 修改某个位置的元素
E get(int index) 获取某个位置的元素
E remove(int index) 移除某个元素

泛型数组的兼容性要注意！

对象包装器与自动装箱

Integer类对应基本类型int，所有的基本类型都有一个与之对应的类，这些类被成为包装器

这些对象包装类分别是：Integer、Long、Float、Double、Short、Byte、Character、Void和Boolean。

ArrayList<Integer> n_list = new ArrayList<>();

注：由于每个值都被包装在对象中，所有ArrayList的效率远远低于int[] 数组。

  • 自动装箱与自动拆箱

    如果这时调用

    n_list.add(3);

    编译器会自动把这条语句变成

    n_list.add(Integer.valueOf(3));

两个对象包装器的比较需要调用**equals**方法

参数可变的方法

public static double max(double... values) {
     
    double largest = Double.NEGATIVE_INFINITY;
    for (double v : values) if (v > largest) largest = v;
    return largest;
}

调用

double m = max(3.1, 30)

编译器会将new double[] {3.1, 30}传递给max方法

枚举类

enum Size {
     
  SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

  private String size;

  private Size(String size) {
     
    this.size = size;
  }

  public String getSize() {
     
    return this.size;
  }
}
常用API
方法 说明
static Enum valueOf(Class enumClass, String name) 返回指定名字、给定类的枚举常量
static toString() 返回枚举常量名
int ordinal() 返回枚举常量在enum声明中的位置
int compareTo(E other) 如果枚举常量出现在other之前，返回一个负值，如果this==other，返回0.否则返回正值

反射

能够分析类能力的程序被称为反射。反射机制功能极为强大，其可以用来：

  • 在运行时分析类的能力
  • 在运行时查看对象。例如，编写一个toString()方法供所有类使用
  • 实现通用的数组操作代码
  • 利用Method对象，这个对象很像C++中的函数指针

反射机制相关类

反射属于Java的高级特性，JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

类名 用途
Class类 代表类的实体，在运行的Java应用程序中表示类和接口
Field类 代表类的成员变量（成员变量也称为类的属性）
Method类 代表类的方法
Constructor类 代表类的构造方法

例子：

Random generator = new Random();
Class c1 = generator.getClass();
String name = c1.getName();   // name = "java.util.Random"

反射可以通过一个对象、成员变量、属性等来获得整个类，非常方便，这其中涉及类加载器等balabala。。。慢慢来

反射的知识很深奥！！需要慢慢理解！！只写了一小部分！！

接口

接口概念

官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的功能。

个人理解：接口可以理解为一种特殊的类，里面全部是有全局变量和公共抽象方法组成。接口是解决Java无法多继承的一种方法，但接口在实际中更多的是用来制定标准，或者理解为100%的抽象类，即接口中的方法全部都是抽象方法。

接口的语法实现

为了声明一个接口，要使用interface这个关键字，在接口中所有方法都必须只声明方法标识，而不要声明具体方法体。接口中的属性默认为public static final。一个类要实现这个接口必须实现这个接口中定义的所有抽象方法。

public class TestInterface {
     
  public static void main(String[] args) {
     
    testClass t = new testClass();
    t.show();
    System.out.println(testClass.a);
  }
}

interface in1 {
     
  int a = 10;

  void show();
}

class testClass implements in1{
     
  public void show() {
     
    System.out.println("in1.show()" + a);
  }
}

接口与抽象类

  • 接口也可以被扩展
  • 每个类只能有一个超类，但却可以实现多个接口
  • 接口不能实例化，但却可以声明接口变量

接口方法冲突

  • 超类优先

    如果超类与默认方法提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略。

  • 接口冲突
    class Student implents Person, Named {
       
    public String getName() {
        return Person.super.getName(); }
    ...
}

    如果两个接口其中有一个冲突的方法不是默认方法，编译器则会报错要求解决二义性。

接口与回调

public class CallBackTest {
     
  public static void main(String[] args) {
     
    TaxiDriver td = new TaxiDriver();
    Passenger passenger = new Passenger();
    passenger.TakeTaxi(td);
  }
}

interface Callback {
         // 接口
  boolean Consider(int money);

  void PayFor(int money);

}

class TaxiDriver {
     
  public int Answer(Callback callback) {
     
    System.out.println("去那的话要100块");
    if (callback.Consider(100) == true) {
     
      callback.PayFor(100);   // 回调
    }
    return 100;
  }
}

class Passenger implements Callback {
     
  @Override
  public boolean Consider(int money) {
     
    boolean result = true;
    if (money > 80) {
     
      System.out.println(money + "太贵了，您看80行不行？");
      result = false;
    }
    return result;
  }

  @Override
  public void PayFor(int money) {
      System.out.println("好的，这是您的" + money); }

  public void TakeTaxi(TaxiDriver td) {
     
    System.out.println("师傅，去天一多少钱？");
    td.Answer(this);
  }
}

回调是一种常见的程序设计模式，利用回调技术可以处理这样的问题，事件A发生时要执行处理事件A的代码，判断何时发生事件A及何时执行处理事件A的代码。这些代码是固定的，先行编写完毕，供使用。但事件A的处理代码开放给其他开发人员编写，可以有很多不同的实现，使用时可以注册具体需要的实现来处理。

对象克隆

Employee origin = new Employee("John", 13000);
Employee copy = origin;   // 获取对象的引用
copy.raiseSalary(1000);   // 此时origin对象发生改变

// 如果希望copy是一个新对象，且初始状态与origin相同，可以使用clone方法
Employee copy = origin.clone();
copy.raiseSalary(1000); 

// 默认浅拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
     
  return super.clone();
}

// 深拷贝
protected object clone() throws CloneNotSupportedException {
     
    Employee cloned = (Employee) super.clone();
    cloned.hireDay = (Date) hireDay.clone();
    return cloned;
}

默认的克隆操作是“浅拷贝”，并没有克隆对象中引用的其他对象。如果引用的其他对象属于不可变的类，例如String，那么这种浅克隆的共享子对象就是安全的。而通常子对象都是可变的，必须重新定义clone方法来建立一个深拷贝，同时克隆出所有的子对象。例如Employee类中的hireDay域是一个Date，所以它也需要克隆。

lambda表达式

lambda表达式语法格式：

(parameters) -> expression
// 或
(parameters) -> {
      statements; }

函数式接口

对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口被称为函数式接口。

例如：

// Arrays.sort第二个参数需要一个Comparator实例，Comparator就是只有一个方法的接口。
String[] planets = new String[] {
      "Mercury", "Venus", "Earth", "Mars", "Jupiter"};

Arrays.sort(planets, (first, second) -> first.length() - second.length());

在底层，Arrays.sort方法接收 实现了Comparator的某个类的对象。在这个对象上调用compare方法会执行这个lambda表达式的体。这些对象和类的管理完全取决于具体实现，且比传统的内联类高效得多。

注：最好把lambda表达式看作是一个函数，而不是一个对象

Timer t = new Timer(1000, event -> {
     
    System.out.println("the time is " + new Date());
})

Java API在java.util.function包中定义了很多非常通用的函数式接口

方法引用

在学习lambda表达式之后，我们通常使用lambda表达式来创建匿名方法。然而，有时候我们仅仅是调用了一个已存在的方法。

什么是方法引用？

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。

四种方法引用类型

类型方法 语法 对应的Lambda表达式
静态方法引用 类名::staticMethod (args) -> 类名.staticMethod(args)
实例方法引用 类名::instanceMethod (args) -> 类名.instMethod(args)
对象方法引用 类名::instMethod ()
构造方法引用 类名::new

异常

如果由于出现错误而是的某些操作没有完成，程序应该：
  • 返回到一种安全状态，并能够让用户执行一些其他的命令
  • 允许用户保存所有操作的结果，并以妥善的方式终止程序

异常分类

异常对象都是派生于**Throwable**类的一个实例

Throwable
Error
Exception
IOException
RuntimeException

**Error**类层次描述了 Java 运行时系统的内部错误和资源耗尽错误。

在设计 Java 程序时，需关注**Exception层次结构。这种层次结构又分解位两个分支：一个分支派生于RuntimeException**; 另一个分支包含其他异常。划分的规则是：由程序错误导致的异常属于RuntimeException；而程序本身没有问题，但类似像 I/O 错误这类问题导致的异常则属于其他异常。

注：如果出现RuntimeException异常，那么就一定是你的问题

派生于RuntimeException的异常包含以下几种情况：
  • 错误的类型转换
  • 数组访问越界
  • 访问 null 指针

Java 语言规范将派生于 Error 类或 RuntimeException 类的所有异常成为非受查(unchecked)异常，所有其他异常称为受查(checked)异常。

遇到下面四种情况时应该抛出异常：
  • 调用一个抛出受查异常的方法，例如 FileInputStream 构造器
  • 程序运行过程中发现错误，并利用 throws 语句抛出一个受查异常
  • 程序出现错误
  • Java 询价和运行时库出现的内部错误
注：子类方法可以抛出比父类更特定的异常或根比不抛出，但不能抛出父类方法没有 throws 的异常

捕获多个异常

try {
     
    code that might throw exceptions
}
catch (FileNotFountException | UnknownHostException e) {
     
    pass
}
catch (IOException e) {
     
    pass
   	e.getMessage();   // 得到更详细的信息
    e.getClass().getName()   // 得到异常对象的实际类型
}

再次抛出异常与异常链

捕获异常并将它再次抛出的基本方法。

try {
     
	access the database
}
catch (SQLException e) {
     
    throw new ServletException("database error: " + e.getMessage());
}

这里，ServletException 用带有异常信息文本的构造器来构造

不过，有一种更好的处理方法，并且将原始异常设置为新异常的“原因”

try {
     
    access the database
}
catch (SQLException e) {
     
    Throwable se = new Servlet("database error");
    se.initCause(e);   // initCause()方法初始化该throwable为指定值的原因
    throw se;
}

当捕获到异常时，就可以用下面这条语句重新获得原始异常：

Throwabel e = se.getCause();

强烈建议使用这种包装技术。这样可以让用户抛出子系统中的高级异常，而不会丢失原始异常的细节。

finally 子句

finally 子句并不是必须存在的,不过开发过程中建议加上finally,里面可以使用来执行打印日子代码,给出现问题时查看日子买下伏笔,做一些善后清理工作。

有意思的是，即使try里包含continue，break，return，try块结束后，finally块也会执行。

如果 try 子句和 finally 子句中都有 return 返回值，那么同时执行时 finally 会覆盖原始返回值

带资源的try语句(try-with-resources)

带资源的try语句，它允许在try关键字后紧跟一对圆括号，圆括号可以声明、初始化一个或多个资源（此处的资源是指那些必须在程序结束时显式关闭的资源，比如数据库连接，网络连接等）

try-with-resources 是一个定义了一个或多个资源的 try 声明，try语句在该语句结束时自动关闭这些资源。try-with-resources确保每一个资源在处理完成后都会被关闭。这些资源必须实现 AutoCloseable 或者 Closeable 接口，实现这两个接口就必须实现close() 方法。

try (Scanner in = new Scanner(new FileInputStream("d:\\haha.txt"));
     PrintWriter out = new PrintWriter("d:\\hehe.txt"))
{
     
    while (in.hasNext()) {
     
        out.println(in.next().toUpperCase());
    }
} catch (FileNotFoundException e) {
     
    e.printStackTrace();
}

堆栈轨迹(stack trace)

堆栈轨迹是一个方法调用过程的列表，它包含了程序执行过程中方法调用的特定位置。

可以调用 Throwable 类的 printStackTrace 方法访问堆栈轨迹的文本描述信息，或者调用getStackTrace 方法得到一个 StackTraceElement 对象数组，你可以在程序中分析这个数组

Throwable t = new Throwable();
StackTraceElement[] frames = t.getStackTrace();
for(StackTraceElement frame : frames)
    System.out.println(frame);
/*
StackTraceTest.factorial(StackTraceTest.java:6)
StackTraceTest.main(StackTraceTest.java:24)
*/

/*
阶乘递归打印函数的堆栈情况
*/
import java.util.Scanner;

public class StackTraceTest {
     
  public static int factorial(int n) {
     
    System.out.println("factorial(" + n + "):");
    Throwable t = new Throwable();

    StackTraceElement[] frames = t.getStackTrace();
    t.printStackTrace();
    for (StackTraceElement f : frames)
      System.out.println(f);

    int r;
    if (n <= 1) r = 1;
    else r = n * factorial(n - 1);
    System.out.println("return " + r);
    return r;
  }

  public static void main(String[] args) {
     
    Scanner in = new Scanner(System.in);
    System.out.println("Enter n: ");
    int n = in.nextInt();
    factorial(n);
  }
}

java.lang.Throwable

方法名 作用
Throwable(Throwable cause)
Throwable(String message, Throwable cause) 用给定"原因"构造一个Throwable对象
Throwable getCause() 获得设置为这个对象的"原因"的异常对象
StackTraceElement[] getStackTrace() 获得构造这个对象时调用堆栈的跟踪
  • 捕获异常机制所消耗的时间远大于不进行捕获，所以只在异常情况下使用异常机制
  • 不要过分地细化异常
  • 利用好异常层次结构
  • 不要压制异常
  • 在检测错误时，"苛刻"比放任更好
  • 不要羞于传递异常

使用断言

Java 断言的两种形式：
assert 条件;
assert 条件 : 表达式;

这两种形式都会对条件进行检测，如果为 false ，则抛出一个 AssertionError 异常。在第二种形式中，表达式被传入 AssertionError 的构造器，并转换成一个消息字符串

注：“表达式” 部分的唯一目的是产生一个消息字符串。

启用和禁用断言

在默认情况下，断言是被禁用的。可以在命令行运行时用 -enableassertions 或 -ea 选项启用：

java -enableassertions Test.java

在启用或禁用断言时不必重新编译程序。

禁用断言，可以在命令行运行时用 -disableassertions 或 -da 选项启用：

上述断言命令选项不能用于那些没有类加载器的"系统类"中。

Java 语言中，给出了3种处理系统错误的机制:
  • 抛出一个异常
  • 日志
  • 使用断言
什么时候该使用断言呢?应记住以下几点：
  • 断言失败是致命的、不可恢复的错误
  • 断言检查只用于开发和测试阶段

在调用API时，可以阅读文档，确定可能出现的错误，例如如下的排序方法

/*
 * @param a the array to be sorted
 * @param fromIndex the index of the first element, inclusive, to be sorted
 * @param toIndex the index of the last element, exclusive, to be sorted
 *
 * @throws IllegalArgumentException if {@code fromIndex > toIndex}
 * @throws ArrayIndexOutOfBoundsException
 *     if {@code fromIndex < 0} or {@code toIndex > a.length}
 */
public static void sort(int[] a, int fromIndex, int toIndex)

文档指出了方法可能出现的错误，比如出现错误的索引值，那么就会抛出一个异常。这是方法与调用者之间约定的处理行为。如果实现这个方法，就应该遵守约定，并抛出索引值有误的异常，因此不适合用断言。

如果：

/*
* @param a the array to be sorted
* 变为
* @param a the array to be sorted (must not be null)
*/

此时不允许用null数组去调用这个方法，就应该在调用方法前使用断言

assert array != null;

这种约定被称为前置条件(Precondition)。

泛型程序设计

泛型程序设计(Generic programming) 意味着编写的代码可以被很多不同类型的对象所重用。例如 ArrayList 类可以聚集任何类型的对象。

在 Java 增加泛型类之前，泛型程序设计是用继承实现的（CoreJava I 309页）。ArrayList类只维护一个 Object 引用的数组：

public class ArrayList  // 产生泛型类之前
{
      
 private Object[] elementData;
 ...
 public Object get(int i) {
      ...}
 public Object add(Object o) {
      ...}
}

这种方法有两个问题：

  • 当获取一个值时必须进行强制类型转换
  • 没有错误检查，可以向数组列表中添加任何类的对象。

泛型类提供了一个类型参数(type parameters) 用来指示元素的类型，例如：

ArrayList<String> files = new ArrayList<String>();
// 在 Java SE 7之后，构造函数中可以省略泛型类型

类型参数的魅力在于：使得程序具有更好的可读性和安全性。

定义简单的泛型类

一个泛型类就是具有一个或多个类型变量类型的类。

注：类型变量尽量使用大写，且比较短，E表示集合的元素类型。K和V分别表示表的关键字与值的类型。T表示 “任意类型”。

类型变量的限定

如何确保类型 T 变量所属的类有 compareTo 方法呢？解决这个问题的方案是将 T 限制为实现了 Comparable 接口的类。

public static <T extends Comparable> T min(T[] a) ...

表示 T 绑定的子类型。绑定类型既可以是类，也可以是接口。

限定类型用 “&” 分隔，而 逗号 用于分隔类型变量。

一个简单的泛型类例子如下：

package pair;

import java.time.LocalDate;

public class PairTest1 {
     
  public static void main(String[] args) {
     
    String[] words = {
     "Mary", "had", "a", "little", "lamb"};
    Pair<String> mm = ArrayAlg.minmax(words);
    System.out.println("min = " + mm.getFirst());
    System.out.println("max = " + mm.getSecond());
    System.out.println("test_min = " + ArrayAlg.<String>min(words));

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

    LocalDate[] birthday =
            {
     
                    LocalDate.of(2000, 12, 25),
                    LocalDate.of(2000, 8, 28),
                    LocalDate.of(2000, 9, 30),
                    LocalDate.of(2000, 4, 28),
                    LocalDate.of(2018, 1, 13),
            };
    Pair<LocalDate> bd = ArrayAlg.minmax(birthday);
    System.out.println("min = " + bd.getFirst());
    System.out.println("max = " + bd.getSecond());
  }
}

class Pair<T> {
     
  private T first;
  private T second;

  public Pair() {
     first = null; second = null;}
  public Pair(T first, T second) {
     this.first = first; this.second = second;}

  public T getFirst() {
         return first;  }

  public T getSecond() {
     return second; }

  public void setFirst(T first) {
     this.first = first;}

  public void setSecond(T second) {
         this.second = second;  }
}

class ArrayAlg {
     
	
  public static <T extends Comparable<? super T>> Pair<T> minmax(T[] a) {
     
    if (a == null || a.length == 0) return null;
    T min = a[0];
    T max = a[0];
    for (int i = 1; i < a.length; i++) {
     
      if (min.compareTo(a[i]) > 0) min = a[i];
      if (max.compareTo(a[i]) < 0) max = a[i];
    }
    return new Pair<>(min, max);
  }

  public static <T extends Comparable> T min(T[] a) {
     
    if (a.length == 0) return null;
    T smallest = a[0];
    for (int i = 1; i < a.length; i++) {
     
      if (smallest.compareTo(a[i]) > 0) smallest = a[i];
    }
    return smallest;
  }
}

泛型代码和虚拟机VM

虚拟机没有泛型类型对象——所有对象都属于普通类。

无论何时定义了一个泛型类型，都自动提供了一个相应的原始类型(raw type)。

类型擦除

Java泛型的处理在编译器中运行，编译生成的字节码bytecode不包含泛型信息，泛型信息在编译处理时被擦除(erasure)，这个过程即类型擦除。

例如上述 Pair的原始类型如下所示：

public class Pair {
     
    private Object first;
    private Object second;
    
    public Pair() {
     first = null; second = null;}
    public Pair(Object first, Object second) {
     
        this.first = first;
        this.second = second;
    }
    public Object getFirst() {
         return first;  }

    public Object getSecond() {
     return second; }

    public void setFirst(Object first) {
     this.first = first;}

    public void setSecond(Object second) {
     this.second = second;  }
}

如果泛型类有类型限定，原始类型用第一个限定的类型变量来替换，如果没有限定则用 Object 来替换。

例如：

class Interval<T extends Comparable & Serializable> implements Serializable {
     
  private T lower;
  private T upper;
  ...
  public Interval(T first, T second) {
     
    if (first.compareTo(second) <= 0) {
     lower = first; upper = second;}
    else {
     lower = second; upper = first;}
  }
}

原始类型如下所示：

class Interval implements Serializable {
     
    private Comparable first;
    private Comparable second;
    ...
    public Interval(Comparable first, Comparable second) {
     ...}
}

如果要用到原始类型 Serializable ，在编译器中会在必要时向 Comparable 插入强制类型转换。

因为 Comparable 包含实现方法 CompareTo ，而 Serializable 只是个标签（Tagging， 即没有方法的接口）接口，若二者对调位置，则原始类型将用Serializable来替换，这样在编译器必要时要向 Comparable 插入强制类型转换，所以为了提高效率，最好将标签（Tagging）接口放在边界列表的末尾。

给JVM的指令：擦除方法返回类型，编译器将方法调用处理为两条JVM虚拟机指令

  • 对原始方法的调用（返回Object类型或限定类型）

  • 将返回的Object类型强制转换为泛型类型的具体类型（如Employee）

  • 补充#当存取一个泛型域时也要插入强制类型转换

桥方法

我们知道 Java 中的泛型在编译为 class 的时候会把泛型擦除，也就是说你写的 到最后 class 文件中其实都是 Object。

而对于泛型类的子类，例子如下：

class DataInterval extends Pair<LocalDate> {
     
  @Override
  public void setSecond(LocalDate second) {
     
    if (second.compareTo(getFirst()) >= 0)
      super.setSecond(second);
  }
  ...
}

经过编译类擦除后，变成：

class DataInterval extends Pair {
     
    public void setSecond(LocalDate second) {
     ...}
    ...
}

此时在编译器中会生成一个桥方法(bridge method)

public void setSecond(Object second) {
     ...}

来解决对setSecond 的调用多态性要求。

在 JVM 中，用参数类型和返回类型来确定一个方法。

总之，需要记住有关 Java 泛型转换的事实：

  • 虚拟机中没有泛型，只有普通的类和方法
  • 所有的类型参数都用它们的限定类型转换
  • 桥方法被合成来保持多态
  • 为保持类型安全性，必要时插入强制类型转换

泛型的约束与局限性

《CoreJava I》 P321

不能用基本类型实例化类型参数

不能用类型参数代替基本类型。因此没有 Pair ，只有 Pair 。其原因是类型擦除，擦除之后，Pair类含有 Object 类型的域，而 Object 不能存储 double 值。

类型查询只适用于原始类型

虚拟机中的对象总有一个特定的非泛型类型。因此，素有的类型查询只产生原始类型。

例如：

if (a instanceof Pair<String>)   // Error

实际上任意一个类型的 Pair 都是如此亦或是 强制类型转换：

if (a instanceof Pair<T>)   // Error
Pair<String> p = (Pair<String>) a;   // Warning--can only test that a is a Pair

同样的道理， getClass() 方法返回的也总是原始类型

Pair<String> a = new Pair<>("aaa", "bbb");
System.out.println(a.getClass());   // class pair.Pair

不能创建参数化类型的数组

不能实例化参数化类型的数组，例如：

Pair<String>[] table = new Pair<String>[10];   // Error

但是却可以参数化数组本身的类型

Pair<String>[] arr;   // Right

Varargs警告

不能实例化类型一个变量或数组

public Pair() {
     first = new T();  second = new T();}   // Error

不能构造泛型数组

泛型类的静态上下文中类型变量无效

不能抛出或捕获泛型类的实例

可以消除对受查异常的检查

泛型类型的继承规则

《CoreJava I》 P328

Manage[] m = ...;
Pair<Employee> result = ArrayAlg.minmax(m);   // Error

minmax 方法返回 Pair ，而不是 Pair ，并且这样的赋值是不合法的。

通常，Pair 和 Pair 没有什么联系

通配符类型

通配符类型

Java 集合

所有的集合类都位于 java.util 包下

Java 数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点
  • 集合类不能存放基本数据类型
  • 数组容量固定无法动态改变
  • 数组无法判断实际的元素数量

一篇还不错的文章

Collection 接口

在 Java 类库中，集合类的基本接口是 Collection 接口。这个接口有两个基本方法

public interface Collection<E>
{
     
	boolean add(E element);
	Iterator<E> iterator();
	...
}

add 方法用于向集合中添加元素。如果添加元素确实改变了集合就返回 true，没有发生变化则返回 false。

iterator 方法用于返回一个实现 Iterator接口的对象。可以使用这个迭代器对象一次访问集合中的元素。

Iterator 接口——迭代器

Iterator 接口包含4个方法：

public interface Iterator<E>
{
     
	E next();
	boolean hasNext();
	void remove();
	default void forEachRemaining(Consumer<? super E> action);
}

通过反复调用 next 方法，可以逐个访问集合中的每个元素。但是如果达到了集合的末尾，next 方法将抛出一个 NoSuchElementException 。因此，需要在调用 next 之前调用 hasNext 方法。

例如：

Collection<String> c = ...;
Iterator<String> iter = c.iterator();
while (iter.hasNext()) {
     
    String element = iter.next();
    ...
}
// 或用 for each 循环
for (String element : c) {
     
    ...
}

“for each” 循环可以与任意实现了 Iterator 接口的对象一起工作，这个接口只包含一个抽象方法：

public interface Iterable<E>
{
     
	Iterator<E> iterator();
	...
}

Collection 接口扩展了 Iterable 接口。因此，对于标准类库中的任意集合都可以使用 "for each"循环。

在 Java SE 8 中，甚至不用写循环。可以调用 forEachRemaining 方法并提供一个 lambda 表达式(它会处理一个元素)。将对迭代器的每一个元素调用这个 lambda 表达式，知道没有元素为止。

例如：

Iterator<String> iter = c.iterator();
iter.forEachRemaining(element -> {
     ...})

元素被访问的顺序取决于集合类型。如果对 ArrayList 进行迭代，迭代器将从索引 0 开始顺序迭代。如果访问 HashSet 中的元素，每个元素将会按照某种随机的次序出现。

Java 迭代器的查找操作与位置变更是紧密相连的。查找一个元素的唯一方法是调用 next 方法，而在查找操作的同时，迭代器的位置随之向前移动。

因此，应将 Java 迭代器认为是位与两个元素之间。当调用 next 时，迭代器就越过一个元素，并返回刚刚越过的那个元素的引用。

Iterator 接口的 remove 方法将会删除上次调用 next 方法时返回的元素。在大多数情况下，在决定删除某个元素之前应该看一下这个元素是很具有实际意义的。然而，如果想要删除指定位置上的元素，仍需要越过这个元素。

例如删除集合中第一个元素的方法：

Iterator<String> iter = c.iterator();
iter.next();   // skip over the first element
iter.remove();   // now remove it

对 next 方法和 remove 方法的调用具有相互依赖性，如果调用 remove 之前没有调用 next 将是不合法的。如果这样做会抛出一个 IllegalStateException 异常。

泛型实用方法

由于 Collection 与 Iterator 都是泛型接口，可以编写操作任何集合类型的实用方法。例如，一个检查任意类型集合是否包含指定元素的泛型方法：

public static <E> boolean contains(Collection<E> c, Object obj)
{
     
    for (E element: c)
        if (element.equals(obj))
            return true;
    return false;
}

Collection 接口声明了很多很有用的方法，所有的实现类都必须提供这些方法。但实现 Collection 接口的每一个方法很繁琐。为了让是实现者更容易地实现这个接口，Java 类库提供了一个 AbstractCollection 类，它将基础方法 size 和 iterator 抽象化了，但其他方法提供了例行方法，例如：

public abstract class AbstractCollection<E> implements Collection<E>
{
     
	...
	public abstract Iterator<E> iterator();
	
	public boolean contains(Object obj)
	{
     
		for (E element : this)
			if (element.equals(obj))
				return true;
		return false
	}
	...
}

在 Java SE 8 中新增了一个 default boolean removeIf(Predicate filter) 方法

可以用 lambda 表达式删除满足条件的此集合的所有元素。

集合框架中的接口

NavigableSet
SortedSet
Set
Deque
Queue
List
Collection
Iterable
NavihableMap
SortedMap
ListIterator
Iterator
Map
RandomAccess

集合类有两个基本接口： Collection 和 Map。

Map 由于映射包含键 / 值对，所以要用 put 方法来插入：V put(K key, V value)

List 是一个有序集合。元素会增加到容器中的特定位置。可以采用两种方式访问元素：使用迭代器访问元素 或 使用一个整数索引来访问。

ListIterator 接口是 Iterator 的一个子接口。它定义了一个方法用于在迭代器位置前增加一个元素：void add(E element)

Set 接口等同于 Collection 接口，不过其方法的定义更严谨。Set 的 add 方法不允许增加重复的元素。要适当地定义 Set 的equals 方法：只要求包含相同的元素，不要求次序一样。

Java 库中的具体集合

集合类型 描 述
ArrayList 一种可以动态增长和缩减的索引序列
LinkedList 一种可以在任何位置进行高效地插入和删除操作的有序序列
ArrayDeque 一种用循环数组实现的双端队列
HashSet 一种没有重复元素的无序集合
TreeSet 一种有序集
EnumSet 一种包含枚举类型值的集
LinkedHashSet 一种可以记住元素插入次序的集
PriorityQueue 一种允许高效删除最小元素的集合
HashMap 一种存储键 / 值关联的数据结构
TreeMap 一种键值有序排列的映射表
EnumMap 一种键值属于枚举类型的映射表
LinkedHashMap 一种可以记住键 / 值对添加次序的映射表
WeakHashMap 一种在其值无用武之地后可以被垃圾回收器回收的映射表
IdentityHashMap 一种用 == 而不是用 equals 比较键值的映射表

链表

在 Java 中，所有链表实际上都是**双向链接(doubly linked)**的。

例如 LinkedList 中的添加删除元素：

List<String> staff = new LinkedList<>();
staff.add("Amy");
staff.add("Bob");
Iterator iter = staff.iterator();
String first = (String) iter.next();   // visit first element
String second = (String) iter.next();
iter.remove();   // 删除第二个元素

链表与泛型集合之间有一个重要的区别。链表是一个有序集合，每个对象的位置十分重要。

在 Iterator 接口中没有 add 方法。相反地，在集合类库中提供了子接口 ListIterator ，其中包含了 add 方法，与 Collection.add 不同，这个方法为 void，它假定添加操作总会改变链表。

另外，ListIterator 接口有两个方法用来反向遍历列表：

ListIterator<String> iter = staff.listIterator();
String first = iter.next();   // visit first element
String second = iter.next();
iter.remove();   // 删除第二个元素
System.out.println(iter.previous());
System.out.println(iter.previousIndex());

注⚠️：调用 next 后 remove 会删除左侧元素，如果调用 previous 后 remove 则会删除右侧元素。

如果在迭代器修改集合时，另一个迭代器对其进行遍历，一定会出现混乱的状态！！

List<String> list = ...;
ListIterator<String> iter1 = list.listIterator();
ListIterator<String> iter2 = list.listIterator();
iter1.next();
iter1.remove();
iter2.next();   // throws ConcurrentModificationException

为了避免发生修改的异常，请遵循以下简单规则⚠️：可以根据需求给容器附加许多迭代器，但这些迭代器只能读取列表。另外，再单独附加一个既能读又能写的迭代器。

链表在访问特定索引值元素时必须从头开始，故在程序需要采用整数索引访问元素时，不选用链表。使用链表的唯一理由是尽可能减少在列表中插入或删除元素所付出的代价。

List ListIterator LinkedList API 《CoreJava I》P362

数组列表(ArrayList)

ArrayList 详解

散列集

散列表的每一个对象都有一个***散列码(hashCode)***，独一无二，其可以用于快速地查找所需要的对象。散列码的计算方式 hashCode() 参见 P170

注：自己实现的 hashCode 方法应该与 equals 方法兼容，即如果 a.equals(b) 为 true，那么 a 与 b 必须具有相同的 hashCode。

在 Java 中，散列表用链表数组实现。每个列表被称为桶(bucket)。要想查找表中对象的位置，就要先计算它的散列码，然后与桶总数取余，所得到的结果就是保存这个元素的桶的索引值。

桶也有被占满的情况，这种现象被称为***散列冲突(hashCollision)***。这个需要用新对象与桶中的所有对象进行比较，查看这个对象是否已经存在。

要想更多地控制散列表的性能，就要指定一个初始的桶数。如果要插入到散列表中的元素太多，就会增加冲突的可能性，降低运行性能。

通常将桶数设置为预计元素个数的 75%~150%。(最好设为素数 (猜测))标准类库使用的桶数是 2 的幂数，默认值为 16。

如果散列表太慢，就需要***再散列(rehashed)***。rehashed 需要创建一个新的表，将所有元素插入到新表，然后丢弃旧表。***装填因子(load factor)***将决定何时对散列表进行 rehashed ，比如 0.75 代表表中 75% 的位置已经填入元素时，这个表就会用双倍的桶数自动进行 rehashed。

警告⚠️：再更改集中元素时要格外小心，如果元素的散列码发生了改变，元素在数据结构中的位置也会发生变化。

树集

TreeSet 类与散列集十分相似，不过它比散列集有所改进，树集是一个有序集合。可以以任意顺序将元素插入到集合中。在对集合进行遍历时，每个值将自动地按照排序后的顺序呈现。例如:

TreeSet<String> sorter = new TreeSet<>();
sorter.add("Bob");
sorter.add("Amy");
sorter.add("Candy");
for (String name : sorter) System.out.println(name);
// Amy Bob Candy

排序是使用红黑树结构完成的。将一个元素添加到树种要比添加到散列集中慢，如果树中包含 n 个元素，查找新元素的正确位置平均需要 log2n 次比较。

注：要使用树集，其元素类型必须实现 Comparable 接口，或者构造集时必须提供一个Comparator

队列与双端队列

队列可以让人们有效地在尾部添加一个元素，在头不删除一个元素(先进先出)。有两个端头的队列，即***双端队列***，可以有效地在头部和尾部同时添加或删除元素。但不支持在队列中间添加元素。

在 Java SE 6 中引入了 Deque 接口，并由 ArrayDeque 和 LinkedList 类实现。这两个类都提供了双端队列，并且可以在必要时增加队列长度

优先级队列

优先级队列(priority queue) 中的元素可以按任意顺序插入，却总书按照排序顺序进行检索。也就是说，无论何时调用 remove 方法，总会获得当前优先级队列中最小的元素。

然而，优先级队列并没有对所有元素进行排序。优先级队列使用了一个优雅高效的数据结构，从为***堆(heap)***。堆是一个可以不断自我调整的二叉树，对树执行 add 和 remove 操作，可以让最小元素移动到根节点。

与 TreeSet 一样，一个优先级队列既可以保存实现了 Comparable 接口的类对象，也可以保存在构造器中提供的 Comparator 对象。

映射

Java 类库为映射提供了两个通用的实现：HashMap 和 TreeMap 。这两个类都实现了 Map 接口。

基本映射操纵

散列映射(HashMap) 对键进行散列，树映射用键的整体顺序对元素进行排序，并将其组织成搜索树。散列的比较函数只能作用于键。与键关联的值不能进行散列或比较。

例如为存储员工学习建立一个散列映射：

Map<String, Employee> map = new HashMap<>();
Employee cygao = new Employee("cygao", 9200);
map.put("660-12", cygao);

映射添加对象时，必须提供一个键，上面的键约束一个字符串，要检索对象时，必须提供一个键

String id = "600-12";
Employee e = map.get(id);

如果映射中没有与给定键对应的学习，get 将返回null。null 返回值可能并不方便，可以用 getOrDefault 方法设定默认的返回值。键必须是唯一的，不能对一个键同时存放两个值。

remove 方法用于从映射中删除给定键对应的元素并返回。

要迭代处理映射的键和值，最容易的方法是使用 forEach 方法。

map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

更新映射

更新映射项是一个难点，要考虑一个键是否是第一次出现的情况，一个单词计数器的例子：

Map<String, Integer> counter = new HashMap<>();
String word = "student";

// 方法一：
counter.put(word, counter.getOrDefault(word, 1));

// 方法二：
counter.putIfAbsent(word, 0);
counter.put(word, counter.get(word) + 1);

// 方法三:
counter.merge(word, 1, Integer::sum);
方法 说明
default V merge(K key, V value, BiFunction remappingFunction) 如果 key 与一个非 null 的 v 有关联，那么将该函数应用到 v 和 value 上，如果结果为 null 则删除这个键。否则，将 key 和 value 关联。返回 get(key)
default V compute(K key, BiFunction remappingFunction) 将函数应用到 key 和 get(key)。将 key 与结果关联，或者如果结果为 null，则删除这个键。返回 get(key)
computeIfAbsent 如果 key 为 null 则将函数应用 key 和 get(key)，其余同上
computeIfPresent 如果 key 不为 null 则将函数应用 key 和 get(key)，同上
default void replaceAll(BiFunction remappingFunction) 在所有映射上应用函数。如果结果为 null 则将相应的键删除

弱散列映射 WeakHashMap

当映射中的一个键已经失去存在的价值时，就要将其从映射中删除。但垃圾回收器跟踪活动的对象。自己要映射对象是活动的，其中的所有桶也是活动的，它们不能被回收。因此需要程序负责从长期存活的映射表中删除无用的值，或是使用 WeakHashMap 完成这件事。

和 HashMap 一样，WeakHashMap 也是一个散列表，它存储的内容也是键值对(key-value)映射，而且键和值都可以是null。

不过 WeakHashMap 的键是弱键，当某个键不再正常使用时，会被从WeakHashMap中被自动移除。准确的说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃。

弱键 使用的是 弱引用(weakReference) 保存键，当弱键不再被其它对象引用，并被 CG 回收的同时，这个弱键也会添加到 ReferenceQueue 中。

LinkedHashSet 与 LinkedHashMap

LinkedHashSet 与 LinkedHashMap 类可以用来记住插入元素项的顺序。当条目插入到表中时，就会并入到双向链表中。

枚举类与映射

EnumSet 是一个枚举类元素集的高效实现。

enum Weekday {
     Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

// 可以用静态工厂方法构造这个集
EnumSet<Weekday> always = EnumSet.allOf(Weekday.class);
EnumSet<Weekday> never = EnumSet.noneOf(Weekday.class);
EnumSet<Weekday> workdays = EnumSet.range(Weekday.Monday, Weekday.Friday);
EnumSet<Weekday> rand = EnumSet.of(Weekday.Wednesday,Weekday.Sunday,Weekday.Thursday);

EnumMap 是一个键类型为枚举类的映射。它可以直接高效地用一个值数组实现。使用时需要指定键类型：

EnumMap<Weekday, Employee> personInCharge = new EnumMap<>(Weekday.class);

标识散列映射 IdentityHashMap

并发

线程基本概念

用户每启动一个进程，操作系统就会为该进程分配一个独立的内存空间。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程本身不拥有系统资源，只拥有一点再运行中必不可少的资源，但它可用于同属一个进程的其它线程共享进程所拥有的全部资源。

  • 线程是轻量级的进程
  • 线程没有独立的地址空间(内存空间)
  • 线程是由进程创建的
  • 一个进程可以拥有多个线程
线程状态

Thread类中有一个State枚举类型列举了线程的所有状态

  • New (新创建)
  • Runnable (可运行)
  • Blocked (被阻塞)
  • Waiting (等待)
  • Timed Waiting (计时等待)
  • Terminated (被终止)

调用 Thread.sleep 方法不会创建一个新县城，sleep 是 Thread 类的静态方法，用于暂停当前线程的活动。

线程的创建要继承 Thread 类或者实现 Runnable 接口。

警告⚠️：不要调用 Thread 类或者 Runnable 对象的 run 方法。直接调用 run 方法，只会执行一个线程中的任务，而不会启动新线程。应该调用 Thread.start 方法。这个方法将创建一个执行 run 方法的新线程。

一、继承Thread类
　　编写简单，可直接操作线程
　　适用于单继承
二、实现Runnable接口
　　避免单继承局限性
　　便于共享资源

中断线程

当线程的 run 方法执行方法体中最后一条语句后，并经由执行 return 语句返回时，或者出现了在方法中没有捕获的异常时，线程将终止。

interrupt 方法可以用来请求终止线程。当对一个线程调用 interrupt 方法时，线程的中断状态将被置位。可以调用 isInterrupted 方法判断线程是否被中断。

while (Thread.currentThread().isInterrupted()) 
{
     
    do more work
}

注⚠️： 有两个非常相似的方法，interrupted 和 isInterrupted。Interrupt 方法是一个静态方法，用于检测当前线程是否被中断，并清除该线程的中断状态。而 isInterrupted 方法是一个实例方法，用于与检测是否有线程被中断，且不会改变中断状态。

一点调用 start 方法，线程将处于 runnable 状态。

线程属性

  • 线程优先级
  • 守护线程
  • 线程组

线程优先级

默认情况下，一个线程继承其父线程的优先级。可以用 setPriority 方法提高或降低任何一个线程的优先级。优先级课设为 MIN_PRIORITY(1) 与 MAX_PRIORITY(10) 之间的任何值。但是，线程优先级是高度依赖于系统的。

警告⚠️： 如果有几个高优先级的线程没有进入非活动状态，低优先级的线程可能永远也不能执行。

守护线程

可以通过调用 t.setDeamon(true) 将线程转换为***守护线程***。守护线程的唯一用途是为其它线程提供服务。当线程只剩下守护线程的时候，JVM就会退出。

意义及应用场景

当主线程结束时，结束其余的子线程（守护线程）自动关闭，就免去了还要继续关闭子线程的麻烦。如：Java垃圾回收线程就是一个典型的守护线程；内存资源或者线程的管理，但是非守护线程也可以。

未捕获异常处理机制

多线程运行不能抛出任何受查异常，异常会被直接抛出到控制台，也就是说 try-catch 语句不会执行 catch 部分。

为了在多线程运行中捕获异常，在线程死亡之前，异常会被传递到一个用于未捕获异常的处理器。

该处理器必须属于一个实现 Thread.UncaughtExceptionHandler 接口的类。这个接口只有一个方法 ***void uncaughtException(Thread t, Throwable e)***，例如：

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
     
  @Override
  public void uncaughtException(Thread t, Throwable e) {
     
    System.out.println(this.getClass().toString());
  }
}

可以用 setUncaughtExceptionHandler 方法为任何线程安装一个处理器。也可以用 Thread.setDefaultUncaughtExceptionHandler 方法为所有线程安装一个处理器。例如：

ThreadDemo t1 = new ThreadDemo();
t1.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());   // 为t1安装一个处理器

Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());   // 设置默认处理器

如果不安装默认的处理器，默认处理器为空。但是，如果不为独立的线程安装处理器，次数处理器就是该线程的 ThreadGroup 对象。

同步

在大多数实际的多线程应用中，两个或以上的线程需要共享统一数据的存取。如果两个线程同时操作，可能会产生讹误的对象。这样一个情况通常称为***竞争条件(race condition)***。

竞争条件

在 Java 多线程中，当两个或以上的线程对同一个数据进行操作时，可能会产生竞争条件的现象。

这种现象产生的根本原因是因为多个线程在对同一个数据进行操作，此时对该数据的操作是非“原子化”的，可能前一个线程对数据的操作还没有结束，后一个线程又开始对同样的数据开始进行操作，这就可能会造成数据结果的变化未知。

线程锁

如果在一个线程对数据进行操作的时候，禁止另外一个线程操作此数据，那么，就能很好的解决以上的问题了。这种操作叫做给线程加锁。

class SafeBank {
     
  private Lock bankLock = new ReentrantLock();   // 创建一个锁对象

  private final double[] accounts;

  public SafeBank(int num, double initialBalance) {
     
    accounts = new double[num];
    Arrays.fill(accounts, initialBalance);
  }

  public void transfer(int from, int to, double amount) {
     
    bankLock.lock();   // lock
    try {
     
      System.out.print(Thread.currentThread());
      accounts[from] -= amount;
      System.out.printf("%10.2f from %d to %d ", amount, from, to);
      accounts[to] += amount;
      System.out.printf("Total Balance: %10.2f\n", getTotalBalance());
    }
    finally {
     
      bankLock.unlock();   // make sure the lock is unlocked even if an exception is thrown
    }
  }

  private double getTotalBalance() {
     
    double sum = 0;
    for (double i : accounts) sum += i;
    return sum;
  }

  public final int size() {
     
    return accounts.length;
  }
}

每一个 Bank 对象都有自己的 ReentrantLock 对象。如果两个线程试图访问同一个 Bank 对象，那么锁将以串行的方式提供服务。

ReentrantLock 是可重入锁，synchronized 也是，可重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。

可重入锁的意义之一在于防止死锁。实现原理实现是通过为每个锁关联一个请求计数器和一个占有它的线程。当计数为0时，认为锁是未被占有的；线程请求一个未被占有的锁时，JVM将记录锁的占有者，并且将请求计数器置为1 。如果同一个线程再次请求这个锁，计数器将递增。每次占用线程退出同步块，计数器值将递减。直到计数器为0,锁被释放。

警告⚠️：把解锁操作放在 finally 子句中是非常重要的。如果在临界区的代码抛出异常，锁必须被释放。否则，其它线程将永远阻塞。

注释：如果使用锁，就不能使用带资源的 try 语句。

条件对象

线程进入临界区，却发现在某一条件满足后它才能执行。要使用一个条件对象来实现。利用英航账户资金转出：

if (bank.getBalance(from) >= amount)
    bank.transfer(from, to, amount)   // WARNING!

注意不能使用如上代码，当前线程完全有可能在完成判断后被中断！必须保证没有其它线程在检索余额与转账之间修改余额。可以通过锁来保护检查与转账操作：

public SafeConditionBank(int num, double initialBalance) {
     
    sufficientFunds = bankLock.newCondition();   // 条件对象
    ...
}

public void transfer(int from, int to, double amount) {
     
    bankLock.lock();
    try {
     
        while (accounts[from] < amounts)
            sufficientFunds.await();   // 进入该条件的等待集
        ...
        sufficientFunds.signalAll();   // 解除阻塞
    } catch (InterruptedException e) {
     
        e.printStackTrace();
        finally {
     
            bankLock.unlock();
        }
    }
}

一个锁对象可以拥有多个条件对象。

如果转账的金额大于当前账户的余额，那么条件对象 condition 就 await 等待，直到其他账户先转入给它足够的余额。这里的 condition 是通过 ReentrantLock 的 newCondition 方法构造的。

调用了 condition 的 await 后就会放弃锁，同时等待，进入该 condition 的等待集。一旦有其他线程调用了同一个条件对象的 signalAll 方法后，就会重新激活因为这个条件等待的所有的线程。

调用 signalAll 方法时不是立即激活一个等待线程，而是解除了等待线程的阻塞，让它们继续往下执行。

通常，对 await 的调用应该在如下形式的循环体中☑️：

while (!(ok to proceed))
    condition.await();

另一个方法 ***signal***，则是随机解锁等待集中某个线程的阻塞状态。这比解除所有线程的阻塞更有效，也存在危险。谨防出现死锁！

synchronized 关键字

总结一下锁与条件的关键之处：

  • 锁用来保护代码片段，任何时刻只能由一个线程执行被保护的代码
  • 锁可以管理视图进入被保护代码段的线程
  • 锁可以拥有一个或多个相关的条件对象
  • 每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程

synchronized 作为关键字的作用域由两种:

1、在某个对象实例内，synchronized aMethod(){} 可以防止多个线程访问这个对象的 synchronized 方法。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；

2、某个类的范围，synchronized static aStaticMethod{} 防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

synchronized 代码块

除了方法前用 synchronized 关键字，synchronized 关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

synchronized 的弊端

同步方法，这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象 P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加 了synchronized关键字的方法.同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱:(

若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。

volatile 域

**原子性：**在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

**可见性：**保证被修改的值能立即更新到主存，当其它线程需要读取时，会到内存中读取新值。

有序性： 禁止指令重排序优化，普通的变量仅仅会保证在该方法的执行过程中所有依赖该赋值结果的地方都能获得正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一直。

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

  • 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
  • 禁止进行指令重排序。
//线程1
boolean stop = false;
while(!stop){
     
    doSomething();
}
//线程2
stop = true;

那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

但是用volatile修饰之后就变得不一样了：

  • 使用 volatile 关键字会强制将修改的值立即写入主存
  • 使用 volatile 关键字当线程2修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效
  • 由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

volatile 关键字⚠️无法保证原子性，但能在一定程度上保证有序性。

final 变量

对于final域，编译器和处理器要遵循两个重拍序规则：

  • 在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。

  • 初次读一个包含final域的对象的应用，与随后初次读这个final域，这两个操作之间不能重排序。

死锁

所谓*死锁(deadlock)*是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

线程局部变量

线程间有时要避免共享变量，可以使用 ThreadLocal 辅助类为各个线程提供各自的实例。

例如，SimpleDateFormat 类是线程不安全的：

public static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

如果两个线程都执行以下操作：

String dateStamp = dateFormat.format(new Date());

结果可能会很混乱，因为dateFormat使用的内部数据结构可能会被并发的访问所破坏。或者也可以在需要时构造一个局部SimpleDateFormat对象，不过这也太浪费了。

要为每个实例构造一个实例，可以使用以下代码：

public static final ThreadLocal<SimpleDateFormat> dateFormat = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

在一个给定线程中首次调用get时，会调用initialValue方法。在此之后，get方法会返回属于当前线程的那个实例。

锁超时

线程在调用lock方法来获得另一个线程所持有的锁的时候，很可能发生阻塞。应该更加谨慎地申请锁。try Lock方法试图申请一个锁，在成功获得锁后返回true,否则，立即返回false，而且线程可以立即离开去做其他事。

读 / 写锁

ReentrantReadWriteLock 类

阻塞队列

阻塞队列（BlockingQueue）是一种队列，一种可以在多线程环境下使用，并且支持阻塞等待的队列。和一般队列的区别在于：

  • 多线程环境支持，多个线程可以安全的访问队列
  • 支持生产和消费等待，多个线程之间互相配合，当队列为空的时候，消费线程会阻塞等待队列不为空；当队列满了的时候，生产线 程就会阻塞直到队列不满。
方法/处理方式 抛出异常 返回特殊值 一直阻塞 超时退出
插入方法 add(e) offer(e) put(e) offer(e,time,unit)
移除方法 remove() poll() take() poll(time,unit)
检测方法 element() peel() 不可用 不可用

JDK7 提供了 7 个阻塞队列。分别是

名称 描述
ArrayBlockingQueue 一个由数组结构组成的有界阻塞队列。(底层是数组)
LinkedBlockingQueue 一个由链表结构组成的有界阻塞队列。(底层是链表)
PriorityBlockingQueue 一个支持优先级排序的无界阻塞队列。
DelayQueue 一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue 一个不存储元素的阻塞队列。
LinkedTransferQueue 一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque 一个由链表结构组成的双向阻塞队列

线程安全的集合

早期线程安全的集合有：Vector、HashTable。

Java SE 8 的流库

流提供了一种让我们可以在比集合更高的概念级别上指定计算的数据视图。

从迭代到流的操作

例如我们对长单词进行计数操作，我们通常会遍历它的元素，并在每个元素上执行某项操作。但是我们可以使用流进行更高效的操作：

String[] strings = {
     "11", "22", "###"};
List<String> list = Arrays.asList(strings);
long count = list.stream().filter(w -> w.length() >= 3).count();

仅将 stream 修改为 parallelStream 就可以让流库以并行方式来执行过滤和计数。

long count = list.parallelStream().filter(w -> w.length() >= 3).count();

流看起来和集合很类似，都可以让我转换和获取数据。但是，它们之间存在着显著的差异：

  • 流并不存储其元素。这些元素可能存储在底层的集合中，或者是按需生成的。
  • 流的操作不会修改其数据源。
  • 流的操作是尽可能惰性操作的。

流的创建

Collections 接口的 stream 方法可以将任何集合转换为一个流。

如果你有一个数组，那么可以使用静态的 Stream.of 方法转换为一个流：

Stream<String> words = Stream.of(list);

使用 Arrays.stream(array, from, to) 可以从数组 from 到 to 的元素创建一个流：

String[] strings = {
     "11", "22", "###"};
Stream<String> words = Arrays.stream(strings, 1, 3);

创建不包含任何元素的流，可以使用静态的 Stream.empty 方法：

Stream<String> silence = Stream.empty();

Stream 接口有两个用于创建无限流的静态方法，generate 与 iterate 方法。generate 方法接受一个不包含任何引元的函数(Supplier 接口)，通过反复调用函数生成一个无限流：

Stream<String> echos = Stream.generate(() -> "Echo");
// 或者像下面这样获取一个随机数的流
Stream<String> randoms = Stream.generate(Math::random);

为了产生无限序列例如1 2 3…，可以使用 iterate 方法。它会接受一个“种子”以及一个函数(UnaryOperation)，并且会反复讲该函数应用到之前的结果上：

Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

filter、map 和 flatMap 方法

filter 的引元是 Predicate ，即从 T 到 boolean 的函数。filter 转换会产生一个流，它的元素与某种条件相匹配。

map 类似 Python 中的 map() 函数，参数接受一个转换函数，会讲每一个函数应用到每个元素上，通常我们可以用 lambda 表达式替代：

Integer[] k = {
     4, 6, 8, 10};
System.out.println(Arrays.toString(Arrays.stream(k).map(w -> w / 2).toArray()));

抽取连接流和子流

方法 描述
Stream limit(long maxSize) 产生一个包含当前六中最初的 maxSize 个元素的流
Stream skip(long n) 产生一个除了前 n 个元素之外的元素的流
static Stream concat(Stream a, Stream b) 产生一个连接前后两个流的流

其它的流转换

方法 描述
Stream distinct() 流去重
Stream sorted()
Stream sorted(Comparator comparator) 产生一个可以对元素排序的流
Stream peek(Consumer action) 产生一个一模一样的流，但是会对每一个元素调用一个函数，对于调试来说很方便

简单约简

约简是一种终结操作(terminal operation)，它们会将流约简为可以在程序中使用的非流值。

例如 count 方法 还有 max min 等。这些返回的都是一个类型为 Optional 的值，它要么包装了答案，要么表示没有任何值。例如获得流中的最大值:

Optional<String> largest = words.max(String::compareTo);
System.out.println("Largest: " + largest.orElse(""));
方法 描述
Optional max(Comparator comparator) 分别产生这个流的最大和最小元素，由比较器定义排序规则，如果这个流为空，则产生一个空的 Optional 对象
Optional min(Comparator comparator) 这些操作都是终结操作
Optional findFirst() 分别产生这个流的第一个和任意一个元素，如果这个流为空，则产生一个空的 Optional 对象
Optional findAny() 这些操作都是终结操作
boolean anyMatch(Predicate predicate) 分别在这个流中任意元素、所有元素、没有元素匹配时返回true
boolean allMatch(Predicate predicate) 这些操作都是终结操作
boolean noneMatch(Predicate predicate)

Optional 类型

Optional 对象是一种包装器对象，要么包装了类型T，要么没有包装对象。对于第一种情况，我们称这种值为存在的。Optional 类型被当作一种更安全的方式来代替类型 T 的引用，这种引用要么引用某个对象，要么为 null/但是只有在正确使用的情况才更安全。

方法 描述
T orElse(T other) 产生这个 Optional 的值，若空返回other
T orElseGet(Supplier other) 产生这个 Optional 的值，若空返回调用 other 结果
T orElseThrow(Supplier exceptionSupplier) 产生这个 Optional 的值，若空返回抛出 exceptionSupplier 的异常
void ifPresent(Consumer consumer 如果 Optional 不为空，则将值传递给 consumer
map

未完待续。。。

你可能感兴趣的:(Java,java)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • sql统计相同项个数并按名次显示 朱辉辉33 javaoracle
    现在有如下这样一个表： A表 ID Name time ------------------------------ 0001 aaa 2006-11-18 0002 ccc 2006-11-18 0003 eee 2006-11-18 0004 aaa 2006-11-18 0005 eee 2006-11-18 0004 aaa 2006-11-18 0002 ccc 20
  • Android+Jquery Mobile学习系列-目录 白糖_ JQuery Mobile
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。   从现在起，往后一段时间，我打算
  • 如何给线程池命名 daysinsun 线程池
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：     public class Named
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the 周凡杨 html解析errorreadyState
      错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"     现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
  • java上传 g21121 java
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 下面是servlet的代码： //定义一个磁盘文件工厂 DiskFileItemFactory fact
  • SpringMVC配置学习 510888780 springmvc
    spring MVC配置详解 现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
  • spring mvc-jfreeChart 柱图(1) 布衣凌宇 jfreechart
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 第二步：配置web.xml; web.xml代码如下 <servlet>     <servlet-name>jfreechart</servlet-nam
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
  • java 线程池使用 Runnable&Callable&Future antlove javathreadRunnablecallablefuture
    1. 创建线程池 ExecutorService executorService = Executors.newCachedThreadPool();   2. 执行一次线程，调用Runnable接口实现 Future<?> future = executorService.submit(new DefaultRunnable()); System.out.prin
  • XML语法元素结构的总结 百合不是茶 xml树结构
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
  • 改变eclipse编码格式 bijian1013 eclipse编码格式
    1.改变整个工作空间的编码格式         改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。         Eclipse->window->preferences->General->workspace-
  • javascript中return的设计缺陷 bijian1013 JavaScriptAngularJS
    代码1： <script> var gisService = (function(window) { return { name:function () { alert(1); } }; })(this); gisService.name(); &l
  • 【持久化框架MyBatis3八】Spring集成MyBatis3 bit1129 Mybatis3
    pom.xml配置 Maven的pom中主要包括： MyBatis MyBatis-Spring Spring MySQL-Connector-Java Druid applicationContext.xml配置   <?xml version="1.0" encoding="UTF-8"?> &
  • java web项目启动时自动加载自定义properties文件 bitray javaWeb监听器相对路径
    创建一个类 public class ContextInitListener implements ServletContextListener 使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 <listener> <des
  • 用nginx区分文件大小做出不同响应 ronin47
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大 bylijinnan java
    package com.ljn.base; import java.util.Arrays; import java.util.Random; public class ContinuousPoker { /** * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。 * 2-10为数字本身，A为1，J为1
  • 翟鸿燊老师语录 ccii 翟鸿燊
    一、国学应用智慧TAT之亮剑精神A 1. 角色就是人格     就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。     还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
  • [光速与宇宙]进行光速飞行的一些问题 comsci 问题
         在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家     仅仅是猜想。。。未经官方证实      1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
  • oracle undo解析 cwqcwqmax9 oracle
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 Undo是干嘛用的？         &nb
  • java中各种集合的详细介绍 dashuaifu java集合
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
  • 卸载windows服务的方法 dcj3sjt126com windowsservice
    卸载Windows服务的方法 在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist dcj3sjt126com iosxcode
        http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html Excerpt: You are getting this warning because you probably added your Info.plist file to your Copy Bundle
  • 2014之C++学习笔记（一） Etwo C++EtwoEtwoiterator迭代器
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
  • js跨越获取数据问题记录 haifengwuch jsonpjsonAjax
    js的跨越问题，普通的ajax无法获取服务器返回的值。   第一种解决方案，通过getson，后台配合方式，实现。 Java后台代码： protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String ca
  • 蓝色jQuery导航条 ini JavaScripthtmljqueryWebhtml5
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
  • linux部署jdk,tomcat,mysql kerryg jdktomcatlinuxmysql
    1、安装java环境jdk:     一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。    1.1）、卸载：      （rpm -qa :查询已经安装哪些软件包；        rmp -q 软件包：查询指定包是否已
  • DOMContentLoaded VS onload VS onreadystatechange mutongwu jqueryjs
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 2. onload是最早支持的事件，要求所有资源加载完毕触发。 3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
  • sql批量插入数据 qifeifei 批量插入
    hi，   自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。    WITH tempT AS ( SELECT item_id AS combo_id, item_id, now() AS create_date FROM a
  • log4j打印日志文件 如何实现相对路径到 项目工程下 thinkfreer Weblog4j应用服务器日志
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 需求： 用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
  • linux下mysql-5.6.23.tar.gz安装与配置 笑我痴狂 mysqllinuxunix
    1.卸载系统默认的mysql [root@localhost ~]# rpm -qa | grep mysql mysql-libs-5.1.66-2.el6_3.x86_64 mysql-devel-5.1.66-2.el6_3.x86_64 mysql-5.1.66-2.el6_3.x86_64 [root@localhost ~]# rpm -e mysql-libs-5.1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他