Java技术点简要

java 基础

八种基本数据类型的大小，以及他们的封装类

第一类：整型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
在栈中可以直接分配内存的数据是基本数据类型。

Byte, Short, Integer, Long
Float, Double
Boolean
Character

字节大小：

boolean 布尔型 1/8
byte 字节类型 1
char 字符型 2 一个字符能存储一个中文汉字
short 短整型 2
int 整数类型 4
float 浮点类型（单精度） 4
long 长整形 8
double 双精度类型（双精度） 8

java中默认的整数类型是int类型，如果要定义为float型，则要在数值后加上l或L；

默认的浮点型也是双精度浮点，如果要定义为float型，则要在数值后加上f或F。

一个字节等于8位，一个字节等于256个数，就是-128到127一共256。
kB就是kBytes Bytes就是“字节”的意思！
K就是千的意思，因为计算机是通过二进制来计算，10个1正好是1024
1Bytes（字节）= 8bit（比特）

一个英文字母或一个阿拉伯数字就是一个字符，占用一个字节
一个汉字就是两个字符，占用两个字节。

一般讲大小是用Bytes，大写的“B”，讲网络速率是用bit，注意是小写的“b”。
例：一个文件有8MBytes
例：我下载文件的速率是256KB/s，即2Mbit，这通常就是我们宽带上网的速率。

基本数据类型自动转换
byte->short,char -> int -> long
float -> double
int -> float
long -> double
记住：小可转大，大转小会失去精度！！！

引用数据类型

是数据的引用在栈中，但是他的对象在堆中。
String, Object, Class, Enum

Switch能否用string做参数

jdk1.7后，整形，枚举类型，boolean，字符串都可以。

为什么jdk1.7后又可以用string类型作为switch参数呢？
其实，jdk1.7并没有新的指令来处理switch string，而是通过调用switch中string.hashCode,将string转换为int从而进行判断。

具体可以参考：http://freish.iteye.com/blog/1152921

equals与==的区别

对象类型不同
1、equals()：是超类Object中的方法。
2、==：是操作符。

比较的对象不同
equals()：用来检测两个对象是否相等，即两个对象的内容是否相等。
==：用于比较引用和比较基本数据类型时具有不同的功能。

运行速度不同
equals()：没有==运行速度快。
==：运行速度比equals()快，因为==只是比较引用。

对equals重新需要注意五点：
1、自反性：对任意引用值X，x.equals(x)的返回值一定为true；
2、对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true；
3、传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true ；
4、 一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变；
5、非空性：任何非空的引用值X，x.equals(null)的返回值一定为false 。

== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。
1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。

String s="abce"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。
以String s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串，在JVM内部发生字符串拘留，即当声明这样的一个字符串后，JVM会在常量池中先查找有有没有一个值为"abcd"的对象。
如果有，就会把它赋给当前引用. 即原来那个引用和现在这个引用指点向了同一对象，如果没有，则在常量池中新创建一个“abcd"”，下一次如果有Strings1="abcd"；又会将s1指向“abcd”这个对象，即以这形式声明的字符串，只要值相等，任何多个引用都指向同一对象。
而String s = new String（"abcd”）；和其它任何对象一样.每调用一次就产生一个对象，只要它们调用。
也可以这么理解：String str="hello”；先在内存中找是不是有“hello”这个对象，如果有，就让str指向那个“hello”。如果内存里没有"hello"，就创建一个新的对象保存"hello”.String str=new String（“hello"）就是不管内存里是不是已经有"hello"这个对象，都新建一个对象保存"hello"。

自动装箱，常量池

参考：https://www.jianshu.com/p/c4b76e2a905a

Object有哪些公用方法

参考：https://www.jianshu.com/p/f140ac279fd1
getClass()
hasCode()
equals()
toString()
toHexString()
numberOfLeadingZeros()
clone()
finalize()
notify()
notifyAll()
wait()

Java的四种引用，强弱软虚，用到的场景

• 强引用-FinalReference
  强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收，使用方式：
  String str = new String("str");
  这个str就是强引用。

• 软引用-SoftReference
  软引用在程序内存不足时，会被回收，使用方式：
  // 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的，
  // 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T
  SoftReference wrf = new SoftReference(new String("str"));
  可用场景：
  创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。PS：图片编辑器，视频编辑器之类的软件可以使用这种思路。
  软引用使用例子传送门：https://www.cnblogs.com/mjorcen/p/3968018.html

• 弱引用-WeakReference
  弱引用就是只要JVM垃圾回收器发现了它，就会将之回收，使用方式：
  WeakReference wrf = new WeakReference(str);
  **可用场景： **
  Java源码中的java.util.WeakHashMap中的key就是使用弱引用，我的理解就是，一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作。
  弱引用使用例子传送门：http://www.importnew.com/21206.html

• 虚引用-PhantomReference
  虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入ReferenceQueue中。注意哦，其它引用是被JVM回收后才被传入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有ReferenceQueue，使用例子：
  PhantomReference prf = new PhantomReference(new String("str"), new ReferenceQueue<>());
  可用场景：
  对象销毁前的一些操作，比如说资源释放等。Object.finalize()虽然也可以做这类动作，但是这个方式即不安全又低效(传送门：http://blog.csdn.net/aitangyong/article/details/39450341)，so。

强调
上诉所说的几类引用，都是指对象本身的引用，而不是指Reference的四个子类的引用(SoftReference等)。

Hashcode的作用

hashCode()方法返回当前对象运行时的hash码，是用于支持散列表数据结构，因为散列表在进行数据存储时依赖hash码决定数据存储的逻辑位置。

HashMap的hashcode的作用

因为散列表在进行数据存储时依赖hash码决定数据存储的逻辑位置。

为什么重载hashCode方法？

对这两个对象中的任一对象上调用 hashCode方法不要求一定生成不同的整数结果，为不相等的对象生成不同整数结果可以提高哈希表的性能。

ArrayList、LinkedList、Vector的区别

1. 从存储数据结构分析

ArrayList：数组

Vector：数组

LinkedList：双向链表

数组：可以根据下标快速查找，所以大部分情况下，查询快。但是如果要进行增删操作的时候，会需要移动修改元素后面的所有元素，所以增删的开销比较大，数组的对增删操作的执行效率低。而采用数组作为数据存储结构的ArrayList、Vector也存在这些特性，查询速度快（可以根据下标直接取，比迭代查找更快），增删慢。

链表：增加和删除元素方便，增加或删除一个元素，仅需处理结点间的引用即可。就像人手拉手连成一排，要增加或删除某个人只要附近的两个人换一个人牵手，对已经牵好手的人没影响。无论在哪里换人耗费的资源和时间都是一样的。但是查询不方便，需要一个个对比，无法根据下标直接查找。而采用链表结构存储的LinkedList也有这些特性，增删方便，查询慢(指的是随机查询，不是顺序查询)。

2. 从继承上分析

都实现了List接口，也就是说都实现了get(int location)、remove(int location)等“根据索引值来获取、删除节点的函数”。数组结构根据下标取值很容易，LinkedList双向列表的实现也比较简单，通过计数索引值实现，从链表长度的1/2开始查找，下标大了就从表头开始找，小了就从表尾开始找。

3. 从并发安全上分析

Vector：线程安全

ArrayList：非线程安全

LinkedList: 非线程安全

4. 数据增长分析

Vector：缺省的情况下，增长为原数组长度的一倍。说到缺省，说明他其实是可以自主设置初始化大小的。

ArrayList：自动增长原数组的50%。

参考：
https://www.jianshu.com/p/bd6ee6eca25b

String、StringBuffer与StringBuilder的区别

如果要操作少量的数据用 = String
单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

https://www.jianshu.com/p/6c8c0e7391d5

Map、Set、List、Queue、Stack的特点与用法

https://www.jianshu.com/p/8351173a24f3

HashMap和HashTable的区别

HashTable不能有null的key，HashTable是线程安全的
https://www.jianshu.com/p/82dcdb99b014

JDK7与JDK8中HashMap的实现

在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
https://www.jianshu.com/p/89ae11765524

HashMap和ConcurrentHashMap的区别，HashMap的底层源码

https://www.jianshu.com/p/82dcdb99b014

ConcurrentHashMap使用了分段锁技术来提高了并发度，不在同一段的数据互相不影响，多个线程对多个不同的段的操作是不会相互影响的。每个段使用一把锁。

ConcurrentHashMap能完全替代HashTable吗

在多线程的环境中，相对于HashTable，ConcurrentHashMap会带来很大的性能提升！

为什么HashMap是线程不安全的

HashMap会进行resize操作，在resize操作的时候会造成线程不安全。下面将举两个可能出现线程不安全的地方。

1. put的时候导致的多线程数据不一致
2. get操作可能因为resize而引起死循环（cpu100%)
   https://www.jianshu.com/p/e2f75c8cce01

如何线程安全的使用HashMap

这个无非就是以下三种方式：

• Hashtable
• ConcurrentHashMap
• Synchronized Map

多并发情况下HashMap是否还会产生死循环

HashMap在并发执行put操作时会引起死循环，导致CPU利用率接近100%。因为多线程会导致HashMap的Node链表形成环形数据结构，一旦形成环形数据结构，Node的next节点永远不为空，就会在获取Node时产生死循环。

TreeMap、HashMap、LinkedHashMap的区别

共同点：
HashMap,LinkedHashMap,TreeMap都属于Map；Map 主要用于存储键(key)值(value)对，根据键得到值，因此键不允许键重复,但允许值重复。
不同点：

1. HashMap里面存入的键值对在取出的时候是随机的,也是我们最常用的一个Map.它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
2. TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。
3. LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现. (应用场景：购物车等需要顺序的)

Collection包结构，与Collections的区别

Collection
1、Collection是集合类的顶级接口；
2、实现接口和类主要有Set、List、LinkedList、ArrayList、Vector、Stack、Set；

Collections
1、是针对集合类的一个帮助类，提供操作集合的工具方法；
2、一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作；
3、服务于Java的Collection的框架；

try?catch?finally，try里有return，finally还执行么

即使try或catch中return了，finally中的代码还是会执行。
如果finally中有return，结果会根据finally中的结果返回，如果finally中没有return，结果会按照catch的结果返回，但是不管怎么样，都是会执行finally的代码。

Excption与Error包结构，OOM你遇到过哪些情况，SOF你遇到过哪些情况

https://www.jianshu.com/p/c6f166a9051c

Java(OOP)面向对象的三个特征与含义

1、封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
2、继承
提高代码复用性；继承是多态的前提。
3、多态
父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

https://www.jianshu.com/p/9b7800328127

Override和Overload的含义去区别

Overload是重载的意思，表示在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
Override是覆盖的意思，也就是重写，它与返回值类型无关，只看参数列表。

两者不同主要体现在:
1，目的
overload用于增加程序的可读性(做法不同,但是做的同一事情)。 override用于提供其超级类已经提供的方法的特定实现。

2，范围
overload 在相同的类范围内内执行。 override发生在两类具有继承（继承）的关系。

3， 参数
overload参数必须不同。 override参数必须相同。

4，多态性
overload 静态多态, 调用的函数在编译时被选中。
override 是运行时多态性的。

5，返回类型
overload中可以相同或不同。但你必须改变参数。
override必须是相同的或协变的。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中定义的方法，这相当于把父类中定义的那个完全相同的方法给覆盖掉了，这也是面向对象编程的多态的一种表现。子类覆盖父类方法时只能抛出父类的异常或者异常的子类或者父类异常的子集，因为子类可以解决父类的一些问题，但不能比父类有更多的问题。

重载overload的特点就是与返回值无关，只看参数列表，所以重载的方法是可以改变返回值类型的。所以，如果两个方法的参数列表完全一样，是不能通过让他们的返回值类型不同来实现重载的。

Interface与abstract类的区别

(01). abstract class 在Java中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

(02). 在abstract class 中可以有自己的数据成员，也可以有非abstarct的方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的方法都是public abstract的。

(03). 抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。接口中定义的变量默认是public static final 型，且必须给其赋初值，所以实现类中不能重新定义，也不能改变其值。

(04). abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

(05). 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

abstract class 和 interface 是 Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系。

static class与non static class的区别

static class:
1、用static修饰的是内部类，此时这个内部类变为静态内部类；对测试有用；
2、内部静态类不需要有指向外部类的引用；
3、静态类只能访问外部类的静态成员，不能访问外部类的非静态成员；

non static class:
1、非静态内部类需要持有对外部类的引用；
2、非静态内部类能够访问外部类的静态和非静态成员；
3、一个非静态内部类不能脱离外部类实体被创建；
4、一个非静态内部类可以访问外部类的数据和方法；

java多态的实现原理

多态机制包括静态多态（编译时多态）和动态多态（运行时多态），静态多态比如说重载，动态多态是在编译时不能确定调用哪个方法，得在运行时确定。动态多态的实现方法包括子类继承父类和类实现接口。当多个子类上转型（不知道这么说对不）时，对象调用的是相应子类的方法，这种实现是与JVM有关的。

在JVM中，多态的实例方法调用实际上有两种指令：
invokevirtual指令用于调用声明为类的方法；
invokeinterface指令用于调用声明为接口的方法。
当使用invokeinterface指令调用方法时，就不能采用固定偏移量的办法，只能老老实实挨个找了。

https://www.jianshu.com/p/c83d379897b9

foreach与正常for循环效率对比

对于数组来说，for和foreach循环效率差不多，但是对于链表来说，for循环效率明显比foreach低。
https://www.jianshu.com/p/14a1afbf8c51

Java?IO与NIO

image.png

https://www.jianshu.com/p/079a0cecd967

java反射的作用与原理

反射是框架设计的灵魂

反射的实现原理：

1. 反射类及反射方法的获取，都是通过从列表中搜寻查找匹配的方法，所以查找性能会随类的大小方法多少而变化；
2. 每个类都会有一个与之对应的Class实例，从而每个类都可以获取method反射方法，并作用到其他实例身上；
3. 反射也是考虑了线程安全的，放心使用；
4. 反射使用软引用relectionData缓存class信息，避免每次重新从jvm获取带来的开销；
5. 反射调用多次生成新代理Accessor, 而通过字节码生存的则考虑了卸载功能，所以会使用独立的类加载器；
6. 当找到需要的方法，都会copy一份出来，而不是使用原来的实例，从而保证数据隔离；
7. 调度反射方法，最终是由jvm执行invoke0()执行；

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

2，反射提供的功能：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法

https://www.jianshu.com/p/182b981d53d7

泛型常用特点

java中的泛型只是在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type,也成为裸类型），并且在相应的地方插入了强制转换代码，因此对于运行期的Java语言来讲，所有的泛型容器都是一样的，泛型技术实际上是Java的一颗语法糖，Java语言的泛型实际方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。
java1.4或更早版本的开发背景的人都知道，在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。泛型的好处是在编译的时候检查类型安全。泛型提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。泛型是通过类型擦除来实现的，编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List在运行时仅用一个List来表示。这样做的目的，是确保能和Java 5之前的版本开发二进制类库进行兼容。你无法在运行时访问到类型参数，因为编译器已经把泛型类型转换成了原始类型。List不能转为List