目录

1.String、StringBufer、StringBuilder

1.1 String

1.2 StringBuffer、StringBuilder

1.3 Efficiency

2. Interface and abstract class

3. 运算符

3.1. 移位运算符

4. List

4.1. ArrayList的扩容机制

 框架学再多，基础甚至底层都不会有什么用哟。面试的时候就只能说我会用框架，一问理论、底层就懵逼了。原来我只是会用，仅仅会用。自学了那么多框架，结果面试都过不了。多么嘲讽的。大学刚毕业的那时候，没有人告诉你需要做什么？虽然之前在某公司IT部独立负责三个项目的二次开发，依旧没能遇到引路人。就这样当条咸鱼，偶尔学学框架敲敲代码，甚至连BAT也没有想过。没有一点点的挣扎就随便选了一家公司然后开始了。

现在想来甚是后悔，就应该在大一的时候开始想要做什么？要学什么？要去哪里？然后开始准备了。

那就从现在开始，开始复习开始刷题吧！希望一年后能遇到更好的自己。

1.String、StringBufer、StringBuilder

String是只读字符串，典型的Immutable对象，对它的任何改动。起手都是创建一个新对象，再把引用指向该对象。String对象赋值操作后，会在常量池中进行缓存。如果下次引用的时候，该对象已经存在就会直接调用缓存池中。StringBuffer则是可以在原对象上进行修改，是线程安全的。StringBuffer和StringBuilder都是继承了AbstractStringBuilder。该抽象类也是以字符数组的形式存储字符串。StringBuilder线程不安全，但是效率比StringBuffer高。

1.1 String

String对象是不可变，也是不可继承的。如下源码中String是被final所修饰的。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Omit resource code ……  . */
}

String 为不可变对象,一旦被创建,就不能修改它的值. . 对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

String中的对象是不可变的，也就可以理解为常量， 显然线程安全 。

1.2 StringBuffer、StringBuilder

StringBuffer、StringBuilder都是继承AbstractStringBuilder类。

在AbStaractStringBuiler中使用字符数组保存字符串。可知这两种对象都是可变的。

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;
    /** Omit resource code ……  . */
}

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

/** --------StringBuffer Resource code-------------- */
public StringBuffer(int capacity) {
    super(capacity);
}
public StringBuffer() {
    super(16);
}

 StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象 , 它只能通过构造函数来建立,  如： StringBuffer sb = new StringBuffer();

不能通过赋值符号对他进行付值. ， 如 sb = "welcome to here!";//error

对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer中赋值的时候可以通过它的append方法.      sb.append("hello");

StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

/** --------StringBuffer Resource code-------------- */
@Override
public synchronized int length() {
    return count;
}

@Override
public synchronized int capacity() {
    return value.length;
}

@Override
public synchronized void ensureCapacity(int minimumCapacity) {
    super.ensureCapacity(minimumCapacity);
}
/** --------Omit Resource code-------------- */

StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。 

使用场景：1. 操作少量数据: String  2. 操作大量数据、单线程: StringBuilder  3. 操作大量数据、多线程: StringBuffer

1.3 Efficiency

如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。  

效率比较String < StringBuffer < StringBuilder，但是在String S1 =“This is only a”+“simple”+“test”时，String效率最高。

2. Interface and abstract class

参考CSDN文档：https://blog.csdn.net/aptentity/article/details/68942916 

参考CSDN文档：https://blog.csdn.net/Speed_Pig/article/details/71628368?locationNum=3&fps=1（1.8特性）

3. 运算符

3.1. 移位运算符

用最有效率的方式计算2乘以8

2  〈〈  3 

常见的JDK源码里面HashMap默认容量 16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 = 1 * 2^4

直接二进制操作，表示1 左移4位，低位补0，即10000转化二进制位16。

在代码编写中，尽量使用移位运算符。虽然 DEFAULT_INITIAL_CAPACITY =16可能更直观！

栗子：

<< ：左移运算符，num<< 1,不区分正负数，低位补0，相当于num*2
        4 << 1  // aka  4 * 2^1  = 8
        5<< 4  // aka  5 * 2^4  = 64
>> ：右移运算符，num>>1,如果该数为正，则高位补0，若为负数，则高位补1
        64 >> 1  // aka 64 / 2    32
       64 >> 2   // aka 64 / ( 2 ^ 2) 16

4. List

4.1. ArrayList的扩容机制

注意：JDK1.7之前ArrayList默认大小是10，JDK1.7后是0

未指定集合容器，默认为0。若已指定大小则为所指定集合大小。当集合第一次添加元素时候，集合大小扩容为10。ArrayList的元素个数大于其容器，扩容的大小 = 原始大小 + 原始大小/2

首先认识ArrayList的重要变量：

数组每次新增时候，都会使用ensureCapacityInternal确保数组容量，使用该方法进行容量判断。之后将新增的元素添加到数组中，size++。

ensureCapacityInternal将判断委托给calculateCapacity获取当前容器所需最小的容量。（一般我写代码都是用放一起然后接收，再传参给下个函数，没有多处使用，这样想来一点都不好。要抽出公共代码模块）

扩容的实现方法grow方法：

Java运行三部曲：编写，编译，运行
编写：硬件编写代码，就是我们写代码
编译：javac将文件编译成一个或多个.class文件
编译中间的过程主要是类型和格式的检查。
如: Person.java ->词法分析器-〉语法分析器-〉语义分析器-〉字节码生成器
字节码包括class文件相关信息，java源码中的声明和常量信息（元数据），源码中的语句和表头
JVM和Java语言本身没什么关系，JVM只和class文件有关系，其他语言也能具有class文件。
运行:运行字节码文件
加载:将类文件中的字节码加载到JVM内存中
解释执行:逐行执行
类加载器：类加载(类加载)是一种机制，描述的是将字节码以.class文件的形式加载到内存，再经过连接、初始化后，最终形成可以被JVM直接使用的java类型的过程，这个过程只有在运行期才会触发，所以会牺牲一些程序启动的性能，但是却可以提供更高的灵活度。
类加载必经的五个过程:
加载，连接(校验，准备，解析)，初始化，使用，卸载。
可以使用-verbose:class方法查看ClassLoader加载过程。
Class是所有类的模板
类是实例的模板
加载loading
概念:加载过程就是将class文件中的字节码‘bytecode’一行一行读入JVM内存中的方法区，但不会执行。
通过类全名来获取定义这个类的二进制字节流，这部分工作由类加载器完成。
将这个字节流所代表的静态存储结构，转化成方法区中运行时数据结构。
在堆中生成一个对应的‘java.lang.Class’对象，作为方法区中这个类的各种数据的访问入口。
JVM在加载数组的时候为了提高效率，减少重复加载（数组中类型统一且固定)，加载的是数组的类型，多维数组也是递归加载类型，直到发现非数组类型停止，而数组的创建由JVM直接完成。
提示：基本数据类型和引用数据类型的加载过程没有差别，因为在编译阶段，基本数据类型就会被封装成对应的包装类。
int a ----方法区中 ：Integer class
连接linking
概念:连接又分为三个步骤:验证、准备和解析
验证(Verification):检查被加载的类是否有正确的内部结构，包括代码是否正确，类与类之间的关系是否合理等，这与编译时期的检查不同。
准备(Prepanation):为类的静态成员（包括属性和方法）分配内存，并设置初始值（比如null、0、false等).
解析（Resolution):将类的二进制数据中的符号引用(字面量）替换为直接引用(内存地址)。
符号引用(Symbolic References):符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，在class文件中表示我和你的关系，比如全路径名，方法名称等，只要是能无歧义地定位到目标即可。符号引用与JVM内存无关，引用的目标不一定加载到内存中，在Java中，一个类将会编译成一个class文件，在编译时，java类并不知道所引用的类的实际地址，只能用一些符号来替代，各种JVM实现的内存布局可能不一样，但是它们能接受的符号引用是一致的，因为符号引用的字面量明确定义在JVM规范的class文件格式中。
直接引用可以是直接指向目标的指针，比如指向java.lang.Class，指向静态方法，指向静态属性等，还可以是相对偏移量，比如指向属性变量，属性方法等，还可以是一个可以间接定位到目标的句柄。直接引用和JVM布局是相关的，同一个符号引用在不同的VM上翻译出来的直接引用一般会不相同，如果有了直接引用，那引用的目标必定已经被加载到内存中了。总之，直接引用是在JVM中使用内存地址的形式来表示我和你的关系。
例如：
private static String name
属性和局部变量区别?
属性有初始值，不赋值可以使用。
局部变量没有初始值，不赋值不可以使用

总结:
A.java通过javac编译之后，会形成A.class和B.class（存在于硬件中）
变量b中存的到底是什么?是一个符号“我引用了com.joe.pojo.B类"
类运行时，A和B才被加载到内存中，A分配到内存地址为ex0011，B分配到内存地址为ex0012
B类有了真正的内存地址后，再将之前的符号引用"我引用了com.joe.pojo.B类"转成直接引用ex0012，这个过程就是符号,、引用转成直接引用的过程。
类加载过程
加载:在JVM的方法区中，创建一个对应的instanceKlass区域，然后将class文件中的字节码内容逐行加载对应的instanceKlass中，然后在堆中创建一个对应instanceKlass的Class对象（称为instanceKlass的Java镜像）中。
连接-校验:检查class对象中的代码是否正确。
连接-准备:为类的静态属性和方法分配内存，并设置初始值。
连接-解析:将class对象中的符号引用转成直接引用。
初始化:为类的静态属性赋真正的值，执行静态块。
类加载的触发条件
假设我是一个类，那么:
有人new我的时候，我会被加载，连接，初始化。
有人访问我的静态成员（属性和方法）的时候，我会被加载，连接，初始化。
有人反射，克隆，反序列化我的时候，我会被加载，连接，初始化。
一个类在每次被使用前，都会先检查是否被加载，连接，初始化过:
如果已经被加载，连接，初始化过，则直接使用。
如果仍未被加载，连接，初始化过，则先去执行加载，连接，初始化。

实例创建方式：
类加载完成之后，才允许根据类来new对应的实例，在new的时候会使用到方法区中对应instanceKlass对象的数据信息。
new的过程就是为实例分配一块连续的堆内存空间过程，方式有两种:
指针碰撞:分配内存空间包括开辟一块新的内存和移动指针两个步骤。
空闲列表:分配内存空间包括开辟一块新的内存和修改空闲列表两个步骤。
-new实例的过程是非原子的，可能会出现并发问题（两个线程争抢到同一块内存），JVM采用CAS乐观锁的方式来解决:
-赵四为某个实例进行new操作，申请到一块内存0x9527，开始操作，查看版本号为000.
-刘能为某个实例进行new操作，申请到同块内存0x9527，开始操作，查看版本号为000.
-赵四操作完成，再次查看版本号，仍为000，提交操作，将版本号更改为001。
-刘能操作完成，再次查看版本号，发现版本号变为了001，放弃这次操作，去申请其他内存。
-最终结果永远不会有两个线程申请到同块内存。
除了CAS乐观锁的方式可以解决并发问题，JVM还提供了一种本地线程额缓冲内存的方式，即每个线程在Java堆中都先提前分配一小块内存区域，称为本地线程分配缓冲T-LAB，各线程给实例分配内存时会在该线程的T-LAB上进行分配，这样各个线程即可互不影响。
扩展——悲观锁：正如其名，具有强烈的独占和排他特性。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。
实例储存模式：
概念: 在JVMN中，实例在内存中的存储也是很有规律的，存储的布局可以分为三块区域:
（1）对象头区:object Header
存储对象的原数据信息，包括对象运行时数据和类型指针（指向方法区的类型实例)
存储Mark Word，包括对象自身的运行时数据，如它的哈希码和它在GC中分代的年龄、锁状态表示，线程持有锁，偏向锁ID，偏向锁时间戳等信息。
如果是数组对象，还多了一个数组长度。
（2）实例数据区:Instance Data
存储真正有效的数据，即在程序中定义的各种类型的字段数据，这部分数据有一部分是从父类中继承下来的，也有在子类中定义的，总之都要被记录下来。
各字段的分配策略为long/double，int、short/char，byte/boolean，相同宽度的字段总是被分配到一起，便于之后取数据。
（3）对齐填充区:Padding
对齐填充并不一定是必然存在的，因为HotSpot虚拟机内存管理的要求是给实例分配内存的大小必须是8字节的整数倍，所以不够的部分需要填充。又因为对象头部分正好是8字节的倍数，所以对齐填充实际上补全的是实例数据区域，对齐填充的数据并没有特殊的含义，仅仅是起到填充占位符的作用

实例调用方法
*概念:*在不同的虚拟机中，对象的访问方式也是不同的，主流的访问方式有使用句柄和直接指针两种。
（1）使用句柄:是一种间接使用指针访问实例的方式，因为它需要先在Java堆中划分出一块内存区域作为句柄池。栈中的变量存储的是句柄池中稳定的句柄的地址，而句柄中包含的才是Java堆中的实例和对应的java.lang.Class各自的具体地址。
-使用句柄访问方式的最大好处是栈中的变量存储的是稳定的句柄地址，在实例被移动时只会改变句柄中的类型数据指针，而栈中变量本身不需要被修改。
-直接指针:栈中的变量直接存储的是实例的地址。
-使用直接指针访问方式的最大好处就是速度更快，它节省了一次指针定位的的时间开销。- HotSpot实现中采用的是本方式。

博主是刚刚学习到集合的小白，如有谬误，请及时在评论区更正，以免误导他人。

迭代器的使用

package Test;

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

public class Test7 {
    public static void main(String[] args) {
        // 创建一个集合对象
        ArrayList a1 = new ArrayList();
        // 向集合中添加数据
        a1.add(100);      // 自动装箱就不多说了。
        a1.add(500);
        a1.add(300);
        a1.add(true);
        a1.add("hello world!");
        // 创造集合对象的迭代器对象，并利用迭代器对象进行迭代/遍历集合
        Iterator iterator = a1.iterator();
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
    }
}

迭代器疑问

  大家在刚开始接触迭代器时，应该都会有些疑问：
  一、Iterator是个接口，为什么接口可以接收对象？接口不是不能new对象吗？
  二、Java中的API帮助文档中显示，java.util.ArrayList.iterator()方法返回的竟然是一个接口！

知识储备

一、Iterator接口

二、多态
  多态：父类型的引用指向子类型的对象。
三、工具及快捷键
  工具：IDEA
  快捷键：ctrl+点击变量名  快速定位源码
      ctrl+F12         查看当前类中的所有内容
 
通过IDEA工具我们可以快速查找源码，功能十分强大，推荐各位使用！

迭代器原理

第一步： ctrl+点击上方代码中的iterator()方法，跳转至java.util.ArrayList.iterator()源码位置。

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     * The returned iterator is fail-fast
     * return an iterator over the elements in this list in proper sequence
     */
     // 我百度了下翻译
     // 按正确顺序遍历此列表中元素的迭代器
     // 返回的迭代器是fail fast。
     
    public Iterator<E> iterator() {
        return new Itr();
    }
    

  百度翻译的英文，真的看不懂，不过没关系，我们此时见到了ArrayList.iterator()的源码，调用iterator()其实就是new了一个Itr()对象。
  那么问题又来了，为什么在源码中返回值类型是 “Iterator接口” ，返回的是个 “Itr类” 却不报错？
  基础扎实的人可能很快就会想到Java的多态机制，我们此时可以得出Itr类中实现了Iterator接口的结论，接下来我们去Itr类中验证我们的结论。

第二步： ctrl+点击上方代码中的Itr()构造方法，跳转至java.util.ArrayList.java文件下的Itr类中Itr()源码位置。

    private class Itr implements Iterator<E> {
    	// 方法体
    	// 内容就不写了
    }

  此时我们看到Itr类实现了Iterator接口，验证了我们的结论，也就是说Iterator接口中的方法Itr中都有。

第三步： 查看Itr类中的方法，ctrl+F12
  

  看图可知：在ArrayList类中还有Itr类，也看到了Itr类实现Iterator接口的方法，当然还有其他的类，这里不做讨论。

结论

        Iterator iterator = a1.iterator();     //其实就是下方的代码扩展。
//      Iterator iterator = new Itr();           运用多态机制，表面上是Iterator接口的对象，实际是Itr类的对象

启发

  一、我们以后遇到接口接收对象时，应该就是运用了多态。
  二、遇到不懂的问题，不如直接看看源代码，毕竟看不懂也没啥损失，万一看懂了呢?

如有谬误，请务必告知，以免误导他人
如果各位看官觉得写得不错，对你有帮助，能不能给个赞啊，这是对我最大的鼓励！