1.String StringBuffer StringBuilder 区别？

String 字符串常量，StringBuffer 字符串变量（线程安全），StringBuilder 字符串变量（非线程安全）。

String 是不可变的对象, 常量池中只会维护一个值相同的String 对象，对于“ ”内容为null 的常量字符串，会创建一个长度为0，内容为空的字符串放入常量池中。当调用String 类的intern（）方法时，若常量池中已经包含一个等于此String 对象的字符串（用 Object 的 equals 方法确定），则返回池中的字符串，否则将此 String 对象添加到池中，并返回此 String 对象在常量池中的引用。

Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区。可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。StringBuffer 内部实现是char 数组，默认初始化长度为16，每当字符串长度>char 数组长度时，JVM 会构造更大的char 数组，并将原先的数组内容复制到新数组。

java.lang.StringBuilder此类提供一个与 StringBuffer 兼容的 API，StringBuffer方法上都加了synchronized，StringBuilder没有，不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。它比 StringBuffer 要快。

2.泛型，即参数化类型，泛型擦除：Java 编译器生成的字节码文件不包含有泛型信息，泛型信息将在编译时被擦除，这个过程称为泛型擦除。其主要过程为1）将所有泛型参数用其最左边界（最顶级的父类型）类型替换；2）移除all 的类型参数。

3.多态：父类引用指向子类对象，对于static，编译运行都看左边。

4.数组VS 链表——数组在内存中连续，链表不连续。数组可以随机访问，链表顺序访问。数组查询方面，链表插入和删除方便。

5.Int 和 integer：1）只要 int 和 integer 比较，integer 就自动拆箱；

6.Hash:把任意长度的输入，通过散列算法，变换成固定长度的输出。不同的输入可能导致相同的输出。作用：文件校验，数字签名，hash 表查找O(1)。

7.Java8 新特性:

1）接口的默认方法，java 8  允许我们给接口添加一个非抽象方法，只需使用default 关键字。2）lambda 表达式，在java8 之前，若想将行为传入函数，仅有的选择是匿名类，而定义行为最重要的那行代码，却混在中间不够突出。lambda 表达式取代了匿名类，编码更清晰。3）函数式接口：指仅仅只有一个抽象方法的接口，每一个该类型的lambda 表达式都会被匹配到这个抽象方法。每一个lambda 表达式都对应一个类型，通常是接口类型，我们可以把lambda 表达式当作任意只包含一个抽象方法的接口类型，为了确保接口一定达到这个要求（即有一个抽象方法），你只需要给你的接口加上@FunctioalInterface 注释（编译器若发现标注了这个注释的接口有多于一个抽象方法，则报错）。4）lambda 作用域，在lambda 表达式中访问外层作用域和老版本的匿名对象中的方法很相似，你可以直接访问标记了final 的外层局部变量或实例的字段以及静态变量。lambda 表达式对外层局部变量只可读不可写，对类实例变量可读也可写。5）dateAPI：java8 在java.time 包中包含一组全新日期API。6）annotation 注释，java8 支持可重复注解，相同的注解可以在同一地方使用多次。

8.Synchronized

在java 设计中，每一个对象自打娘胎里出来就带了一把看不见的锁，即monitor 锁。

 1）同步代码块使用monitorenter 和moniterexit 指令实现，monitorenter 指令插入到同步代码块的开始位置，moniterexit 指令插入到同步代码块的结束位置，jvm 需要保证每一个monitorenter 都有一个moniterexit 与之对应。任何对象都有一个monitor 与之相关联，当且一个monitor 被持有之后，他将处于锁定状态。线程执行到monitor 指令前，将会尝试获取对象所对应的monitor 所有权，即尝试获取对象的锁。

2）同步方法。依靠的是方法修饰符上的ACC_SYNCHRONIZED 实现。Synchronized 方法则会被翻译为普通的方法调用和返回指令，比如invokevirtual 指令，在jvm 字节码层面并没有任何特别的指令来实现。synchronized 修饰的方法，而是在class 文件的方法表中将该方法的access_flags 字段中的synchronized 标志位置为1，表示该方法为synchronized 方法，且使用调用该方法的对象or该方法所属的class 在jvm 内部对象表示作为锁对象。

Monitor 是线程私有的数据结构，每一个线程都有一个可用monitor record 列表，同时还有一个全局可用列表。每一个被锁住对象都会和一个monitor 关联。Monitor 中有一个owner 字段存放拥有该对象的线程的唯一标识，表示该锁这这个线程占有。Owner：初始时为null，表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时，又设为null。Entry Q：关联一个系统互斥锁，阻塞all 试图锁住monitor entry 失败的线程。Next：用来实现重入锁的计数。

可重入锁：同一线程，外层函数获得锁所之后，内层递归函数仍有获得该锁的机会但不受影响。Synchronized 和reentrantlock 都是可重入锁。

锁主要有4 中状态：无锁状态、偏向状态、轻量级状态、重量级状态。他们会随着竞争的激烈而逐渐升级，锁可以升级但不可以降级。

自旋锁、自适应自旋锁、锁消除。锁消除的依据是逃逸分析的数据支持。锁粗化：将多个连续加锁解锁操作链接起来扩展成一个范围更大的锁。

轻量级锁：传统的锁是重量级锁，他是用系统的互斥量来实现。轻量级锁的本意是在没

有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。

偏向锁：目的是消除数据在无竞争情况下的同步原语。如果说轻量级锁是在无竞争的情况下使用CAS 操作去消除同步使用的互斥量，那么偏向锁就是在无竞争的情况下把整个同步消除掉。

Synchronized 用的锁时存在java 对象头里。对象头包含标记字段和类型指针。类型指针是对象指向它类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。标记字段用于存储对象自身运行时数据，他是实现轻量级锁和偏向锁的关键。

JVM 可以通过对象的元数据信息确定对象的大小，但是无法从数组的元数据来确定数组的大小。

ClasscastException：当试图将对象强制转换为不是实例的子类时，抛出该异常。

Collections 类中提供了一个方法，返回一个同步版本的hashmap，该方法返回的是一个synchronized Map 的实例，synchronized Map 类是定义在Collections 中的一个静态内部类。它实现map 接口，并对其中的每一个方法通过synchronized 关键字进行了同步控制。但synchronized Map 在使用过程中不一定线程安全。

9.内部类一共有4 种1）成员内部类：外部类的成员。2）局部内部类。3）静态内部类：类似于静态成员。4）匿名内部类：实现一个接口or 继承一个抽象类。

外部类不能任意访问内部类的成员，要做到这一点，外部类必须创建其内部类的对象（静态内部类除外）。内部类可以访问all 外部类的成员，因为内部类就像是一个类的成员。

10.Java 本地方法：该方法的实现是由非java 写的，可以用java 调用c 或c++的代码，这是出于性能的考虑or 访问底层操作系统。

11.Java 反射：可以在运行时获取类or 对象的相关信息。

一个类可以有一个or 多个静态代码块。静态代码块在类被加载时执行，优于构造函数的执行，并且按照各静态代码块放在类中的顺序执行。

12.字符和字节：字节是一种计量单位，表示数据量多少，他是计算机信息技术用于计量存储容量的一种单位。字符：计算机中使用的文字和符号。不用编码里，字符和字节对应关系不同。1）ASCII    中，一个英文字母（不论大小写）占一个字节，一个汉字占2 个字节。2）UTF-8，一个英文1 个字节，一个中文，3 个字节。3）unicode ，中文、英文都是两个字节。

13Java 的包有:java.io；java.net；java.lang；java.util；java.awt；java.sql；javax.swing；java.math（javax 开头的都是扩展包）。

14.正则表达式 \\\\ \\+ \\d \\  

X? 0 次或1 次

X+ 1 次或多次

X* 0 次或多次

X{n} 恰好n 次

X{n，} 至少n 次

X{n,m} 至少n 次，至多m 次

Pattern p=Pattern.copmile(正则表达式)；Macher m=p.matcher(要匹配的String)；

组是用括号划分的正则表达式，可用组的编号来引用组，组号为0 为整个组，组号为1

表示第一对括号。

15.System.arraycopy(object[] src,int I, object[] desc,int j,int len)：从src 数组复制到desc 数组，从src 的i 位置复制len 个元素，从desc 的j 位置开始放。基本数据类型就放值，引用数据类型就复制地址，不支持自动拆箱或装箱，两个类型必须一致。

16.Arrays.equals()比较两个数组是否相等，必须元素个数相同，并且对应位置元素相同（用

equals()来比），int 变为integer。

Collection 的reverseOrder()方法返回一个比较器。 

17.Java 接口的修饰符只可以是abstract 和public。

18.Integer.parseInt(s,x);s 是需要转换的字符串，x 为按什么进制2，10 ，16 ，8，默认是

10。

19.RandomAccessFile：用来访问那些保存数据记录的文件，可用seek 方法访问记录，并进行读写，这些记录的大小不必相同，但其大小和位置必须可知。该类仅限操作文件。

RandomAccessFile 不属于InputStream 和outputStream 系列，直接继承自object。

RandomAccessFile 构造函数，两种模式：1）“r”，只读，不会创建文件，会去读一个已存在的文件，若文件不存在则抛异常2）“w 读写模式，若操作的文件不存在，则自动创建，若存在也不会覆盖。

20.copyOnWriteArrayList 和copyOnWriteSet 从一开始大家都在共享同一个内容，当某个人想要修改这个内容时，才会真正的把内容copy 出去，形成一个新的内容后再改。比如：当我们往一个容器添加元素时，不直接往当前容器添加，而是先将容器进行copy，复制出一个新容器，再往新容器里加元素。添加完之后，再将原容器引用指向新容器。好处：对

copyOnWrite 容器进行并发读时，不需要加锁，因为当前容器不会增加新元素，读写分离。

copyOnWriteArrayList 的add 方法要加锁，否则多线程的时候会copy N 个副本。

copyOnWrite    容器不会抛出并发修改异常，并且返回的元素与迭代器创建时的元素完全一致，而不必考虑之后修改操作带来的影响，当迭代操作远大于修改操作时适用。

copyOnWrite 适合于读多写少的场景，但他只能保证数据最终一致性，不能保证实时一致性。若你希望写入马上被读到，不要用copyOnWrite 容器。

21.Queue 上的操作不会阻塞，如果队列为空，那么获取元素的操作返回空。BlockingQueue 扩展了Queue，增强了可阻塞的插入和获取等。若队列对null，那么获取元素的操作将一直阻塞，直到队列中出现一个可用的元素；若队列已满（对于有界队列来说），那么插入元素的操作将一直阻塞，直到队列中有可用空间。Deque 和BlockingDeque 为双端队列，可以在队列头和尾插入删除，在生产者-消费者中，所有消费者有一个共同的工作队列。而在工作密取设计中，每个消费者都有自己的双端队列。若一个消费者完成了自己双端队列中的全部工作容，那么他可以从其他消费者双端队列末尾秘密的获取工作。大多数情况下，消费者只访问自己的双端队列，从而极大减少竞争，而且访问别人双端队列时是从末尾开始取，进一步减小竞争。

22.ConcurrentHashmap  允许一边迭代，一边更新，不会出现并发修改异常。也就是说，在用iterator 遍历时，ConcurrentHashmap 也可以进行remove、put 操作，且遍历的数据会随着remove、put 发生变化，（弱一致性）。Concurrentmap   中以下功能：若没有则添加，若相等则移除，若相等则替换，且都为原子性。

23.Java 的序列化算：1）当前类的描述2）当前类属性的描述3）父类描述4）父类属性描述5）父类属性值描述6）子类属性值描述类描述是从下到上，类属性描述是从上到下。

24.CAS：Compare and swap 。Java.util.concurrent 包完全建立在cas 上，没有cas 就不会有此包。Cas 有3 种操作数：内存值V，旧的预期值A 和要修改的新值B。当且仅当预期值A 和内存值V 相同时，将内存值V 改为B，返回V。CAS 通过调用JNI 的代码实现。

25.加载发生于创建的第一个对象之时，但是当访问static 变量或static 方法时也会发生加载。初次使用之处也是static 初始化发生之处，所有static 对象和static 代码都会在加载时按程序中的顺序（定义类时的书写顺序）而依次初始化。当然，定义为static 的东西只会被初始化一次。private 不能被继承。

将一个方法调用同一个方法主体关联起来叫做绑定。java 中除了static 方法和final 方法，其他所有方法都是动态绑定。

private 方法默认为final 的，private 方法不能被覆盖。

26.初始化：初始化顺序：1）成员变量默认初始化2）调用基类的构造器，一层一层调用3）按声明顺序调用成员的初始化方法4）调用子类构造器主体。

27.jdk1.8bin 目录下的东西Java.exe javac.exe Javadoc.exe jar.exe jstack.exe (打印所有java 线程堆栈跟踪信息)

jdk 和jre 区别？jdk 的bin 下有javac，jre 的bin 下没有javac。面向对象和面向过程的区别？（过程）优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗源;比如嵌入式开发、Linux/Unix 等一般采用面向过程开发，性能是最重要的因素。缺点：没有面向对象易维护、易复用、易扩展。

（对象）优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统。缺点：性能比面向过程低。

jdk 中的设计模式：1）单例，比如Runtime 类；2）静态工厂Interger a=Integer.valueOf(int or String);3) 迭代器模式Collection.interator();4) 原型设计模式,clone 方法；5 ）适配器

在jdk1.8 之后，hashmap 中，若链表长度太长（默认为8）时，链表转为红黑树。

Jdk1.5 泛型、自动拆箱/装箱，foreach、枚举、线程池；jdk1.7switch  中用string、菱形语法。

28.进程VS 程序——程序，一段代码，一组指令的有序集合。进程：程序的一次动态运行，通过进程控制块唯一的标识这个进程。进程：动态，有资源，有唯一标识，有并发性；程序：

静态，无资源，无唯一标识，无并发性。

并行：两个或多个事件，在同一时刻发生。并发：两个或多个事件，在同一时间间隔发生。

进程基本状态：县城：比进程更小的独立运行单位，同一进程中可有多个线程并发执行。线程：cpu 调度基本单位。进程：cpu 分配资源基本单位。

29.抽象类和接口应用场景——1）标记接口：什么抽象方法都没有。2）需要实现特定的多项功能，而这些功能之间完全没有联系。3）定义了一个接口，但又不想强迫每个实现类都必须实现所有抽象方法，所以可以用抽象类来实现一部分方法体，比如adapter。抽象类是简化接口的实现，它不仅提供了公共方法的实现，让我们可以快速开发，又允许你的类完全可以实现所有的方法，不会出现紧耦合的情况。

30.常见的runtimeException：空指针、数组越界、类型转换，除零、并发修改异常，rejectedExecutionException。

31.基本数据类型double 在判断相等时，为什么不可以用==？答案：存储精度问题，一般使用阈值，a-b 小于这个阈值，一般就认为相等。

32.编码：字符只以一种形式存在，那就是Unicode（不选择任何特定的编码，直接使用他们在字符集中的编号，这是统一的唯一的方法）。在java 中指：在JVM 中，在内存中，在你的代码里声明的每一个char，string 类型的变量中。Reader 和Writer 类使用的是GBK 编码。

33.基本类型：类型由低到高为（byte，short，char）--int--long--float--double

byte，short，char 相同级别，不能相互转换，但可以使用强制类型转换

六个包装类：Float，Double，Byte，Short，Int，Long，Character，Boolean

Java 中float 默认0.0f，double 默认0.0d

String 对象一旦被创建，就不可以改变

Java.util.regex 使用正则表达式来实现模式匹配。

34.类

main 方法必须是public 的，public static void main() 是对的，static void main(String [] args) 是错的，因为默认为protected 的、不论java 的参数类型是什么，一律传递参数额副本，若java 是传值，那么传递的是值的副本，若传递的是引用，则传递的是引用的副本。

在Java 中，有事会遇到子类中的成员变量or 方法和父类同名的情况。因为子类中的成员变量or 成员方法的优先级高，所以子类中的同名成员变量or 方法就隐藏了父类的成员变量or 方法，但父类同名的成员变量or 方法仍然存在，可用super 显示调用。

Java 中的大数类。BigInteger1）该类在java.math 包中2）他的其中一个构造器为new BigInteger(String s) ,将BigInteger 的十进制字符串表示转换为BigInteger，若要将int 型的转为BigInteger，则 BigInteger two=new BigInteger(“2”);双引号不能省略。 BigInteger oneo=new BigInteger(“1”);  one.add(two)  其中 two 必须为 BigInteger 类型，并且 add()方法返回一个BigInteger 对象，其值为3，one 中的值不变。

内部类拥有其外围类的所有元素的访问权，包括private，包括方法和字段。构造内部类对象时，需要一个指向其外围类对象的引用（static 内部类除外），这个引用编译器已经帮你做了。非静态内部类，用外部类对象创建内部类对象：new outer().new Inner();

接口的所有成员（方法+变量），自动被设为public。可以在一个方法里或任意作用域来定义内部类。

每个类都会生成一个class 文件，内部类的class 文件命名为：外部类名$内部类名。若是匿名的，则编译器会简单生成一个数字作为标识符。

Math.ceil(a) 返回>=a 的最小

Math.floor(a) 返回<=a 的最大

Math.round(a) 四舍五入

Byte，short，Int，Long，Float，Double，Character，Boolean 都在java.lang 包中。

Float a=1.0f； 是对的

Float a=1.0；是错的，因为1.0 默认为是double 类型，必须强转为float。

Long 和 float 正常定义要加上 L 和 F byte 的范围是-128 到 127

所有byte，short，char 类型的值将被提高为int 进行计算。被final 修饰的变量不会自动改变类型，当2 个final 修饰的变量操作时，结果根据左边类型而转化。

Java 中数组是对象，不是原生类。

默认值——Boolean-false；char-null；byte-（byte）0；short-（short）0；int-0；long-0L；

float-0.0f；double-0.0d。

System.out 返回PrintStream 对象，println()是该对象中的一个方法。

Javadoc 生成注释文档，只能为 public 和 protected 成员生成注释。赋值 A=4；是对的 4=a 是错的，只能为变量赋值。

编译器通常把指数默认为 double，若要定义为 float，则要加 f。float a=1.43e-13；编译失败。float a=1.43e-13f；编译成功。

Boolean  –exp？value 0：value 1；

若 Boolean  –exp 为 true，则计算 value 0，而且这个计算结果也就是操作符最终产生的；

若 Boolean  –exp 为 false，则计算 value  1，而且这个计算结果也就是操作符最终产生的值。

java 不允许我们使用一个数字作为布尔值。

For(1;;) 1 的位置可以有任意数量的同一类型的定义。构造器没有返回值，与返回空不一样。

只有构造函数才可以调用构造器。

Dog dog=new Dog();这句话的执行过程：1）加载dog 的class 文件。2）初始all 静态（包括static 变量和静态代码块），并且要按照顺序。3）默认初始化。4）显示初始化。5）构造代码块。6）构造函数。

Collection 有iterator 方法，所以list 和set 有。Map 没有，要遍历map，要使用entryset

或keyset。

Treemap 根据键的自然顺序排序。

1)数组转为 list Arrays.aslist 方法，

String[] s={“str1”,”str2”}; ArrayList al=Arrays. Aslist(s);

2)list 转为数组list 的toArray 方法。

可变类型参数 （Object…args）仍是 object 的数组，可用 foreach 遍历。

Package 语句必须是文件中的第一行（除了注释）。

即使一个类只有包访问权限，其 public main 仍然可以访问。

Has-a 组合；is-a 继承。

既是static，又是final 是编译器常量。

Final 初始化只有两个地方：定义处和构造函数。

覆

盖，只有在某方法是基类的接口的一部分时才会出现，即必须能将一个对象向上转型为它的基本类型，并调用相同的方法。若一个方法为private，他就不是

接口的一部分，他仅是一些隐藏于类中的程序代码，只不过具有相同的名称而已。但是若在子类中以相同的名称生成一个public、protected

或包访问权限方法的话，此时并没有覆盖该方法，只是生成了一个新的方法。由于private

方法无法触及，而且能有效隐藏，所以除了把它看成是因为他所归属的类的组织结构的原因而存在外，其他任何事物都不需要考虑到他。

适配器中的代码接受你所拥有的接口，并且产生你需要的接口。

一个类可以实现多个接口，但只能继承一个类，且继承类要写在前面，后面才跟接口，否则编译报错。接口与接口也是继承，接口可以多继承。

35.序列化一个对象？只要让他实现 serializable 接口（该接口没有方法，是一个标记接口）。静态不能被序列化，因为他不在堆里，用 transient 修饰的也不能序列化（即使在堆中），使 用 ObjectInputStream 和 ObjectOutputStream 。

36.浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝休息包含的引用指向的对象。深拷贝不仅拷贝对象，而且拷贝对象包含的引用所指向的对象。比如，对象a1 中包含对象b1 的引用，对象b1 中包含对象c1 的引用，浅拷贝a1 得到a2，则a2 中仍然包含对b1 的引用，b1 中任然包含对c1 的引用。深拷贝是对浅拷贝的递归，若是深拷贝a1 得到a2，则a2 中包含b2（b2 是b1 的copy），b2 中包含c2（c2 是c1 的copy）。

37.存储结构分为4 种。1）随机存取：可以随意直接存取任何一个元素，可以通过下标直接存取任意一个元素，如数组等，有如内存，可以通过地址直接访问任意一个空间。2）顺序存取：只能从前往后逐个访问，如链表。3）索引存取：为某个关键字建立索引，从索引表中得到地址，再直接访问。4）散列存取：建立散列表。

38.优先级队列（PriorityQueue）的头是按指定排序方式确定的最小元素。

39.反射Class.forName(String s)方法返回与带有给定字符串名的类or 接口相关联的class 对象，这将导致命名为s 的类被加载。

40.JAVA IO：

1）RandomaccessFile：用来访问哪些保存数据记录的文件，可以用seek 方法进行访问，并进行读写。这些记录的大小不必相同，但是其大小和位置必须可知，该类仅限于操作文件。

2）RandomaccessFile 不属于inputStream 和outputStream 类系。随机访问文件的行为类似存储在文件系统中的一个大型byte 数组，存在一个光标。

Resultmetadata：可用于获取关于resultset 对象中列的类型和属性信息的对象。创建类实例的方法：1）new 2）class.forname(类全名).newInstance() 3）clone().

41.Java5 个特性：面向对象，跨平台，多线程，健壮性，解释性。

42.java 异常

CheckedException VS Un CheckedException

将派生于 Error 或者 RuntimeException 的异常称为 UnCheckedException，所有其他异常称为 CheckedException 。若出现了 RuntimeException，则一定是程序员自己的问题。

Exception 一般分为IOException 和RuntimeException。

Java 实现封装用的是private。

Fast-fail：java 集合中一种错误检查机制。当多个线程对集合进行结构上的改变的操作时，

有可能会Fast-fail。注意：是有可能，而不是一定。

DeflaterOutputStream 和InflaterInputStream 在java.uti.ip 包下

Blob 对象中的type 属性表示文件的MIME 类型。

除了8 种基本类型以及它们的封装类型，另外还有String 类，会发生深拷贝，其余都是浅拷贝。

String 的contains 和indexof 都可以判断是否有某词。

Class 的getConstructor()返回指定的公有的构造函数；Class 的getDeclaredConstructor()

返回指定的构造函数，私有也可以得到。

可以被序列化：String、数组、Enum、实现了序列化接口（）从WriteObject  方法看出来，这四个可以被序列化。

实现某个接口时，并不需要实现嵌套在其内部的任何接口，且private 接口不能在定义它的类之外被发现。

StringBuffer.append(“123”). append(26).ppend(true).reverse()后变为 eurt62321。

你可以将任意数量的对象放置到容器中，并且不需要担心容器应该设置为多大。使用泛型可以在编译期防止将错误类型的对象放置到容器中。

Collection.reverseOrder（comparator cmp）返回一个比较器，顺序和传入的比较器相反。

高级for 循环可用于数组和任何collection 对象。如果我们创建了任何实现interator 的类，就可以用高级for 循环。但数组不是一个interator。

String s1=”abc”+”def”+47+”mm”;编译器使用了 StringBuilder 的 append()方法，最后调用toString();

String 的 format 方法，用于格式化输出。S.O.P(String.format(“格式”,变量..));

GetDeclaredMethods（）：

返回method 对象的一个数组，这些对象反应次class 对象表示的类or 接口声明的all

方法，包括公有、私有、默认和保护方法，但是不包括继承的方法。GetMethods（）：反应此class 对象表示的类or 接口的公共method

方法。

Int a[]=new int[] ; a++;（这句话是错的，因为a 是常量，是地址）。外部排序常用的是归并排序。

InputStream 和outputStream 之间传数据需要一个byte[], byte[] b=new byte[1024]; While(len=in.read(b)!=-1)

Out.write(b,0,len);

getDeclaredMethod：返回method 数组，表示class 对象表示的类or 接口声明的all 方法，包括公共、保护、私有，但不包括继承。

GetMethod：返回method 数组，表示class 对象所表示的类or 接口的公有方法，包括从父类继承的。

CopyOnWriteArrayList 的核心：对于任何Array 在结构上有所改变的操作（add，remove 等），CopyOnWriteArrayList 都会copy 现有数组，再在copy 的数组上修改。这样就不影响

子类引用父类静态字段，子类不会初始化。通过数据定义引用类，不会触发此类的初始化，比如Person[] p=new Person[10];

若一个类方法体的字节码没有通过验证，那肯定是有问题的；但若一个方法体通过了字节码验证，也不能说明其一定安全。

符号引用的目标不一定已经加载入内存；直接引用的目标一定已经加载入内存。

在编译程序代码的时候，栈帧中需要多大的局部变量表，多深的操作数栈都已经完全确定了，并且写入到方法表的code 属性中，因此，一个栈帧需要分配多少内存，不会受到运行期变量数据的影响，而仅仅取决于具体虚拟机的实现。

局部变量表以slot 为单位，long 和double 占2 个slot，第0 位索引的slot 默认为用于传递方法所属对象实例调用，this。

若一个局部变量定义了，但没有赋初始值是不能使用的。操作数栈中元素的类型必须与字节码指令的序列严格匹配。

每个栈帧都包含一个指向运行时常量池中该栈所属方法的引用，持有这个引用是为了支持方法调用过程中的动态链接。

只

要能被invokestatic 和invokespecia

指令调用的方法，都可以在解析阶段中确定唯一的调用版本，符合这个条件的有静态方法，私有方法，实例构造器，父类方法，他们在类加载的时候就会把符号引

用，改为该方法的直接引用，他们称为非虚方法（包括final 修饰的方法）。

不可变类型String、long、double 等数值包装类型，BigInteger 和BigDecimal 等大数据类型。

Java 中各种操作共享的数据分为五类：不可变，绝对线程安全，相对线程安全，线程兼容，线程对立。

绑定多个条件：一个reentrantlock 对象可以同时绑定多个condition。