java基础语法

一、基本数据类型：

1.Java自动装箱与拆箱

在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

2.equals与==的区别

int a=10 与 long b=10L 与 double c=10.0都是==（为true），因为他们都指向地址为10的堆。

二.Collection包结构，与Collections的区别

Collection是集合类的上级接口，子接口有 Set、List、LinkedList、ArrayList、Vector、Stack、
Set；
Collections是集合类的一个帮助类， 它包含有各种有关集合操作的静态多态方法，用于实现对各种
集合的搜索、排序、线程安全化等操作。此类不能实例化，就像一个工具类，服务于Java的
Collection框架。

1.说说List,Set,Map三者的区别？

List(对付顺序的好帮手)： List接口存储一组不唯一（可以有多个元素引用相同的对象），有序
的对象
Set(注重独一无二的性质): 不允许重复的集合。不会有多个元素引用相同的对象。
Map(用Key来搜索的专家): 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引
用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。

2.ArrayList和linkedList的区别

对比一：Arraylist与LinkedList的比较**
1、ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。
2、因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。
3、LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。
4、因为LinkedList要移动指针,所以查询操作性能比较低。

• 适用场景分析
  当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

对比二：Array和ArrayList有何区别？什么时候更适合用Array？

• 存储内容比较：
  Array数组可以包含基本类型和对象类型，ArrayList只能包含对象类型。
  Array数组存放的一定是同种类型的元素，ArrayList可以存放任意对象（object的子类）。
• 空间大小比较：
  Array的空间大小是固定的，空间不够时也不能再次申请，所以需要事前确定合适的空间大小。
  ArrayList的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大的新数组，然后将所有元素复制到新数组中，接着抛弃旧数组。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。（比较麻烦的地方）。
• 方法上的比较：
  ArrayList作为Array的增强版，在方法上比Array更多样化，比如添加全部addAll()、删除全部removeAll()、返回迭代器iterator()等。
• 适用场景：
  如果想要保存一些在整个程序运行期间都会存在而且不变的数据，我们可以将它们放进一个全局数组里；但是如果我们单纯只是想要以数组的形式保存数据，而不对数据进行增加等操作，只是方便我们进行查找的话，那么，我们就选择ArrayList。
  而且还有一个地方是必须知道的，就是如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用ArrayList就真的不是一个好的选择，因为它的效率很低，我们可以考虑选择LinkedList。

对比三：ArrayList与Vector的比较

• Vector的方法都是同步的，是线程安全的，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。
• 当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只增加50%的大小，这样。ArrayList就有利于节约内存空间。
• 大多数情况不使用Vector，因为性能不好，但是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性。
• Vector可以设置增长因子，而ArrayList不可以。
• 适用场景分析：
  1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
  2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

ArrayList原理结构
Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有
数据, (因为删除数据以后, 需要把后面所有的数据前移)

• ArrayList是一个动态数组，其初始化容量10，一次扩容原先容量的二分之一倍即变为原先容量的1.5倍：

   int   newCapacity = oldCapacity + (oldCapacity >> 1);
  

• ArrayList的elementData属性为什么用了transient修饰后，依然可以序列化，这样的好处？

• ArrayList在序列化的时候会调用writeObject，直接将size和element写入ObjectOutputStream；反序列化时调用readObject，从ObjectInputStream获取size和element，再恢复到elementData。elementData是一个缓存数组，它通常会预留一些容量，等容量不足时再扩充容量，那么有些空间可能就没有实际存储元素，采用上述的方式来实现序列化时，就可以保证只序列化实际存储的那些元素，而不是整个数组，从而节省空间和时间。

LinkedList原理结构

• LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinkedList比较占优势。因为LinkedList要移动指针,所以查询操作性能比较低。
• LinkedList是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低。

双向链表 插入和删除都只要改动前后节点的next和previous实现

3.说说Hashtable 与 HashMap 的区别

1. 都是 key-value 形式的存储数据；
2. HashMap 是线程不安全的，ConcurrentHashMap 是 JUC 下的线程安全的；
3. HashMap 底层数据结构是数组 + 链表（JDK 1.8 之前）。JDK 1.8 之后是数组 + 链表 + 红黑
   树。当链表中元素个数达到 8 的时候，链表的查询速度不如红黑树快，链表会转为红黑树，红
   黑树查询速度快；
4. HashMap 初始数组大小为 16（默认），当出现扩容的时候，以 0.75 * 数组大小的方式进行扩
   容；
5. ConcurrentHashMap 在 JDK 1.8 之前是采用分段锁来现实的 Segment + HashEntry，Segment 数组大小默认是 16，2 的 n 次方；JDK 1.8 之后，采用 Node + CAS + Synchronized来保证并发安全进行实现。

HashMap原理结构

• ArrayList基于数组+单向链表的数据结构.
• 负载因子：扩容因子0.75，初始化容量16 ，最大2^30.
• key重复会被覆盖吗？不会。put时返回oldvalue,getkey是新值。
• 扩容机制：扩容old的两倍。新数组重新计算hash
• hash碰撞:put的时候hash碰撞问题Hash冲突时，新值nextEntry指向旧值。

ConcurrentHashMap原理结构

• ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。
• concurrenthashmap原理和技术，size方法的实现？
  JDK 8 推荐使用mappingCount 方法，因为这个方法的返回值是 long 类型，不会因为 size 方法是 int 类型限制最大值（size 方法是接口定义的，不能修改）。
  在没有并发的情况下，使用一个 baseCount volatile 变量就足够了，当并发的时候，CAS 修改 baseCount 失败后，就会使用 CounterCell 类了，会创建一个这个对象，通常对象的 volatile value 属性是 1。在计算 size 的时候，会将 baseCount 和 CounterCell 数组中的元素的 value 累加，得到总的大小，但这个数字仍旧可能是不准确的。
  还有一个需要注意的地方就是，这个 CounterCell 类使用了 @sun.misc.Contended 注解标识，这个注解是防止伪共享的。是 1.8 新增的。使用时，需要加上 -XX:-RestrictContended 参数。
  

LinkedHashMap原理结构

• 访问队列
  LinkedHashMap实现有序key值的关键就是根据插入顺序另外维护了一个按照插入顺序作为标记的双向循环列表，这样在获取所有数据进行循环获取时获取到的数据就是有序的数据。
  对比四：HashMap和ConcurrentHashMap的区别

1、HashMap不是线程安全的，而ConcurrentHashMap是线程安全的。
2、ConcurrentHashMap采用锁分段技术，将整个Hash桶进行了分段segment，也就是将这个大的数组分成了几个小的片段segment，而且每个小的片段segment上面都有锁存在，那么在插入元素的时候就需要先找到应该插入到哪一个片段segment，然后再在这个片段上面进行插入，而且这里还需要获取segment锁。
3、ConcurrentHashMap让锁的粒度更精细一些，并发性能更好。

对比五：HashTable和ConcurrentHashMap的区别
它们都可以用于多线程的环境，但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。

4、try catch finally，try里有return，finally还执行么？

执行，并且finally的执行早于try里面的return

import static java.lang.Math.*;
public class Test{
 public static void main(String[] args){
 //System.out.println(Math.sin(20));传统做法
 System.out.println(sin(20));
 }
}
byte a = 127;
byte b = 127;
b = a + b; // 报编译错误:cannot convert from int to byte
b += a;
short s1= 1;
s1 = s1 + 1;
short s1= 1;
s1 += 1;

结论：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的
值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数
返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

5、 Excption与Error包结构

Java可抛出(Throwable)的结构分为三种类型：被检查的异常(CheckedException)，运行时异常
(RuntimeException)，错误(Error)。
1、运行时异常
定义:RuntimeException及其子类都被称为运行时异常。
特点:Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws
声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。例如，除数为零时产生的
ArithmeticException异常，数组越界时产生的IndexOutOfBoundsException异常，fail-fast机制产
生的ConcurrentModificationException异常（java.util包下面的所有的集合类都是快速失败
的，“快速失败”也就是fail-fast，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上
的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线
程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的
结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出
ConcurrentModificationException 异常，从而产生fail-fast机制，这个错叫并发修改异常。Failsafe，java.util.concurrent包下面的所有的类都是安全失败的，在遍历过程中，如果已经遍历的数
组上的内容变化了，迭代器不会抛出ConcurrentModificationException异常。如果未遍历的数组
上的内容发生了变化，则有可能反映到迭代过程中。这就是ConcurrentHashMap迭代器弱一致的
表现。ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。
要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样
了。）等，都属于运行时异常。
常见的五种运行时异常：
ClassCastException（类转换异常）
IndexOutOfBoundsException（数组越界）
NullPointerException（空指针异常）
ArrayStoreException（数据存储异常，操作数组是类型不一致）
BufferOverflowException
2、被检查异常
定义:Exception类本身，以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异
常。
特点 : Java编译器会检查它。 此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕
获处理，否则不能通过编译。例如，CloneNotSupportedException就属于被检查异常。当通过
clone()接口去克隆一个对象，而该对象对应的类没有实现Cloneable接口，就会抛出
CloneNotSupportedException异常。被检查异常通常都是可以恢复的。 如：
IOException
FileNotFoundException
SQLException
被检查的异常适用于那些不是因程序引起的错误情况，比如：读取文件时文件不存在引发的
FileNotFoundException 。然而，不被检查的异常通常都是由于糟糕的编程引起的，比如：在对象
引用时没有确保对象非空而引起的 NullPointerException 。
3、错误
定义 : Error类及其子类。
特点 : 和运行时异常一样，编译器也不会对错误进行检查。
当资源不足、约束失败、或是其它程序无法继续运行的条件发生时，就产生错误。程序本身无法修
复这些错误的。例如，VirtualMachineError就属于错误。出现这种错误会导致程序终止运行。
OutOfMemoryError、ThreadDeath。
Java虚拟机规范规定JVM的内存分为了好几块，比如堆，栈，程序计数器，方法区等