JDK 是如何更新的

自从2017年后，JDK就疯狂刷版本号，大家之呼:“别更新了，学不动了”。2017年 Oracle 确认 Java 的发布频率改为每六个月一次。之前的 Java 发布周期为每两年一次，但是，常常因为一些特性未完成等，一直延期，例如 JDK 8 延期了 8 个月，JDK 9 延期了 18 个月。为了避免不断的延期，故修改更新策略，新版本的发布不会等到某个主要的特性完成，而是将该特性并入到下一个版本，并且严格按照时间点就行版本发布，每年的 3 月和 9 月就是新版本的发布月。

同时Oracle提供了长期支持版本 LTS， JDK 8 就是一个LTS版本，支持日期到2025年。而继 JDK 8 之后，JDK 11 为下一个LTS，支持日期到2026年。

下面总结一些 JDK 更新的重要特性，毕竟每次更新的东西太多了。

JDK 9

JDK 9 是 JDK 8 时隔 三年半之后才发布的新版本，因为模块特性而一再延期。

module

这是 JDK 9 中的一个重要特性，通过module我们可以指定 jar 包中那些类是可以被访问的，那些类是不可以被外部访问的。同时减少了 Jar 包打包的大小。即使是 public 也不意味着可以被外部包所访问。

module 通过在 src 下的 module-info.java 进行定义。

例如 定义了 student 和 teacher 两个模块。如果我需要在 main 模块中使用这两个模块，首先要在 main 引入所需要的 module。

module main {
    requires teacher;
    requires student;
}

之后要在 student 和 teacher 模块中导出我们需要的 package。

// student module

module student {
    exports top.young.student;
}

// teacher module 
module teacher {
    requires student;
    exports top.young.teacher;
}

这样才完成了一次 module 之间的调用。

同时 JDK 也被拆分成了 94 个模块，通过 jlink 工具，创建出包含依赖的 JDK 自定义的运行时镜像，极大的减少了 Java 的 runtime 的大小。

Jshell

Jshell 的添加可是 Javaer 的福音，实现一个小的想法再也不需要写一坨无关的代码了。Jshell 是一个 REPL 工具，即 读取(R) 执行(E) 输出(P) 再循环(L)。Jshell 启动也是非常方便的，只要在终端输入 jshell 即可打开。

Stream

JDK 8 的时候添加了 Stream 流进行操作，而 JDK 9 的时候又添了4个函数。这 4 个函数分别为 dropWhile、 takeWhile 、``ofNullable、iterate`。

dropWhile

dropWhile 是读取流中的元素，当满足条件是将元素丢弃，不满足条件时结束。

public class Main {
    public static void main(String[] args) {
        Stream.of(6,4,7,9,2,1).dropWhile(it -> it >= 3).forEach(System.out::println); // 2 1
    }
}

takeWhile

同样 takeWhile 是从流中读取元素，满足条件时获取，不满足条件结束。

public class Main {
    public static void main(String[] args) {
        Stream.of(6,4,7,9,2,1).takeWhile(it -> it >= 3).forEach(System.out::println); // 6 4 7 9
    }
}

ofNullable

对 Null 流元素进行过滤，防止发生 NPE

public class Main {
    public static void main(String[] args) {
      Stream.of(6, 4, null, 9, 2, 1).flatMap(Stream::ofNullable).forEach(System.out::println);//6 4 9 2 1
    }
}

iterate

该方法对指定初始种子进行创建，每次按照 next 的规则进行更改，直到条件满足 hasNext。

public class Main {
    public static void main(String[] args) {
        Stream.iterate(3, x -> x < 10, x -> x + 3).forEach(System.out::println);// 3 6 9
    }
}

响应式流

说起响应式编程大家一定不陌生，毕竟之前有 Rx 系列一直在做，而 JDK 9 加入了 java.util.concurrent.Flow。

Flow 包含了4个核心接口： Flow.Publisher、Flow.Subscriber、Flow.Subscription 和 Flow.Processor 。

其他

更多的 JDK 9 更新内容可以查看 JDK9 官方更新日志

JDK 10

JDK 10 是

var 类型推断

终于可以用 var 来做类型推断了，注意 var 并不是关键字，而是保留的类型名称。比如我们这样写也是对的 var var = 6;。

但是 var 声明类型只在以下情况中使用：

• 声明的同时赋值
• 再 for 循环中。

对 Unicode 进行扩展

改善了 java.util.Locale类和相关API以外的实现。尤其是对货币类型，一周第一天等信息的支持。

并行全垃圾回收器 G1

G1 垃圾回收器是 Java 9 中 Hotspot 默认的垃圾回收器，为了最大限度地减少 Full GC 造成的应用停顿响应，所以 Java 10 为 G1 引入了多线程并行 GC。

JDK 11

jdk 11 是目前的最新的 lts。也是大部分公司即 JDK1.8 之后开始使用的另一个 JDK 版本。JDK 11 语法上没有较大的新特性变化。主要变化在安全特性和性能更新。

HTTP Client 标准化

在 JDK 9 提出后，JDK 10 更新，JDK 11 标准化。

kotlin 对集合问题的支持很好，有很多方法可以方便又直观的对集合进行操作。比如 map，count，reduce，filter等方法，这个博客会持续总结些方法。

any

any 这个函数返回值是一个 boolean 类型，用于判断集合内元素是否用满足条件的，如果有任意一个集合满足该条件，则返回 true 否是为 false。

示例代码

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val l = list.any {
        it > 30
    }
    println("判断结果为 $l")
}

输出结果为

判断结果为 true

这里的 it 可以理解为 iterator 既为集合中的每个元素。之后有很多函数都是对 it 进行操作。

all

all 几乎和 any 很相似，只是用于判断每个元素，要集合内每个元素满足条件才会返回ture，否则为 false

示例代码

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val l = list.all {
        it > 30
    }
    println("判断结果为 $l")
}

判断结果为 false

map

map 这个函数对集合内的每一个元素进行迭代遍历，基本可以替代for循环。

示例

fun main(args: Array<String>) {

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)

    list.map {
        print("$it ")
    }
}

输出结果为：

1 2 4 67 7 23 55 34

这样就完成了对集合的迭代输出。

filter

顾名思义，filter为一个过滤器，可以对我们集合元素进行一次过滤，留下我们想要的元素。 例如我们要集合中的偶数元素。

示例代码

fun main(args: Array<String>) {

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)

    list.filter { it % 2 == 0 }.map { print("$it ") }
}

输出

2 4 34

完成了对偶数元素的过滤，结合map进行一下输出。如果我们不用filter和map进行输出，那么我们将会写下下面的这种代码，而且 IDEA 也会给我们警告，让我们及时改进。

    for (i in 0 until list.size) {
        if (list[i] % 2 == 0) {
            print("${list[i]} ")
        }
    }

此时就会感觉到了这些语法对于代码的简洁和易用。

count

即使对集合元素进行统计，如果直接使用 count() 对集合元素统计和直接用 size 没有什么区别，所以说 count 有更加高级的用法。

比如对集合内的某个元素进行统计或者某种类型的元素进行统计，比如统计集合中偶数的个数。

fun main(args: Array<String>) {
    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34)
    val count = list.count {
        it % 2== 0
    }
    println("集合中的偶数个数为 $count")
}

输出

集合中的偶数个数为 3

groupBy

这个用于分组，对元素进行按要求分组，最后的结果也会保存在两个集合中， true 和 false

示例代码

对奇偶数进行分组

    val list: List<Int> = listOf(1, 2, 4, 67, 7, 23, 55, 34) //sum = 193
    val result = list.groupBy {
        it % 2 == 0
    }
    println("$result")
}

输出结果

{false=[1, 67, 7, 23, 55], true=[2, 4, 34]}

扩展函数和扩展属性在 Java 里面是没有的，这样的话很好的弥补了 Java 的缺陷。所谓扩展方法或者属性是指在原来没有的方法或者属性上进行扩展，不会改变原来的属性和方法。

扩展函数

声明扩展函数的方法是先写上要扩展的类名，之后在写扩展方法。

对 Book 这个类进行扩展，这个类只有一个方法，在我们不修改 Book 类的前提下对其进行扩展。

class Book(val name: String, var price: Int) {
    val ISBN: Int = 123456789
    fun add() {
        println("Add a book,name is $name,price is $price,ISBN is $ISBN")
    }
}

fun Book.show() = add()

这样我们便完成了对 Book 类进行扩展。

在扩展函数中，可以使用原有类的方法，变量。

fun main(args: Array<String>) {
    val book = Book("红楼梦", 50)
    book.show()
}

扩展是静态解析的
扩展不能真正的修改他们所扩展的类。通过定义一个扩展，你并没有在一个类中插入新成员， 仅仅是可以通过该类型的变量用点表达式去调用这个新函数。

扩展属性

扩展属性不能初始化器,所以只能是使用显示 get/set 方法进行定义。

任就采用上面的例子。给 Book 添加一个 profit 属性。

像这个样子，我们就定义了这个类的扩展属性

val Book.profit: Int
    get() = price - 20

fun main(args: Array<String>) {
    val book = Book("红楼梦", 50)
    book.show()
    println("book's profit is ${book.profit}")
}

更多关于扩展函数/方法的例子可以参考官方网站

kotlin官方文档(中文)

kotlin官方文档(英文)

感受

关于 Kotlin 的最大的感受就是：代码少写了很多。

相遇

最开始知道这个语言是在使用 IDEA 的时候，当时只是知道，并没有过多的关心，也并没有去了解，更不要说是使用了。直到今年的 Google I/O 提出来 Kotlin 被上升到 Android 开发的一级开发语言。整个互联网沸腾了一把，大家纷纷百度 Kotlin 是什么？当然也包括我。

相识

Kotlin 的学习使我感觉到了欣喜，为什么这么说呢？语法简洁，和 Java 基本兼容。也就是 Kotlin 一出生便是站在 Java 的肩膀上。很好的融入了 Java 生态，基本上说 Java 能做的 Kotlin 都能做，而且在代码方面更加简洁高效。

从 Kotlin 诞生开始，便有了 JetBrains 的编译器支持，毕竟是自己家的语言，而且 IDEA 也一直宣传做 Capable and Emic IDE rgonofor JVM ，而且目前还有了 Google 的支持。前两天 Jake Wharton 加入了 Google 的 Android Formwork 的 Kotlin 团队。 就当前情况看来 Kotlin 会有一个不错的发展。

相遇

前面说了 Kotlin 从一诞生就有强大的编译器支持。刚刚开始不会 Kotlin 的时候，全靠 IDEA 的 Java 转 Kotlin

通过对比 Java 和 Kotlin 的语法，也就慢慢的掌握了 Kotlin 的语法规则。

后来开始使用 Kotlin 写了一下 struts2,表示完全兼容。

尝试用 Kotlin 写了一下 SpringMVC 4 应该是不兼容或者是我的打开方式不对， 在 Controller 发生错误，不过其他层并没有错误。好的是 Spring 5 已经支持 Kotlin 。

在 Android 方面(并没有使用 Anko)，只是简单的使用了扩展。

apply plugin: 'Kotlin-android-extensions'

再也不用写 findViewById(),直接用控件 id 就可以完成操作。

其他

慢慢尝试一些 黑魔法 😝

待补充(毕竟我也才开始慢慢学习)

学习资源推荐

官方文档(英文)

官方文档(中文)

冰封博客

Kotlin 社区

一个简单的 Python 爬虫，用于爬取斗鱼网上的图片。

• 编辑工具：Visual Studio Code
• Python 版本：2.7
• 使用的库：urllib

Visual Studio Code插件

• Code Runner
• Python
• Python for VSCode
• MagicPython

实现思路

首先要打开地址，并且获取该网页的代码。

从代码里获得你要图片。这里我们需要简单的分析一下该网页。

当我们把鼠标移到地址上的时候就会出现该图片，这个就是我们要爬取的图片。

这个图片是在 data-original 后面，我们就需要进行匹配，通过正则表达式很快就可以达到目的。

网页代码片段

<img data-original="https://rpic.douyucdn.cn/a1704/03/15/1032029_170403155245.jpg" src="https://rpic.douyucdn.cn/a1704/03/15/1032029_170403155245.jpg" width="283" height="163" style="display: block;">

正则表达式 data-original="(.*?\.(jpg|png))

这样我们就获取到了这个页面上所有的 jpg 和 png 图片。

最后通过 urlretrieve 这个方法把图片保存到你想要放的地方。

代码

# coding:utf8
import urllib
import re
import time
 # 通过filename设置路径和名字
response=urllib.urlopen('https://www.douyu.com/directory/game/TVgame')
html=response.read()
print html
imglist=re.findall(r'data-original="(.*?\.(jpg|png))"',html)
print imglist
x=0
for imgurl in imglist:
    print ('下载图片 %s'%imgurl[0])
    if imgurl[1]=='gif':
        urllib.urlretrieve(imgurl[0],filename='G:\PythonCode\pic\%d.gif'%x)
    else:
        urllib.urlretrieve(imgurl[0],filename='G:\PythonCode\pic\%d.jpg'%x)
    x+=1
    time.sleep(1)

ArrayList 是我们常用的一种数据结构。仔细分析 ArrayList 这个类和类所包含的方法。

签名

ArrayList继承了AbstractList 和使用了List RandomAccess Cloneable和Serializable四个接口。

AbstractList该接口的作用是用于 AbstractList 提供了 List 接口的默认实现，在AbstractList中已经使用了List接口，为什么还会在ArrayList中使用的List接口，目测是为了让大家更加明白清楚的知道这个类是List这个集合。 RandomAccess 是

变量

ArrayList只有两个私有变量，分别是size和elementData。 elementData这个是来记录传入ArrayList的元素。而size是用来记录传入的元素的个数。

构造器

该类里面一共有三个构造器

• ArrayList()
• ArrayList(int)
• ArrayList(Collection)

下面就详细的分析一下三个构造器的使用。

ArrayList()

ArrayList无参的构造器,使用这个无参构造器会默认有一个长度为10的数组。

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

ArrayList(int)

传入一个int值，这个值为ArrayList的初始容量。如果等于0则会默认使用EMPTY_ELEMENTDATA生成一个空的集合。如果输入为非负数的话会抛出一个IllegalArgumentException(非法参数)异常。

     public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

ArrayList(Collection)

这个构造函数是传入一个集合,toArray是将这个集合转化为一个实际的数组，下面的程序就是和传入int类型是差不多的，判断数组长度是否为0，如果等于0则会默认使用EMPTY_ELEMENTDATA生成一个空数组。在不为空的时候，将Collection的值copy到ArrayList。

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

方法

trimToSize()

该方法主要是用于将ArrayList实际容量调整为列表当前大小。这里它实用了一个三目运算**? :**。

• modCount这个变量在AbstractList这个类里面,其中定义int这个变量使用了transient。

protected transient int modCount = 0;

transient 当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中。

• 三目运算和if else的区别，三目运算是会有一个返回值的，if else没有返回值。如果非要写成if else应该也可以。

 public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

ensureCapacity()

如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 DEFAULT_CAPACITY=10是一个常量

public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }

indexOf()

返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

contains()

如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

lastIndexOf()

lastIndexOf用于返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 这里if和else里面采用了两种不同的比较方法。if代码块里面是采用了==说明比较的是对象，而else的代码块采用的是equals比较。为什么这里采用两种比较方法呢？

这里产生一个疑问？

null是对象还是值？

正在技术论坛上提问

Keywords

50 character sequences, formed from ASCII letters, are reserved for use as keywords and cannot be used as identifiers (§3.8). Keyword: one of

 abstract  continue   for          new         switch
 assert     default    if           package     synchronized
 boolean    do         goto         private     this
 break      double     implements   protected   throw
 byte       else       import       public      throws
 case       enum       instanceof   return      transient
 catch      extends    int          short       try
 char       final      interface    static      void
 class      finally    long         strictfp    volatile
 const      float      native       super       while

The keywords const and goto are reserved, even though they are not currently used. This may allow a Java compiler to produce better error messages if these C++ keywords incorrectly appear in programs. While true and false might appear to be keywords, they are technically Boolean literals (§3.10.3). Similarly, while null might appear to be a keyword, it is technically the null literal (§3.10.7).

在这个50个关键字中没有null，但是下面的一行字写了。

While true and false might appear to be keywords, they are technically Boolean literals (§3.10.3). Similarly, while null might appear to be a keyword, it is technically the null literal (§3.10.7).

虽然true和false可能看起来是关键字，但它们在技术上是布尔值（§3.10.3）。类似地，虽然null可能看起来是一个关键字，但在技术上是null值（§3.10.7）。

java的官方文档里写着true,false,null是一个值，也就是说java有50个关键字，3个特殊的值。 竟然是值，为什么在比较的时候会报错？

public class Main {
    public static void main(String[] args) {
        String a = null;
        String b = null;
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

输出结果

        true
    Exception in thread "main" java.lang.NullPointerException
    	at Main.Main.main(Main.java:14)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
    
    Process finished with exit code 1

第二个方法抛出一个空指针异常。 竟然是一个值，那么应该两种都会显示ture。

这样也就说明了为什么和null比较时要用==而不是equals。

public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
       

clone()

返回此 ArrayList 实例的浅表复制。（不复制这些元素本身。）

什么是浅表复制(shallow copy) 对于shallow copy的翻译很多，有叫浅表复制，浅复制，影子复制，与它向对的是深度复制。 浅表复制 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象

   /**
     * Returns a shallow copy of this <tt>ArrayList</tt> instance.  (The
     * elements themselves are not copied.)
     *
     * @return a clone of this <tt>ArrayList</tt> instance
     */
 public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

add(E)

该方法是用于添加将指定元素添加到末尾，通过ensureCapacityInternal()这个方法来为ArrayList扩容，在为elementData的末尾添加指定元素。代码的注释也强调了，是增加modCount。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

add(int,E)

这个方法的一开始就调用了rangCheckForAdd()这个方法，这个私有方法主要是用来判断传入的索引，如果传入的数值大于最大值或者小于零会抛出一个越界异常。System.arraycopy()是用来复制数组的，将要添加位置之后的数组整体后移一位。

public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    
private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

remove(Object)

移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。

public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

clear()

通过一个循环将ArrayList中的元素赋值为null，最后将size赋值为0，这样应该就会保证没有浪费内存。

 public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

ListIterator()

用于集合遍历，如果索引大于最大值或者小于0，抛出异常，否者使用ListItr()进行。

public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

ListItr()

这是一个私有的内部类，继承了Iterator这个接口，

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

replaceAll()

这个方法是用来替换所有的匹配项

传入的参数是UnaryOperator是在java 8引入的lambda表达式，具体如何使用以后再说。

   public void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

sort()

 public void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

作者

wevan youngxhui

概况

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

签名

    public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

可以看到StringBuilder继承了

1. Serializable：可以序列化的标志。
2. CharSequence接口：包含了charAt()、length() 、subSequence()、toString()这几个方法，String类也实现了这个接口。
3. 抽象类AbstractStringBuilder，这个类封装了StringBuilder和StringBuffer大部分操作的实现

CharSequence接口

这个接口是代表一个有序字符集合，使用该接口的方法一共有四个：CharBuffer、String、StringBuffer、StringBuilder。

AbstractStringBuilder类

变量及构造方法

    char[] value;
    int count;
    AbstractStringBuilder() {}
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

AbstractStringBuilder内部用一个char[]数组保存字符串，可以在构造的时候指定初始容量方法。

append()方法

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

append()方法用于追加字符，如果str是null,则会调用appendNull()方法。这个方法其实是追加了’n’、‘u’、’l’、’l’这几个字符。如果不是null，则首先扩容，然后调用String的getChars()方法将str追加到value末尾。最后返回对象本身，所以append()可以连续调用。

Stringbuilder构造器

StringBuilder()

这个构造器的作用是构造一个初始化不带参数的，初始化字节为16字节。

StringBuilder(int)

构造一个其中不带字符的字符串生成器，初始容量由传入的 int 值指定。

StringBuilder(String)

构造一个字符串生成器，并初始化为指定的字符串内容。该字符串生成器的初始容量为 16 加上字符串参数的长度。

public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

如果传入的字符串问 null 则会抛出空指针 NullPointerException 异常。

示例代码

public class StringBuilderApi {
    public static void main(String[] args) {
        String str=null;
        StringBuilder stringBuilder=new StringBuilder(str);
        System.out.println(stringBuilder);

    }
}

输出结果

Exception in thread “main” java.lang.NullPointerException at java.lang.StringBuilder.(StringBuilder.java:112) at StringBuilderApi.main(StringBuilderApi.java:7) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)

StringBulider(CharSequence)

构造一个字符串生成器，包含与指定的 CharSequence 相同的字符。该字符串生成器的初始容量为 16 加上 CharSequence 参数的长度。

append()方法

该方法一共用13个重载函数,用于实现不同的数据类型。Object,String,StringBuffer,CharSequence,char[],boolen,int ,long,float,double 等,但是他们的作用是一直的。那就是将参数添加到字符串中。

    public StringBuilder append(String str) {
    super.append(str);
    return this;
    }
    public StringBuilder append(CharSequence s) {
    super.append(s);
    return this;
    }

Stringbulider的appen()方法显然直接调用的父类AbstractStringBuilder中的该方法。

appendCodePoint()方法

该方法是附加一个Uncode字符在字符串末尾。

 /**
     * @since 1.5
     */
    @Override
    public StringBuilder appendCodePoint(int codePoint) {
        super.appendCodePoint(codePoint);
        return this;
    }

delete()方法

该方法是删除所字符串中的字符，所传入的参数为其实点和结束点。直接使用父类(AbstractStringBuilder)的方法

 /**
     * @throws StringIndexOutOfBoundsException {@inheritDoc}
     */
    @Override
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }

toString()方法

toString()方法返回了一个新的String对象，与原来的对象不共享内存。

    public String toString() {
    // Create a copy, don't share the array
         return new String(value, 0, count);
    }

replace()方法

replace 方法仍旧继承了父类的 replace 方法,是替换字符

     public StringBuilder replace(int start, int end, String str) {
            super.replace(start, end, str);
            return this;
        }

insert()方法

该方法是插入字符串。该方法重载了12个方法。

总结

该类所有的方法都是通过父类( AbstractStringBuilder )来实现。该方法与String和StringBuffer的区别在于，String是不可修改的，StringBuffer和StringBuilder是可以修改的，但是StringBuffer是线程安全的，StringBuilder是线程不安全的，但是在效率上， StringBuffer 因为对方法做了同步，所以一般是低于 StringBuilder的.

将方法或类声明为final主要目的是：确保它们不会再子类中改变语义。String类是final类，这意味着不允许任何人定义String的子类。换言之，如果有一个String的引用，它引用的一定是一个String对象，而不可能是其他类的对象。——《Java核心技术 卷I》作者：R eversal

链接：https://www.zhihu.com/question/31345592/answer/51639967 来源：知乎 著作权归作者所有，转载请联系作者获得授权。

String不可变性及其原因

String的不可变性

什么叫String的不可变性呢？让我们来看一个例子。
​ String s=“abcd“；
上面的语句定义了一个字符串变量s，该变量指向字符串“abcd”，当初始化变量s时，会在堆中为s非配内容空间，当将字符串变量，赋值给另一个字符串变量时，例如：String s2=s； 此时，s2和s是相同的字符串对象，它们指向堆中的同一个内存空间。
当一个字符串连接其他字符时，他就指向了新的字符串对象，例如，s=s.concat(“ef“）， 此时，s=“abcdef”;它在内存中又指向了一个新的储存空间，存放字符串"abcdef”。
当一个字符串在堆中被分配内容时，它就是不可变的，任何String的方法都无法改变字符串本身，但它可以返回一个新的字符串对象。
由于String是不可变的，所以他们的空间可以共享。例如String str = “abc”;就和
JAVA ​ char data[] = {‘a’, ‘b’, ‘c’};
​ String str = new String(data);

是等价的，它们共享一个存储空间。如果需要可以修改的字符串对象，可以使用StringBuffer和StringBuilder，StringBuffer是线程安全的，由于StringBuilder不需要进行同步操作，StringBuilder是比较快速的。

• String不可变性的原因
  • 源码中String的本质是一个final类型的char数组，既然是final类型，那个该数组引用value就不允许再指向其他对象了，因此只从类的设计角度讲：如果jdk源码中并没有提供对value本身的修改，那么理论上来讲String是不可变的
  • 字符串池（String pool）的需求 在Java中，当初始化一个字符串变量时，如果字符串已经存在，就不会创建一个新的字符串变量，而是返回存在字符串的引用。 例如： String string1=“abcd”; String string2=“abcd”; 这两行代码在堆中只会创建一个字符串对象。如果字符串是可变的，改变另一个字符串变量，就会使另一个字符串变量指向错误的值。
  • 缓存字符串hashcode码的需要 字符串的hashcode是经常被使用的，字符串的不变性确保了hashcode的值一直是一样的，在需要hashcode时，就不需要每次都计算，这样会很高效。
  • 出于安全性考虑 字符串经常作为网络连接、数据库连接等参数，不可变就可以保证连接的安全性。

签名（signature）

    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence

String使用了

• 标记接口 java.io.Serializable
• 标记接口 Comparable
• 标记接口 CharSequenc

Compareable接口

public interface Comparable<T> {
    public int compareTo(T o);
}

此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo 方法被称为它的自然比较方法 。

CharSequence接口

CharSequence的所有成员变量和方法。

成员变量

• private final char value[];//这是用于存储String字符的数组
• private final int offset;//这是value数组的第一个有效的字符的index
• private final int count;//这是String中的字符个数
• private int hash; // 存储String的hashcode，默认是0
• private static final long serialVersionUID = -6849794470754667710L;//在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常

源码剖析

构造器

String类的构造器有十六个，除了提供了一个无参构造函数之外，还有十五个带参构造器。

String()

 public String() {
        this.value = "".value;
    }

初始化一个新创建的 String 对象，使其表示一个空字符序列。注意，由于 String 是不可变的，所以无需使用此构造方法

String(String)

    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

初始化一个新创建的 String对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。由于 String 是不可变的，所以无需使用此构造方法，除非需要 original 的显式副本。

String(char)

public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。该字符数组的内容已被复制；后续对字符数组的修改不会影响新创建的字符串。

String(char,int,int)

public String(char value[], int offset, int count) {
    public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

作用为分配一个新的value，将传入的char数组进行一次复制，offset是开始索引位置，count表示数组长度。

String(int,int,int)

public String(int[] codePoints, int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= codePoints.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > codePoints.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }

        final int end = offset + count;

        // Pass 1: Compute precise size of char[]
        int n = count;
        for (int i = offset; i < end; i++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                continue;
            else if (Character.isValidCodePoint(c))
                n++;
            else throw new IllegalArgumentException(Integer.toString(c));
        }

        // Pass 2: Allocate and fill in char[]
        final char[] v = new char[n];

        for (int i = offset, j = 0; i < end; i++, j++) {
            int c = codePoints[i];
            if (Character.isBmpCodePoint(c))
                v[j] = (char)c;
            else
                Character.toSurrogates(c, v, j++);
        }

        this.value = v;
    }

方法

checkBounds()方法

private static void checkBounds(byte[] bytes, int offset, int length) {
        if (length < 0)
            throw new StringIndexOutOfBoundsException(length);
        if (offset < 0)
            throw new StringIndexOutOfBoundsException(offset);
        if (offset > bytes.length - length)
            throw new StringIndexOutOfBoundsException(offset + length);
    }

这是一个私有的静态方法用于检查边界的方法。

length()方法

获得长度的方法

 public int length() {
        return value.length;
    }

isEmpty()方法

检查字符串长度是否是0，当长度为0返回true，否则返回false。

 public boolean isEmpty() {
        return value.length == 0;
    }

charAt()方法

该方法返回的值为char数组中的其中一个。

 public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

codePointAt()方法

用于返回指定索引处的字符，与codePointBefore方法类似，codePointBefore返回的的是索引之前的值

codePointAt

public int codePointAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return Character.codePointAtImpl(value, index, value.length);
    }

codePointBefore

public int codePointBefore(int index) {
        int i = index - 1;
        if ((i < 0) || (i >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return Character.codePointBeforeImpl(value, index, 0);
    }