Java复习

一、Java

1.1基础

基本功

• java执行系统中，解释执行与编译执行并存； 编译包括JIT(即时编译=>只编译执行过程中的热点代码)与AOT(提前编译)
• JDK(所有) > JRE(JVM+javaSE) >JVM
• 在 C 语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java 语言中没有结束符这一概念(思考原因 => java与C语言在字符串结束符上的区别)
• java中char描述了UTF16编码中的一个代码单元，占两个字节(所以char不一定能表示一个完整的字符，因为有的字符可能由两个代码单元组成) <=> 而C语言中char代表一个ASCII固定一个字节
• ==和equals的区别
  ==：判断值是否相等(对于基本类型而言比较两个数是否相等； 对于引用类型而言也是比较两个值是否相等，只是引用类型变量存储的值是对象的地址 => 比较的是对象的地址是否相等)
  equals：只能用于比较对象；如果没有被重写，默认也是比较对象地址(见Object类)；String类覆盖了equals方法，比较的是内容
• 重写 equals 时必须重写 hashCode 方法
  equals默认比较对象的地址
  hashCode默认根据对象的地址计算所得(但不同对象的hashCode可能冲突 )
  => 默认情况下如果两个对象相等(说明是同一个对象)，则hashCode一定相等；
  如果重写了equals方法确没有重写hashCode方法：equals方法判断两个对象相等时，他们可能不是同一个对象，由于不同对象可能产生相同的hashCode，从而equals方法与hashCode方法不一致
• 基本类型boolean的大小
  对于boolean，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1位，但是实际中会考虑计算机高效存储因素。
• 装箱与拆箱
  以下代码的运行结果：

  		Integer i1 = 127;
          Integer i2 = 127;
          Integer i3 = 128;
          Integer i4 = 128;
  		System.out.println(i1==i2);   // true
  		System.out.println(i3==i4);   // false
  		
  		Double j1 = 100.0;
          Double j2 = 100.0;
          Double j3 = 200.0;
          Double j4 = 200.0;
          System.out.println(j1==j2); //false
          System.out.println(j3==j4); //false
  

原因：查看Integer自动装箱时调用的源码valueOf()：

public static Integer valueOf(int i) {
		//IntegerCache是Integer的内部类
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

对于一定范围内的整数，会直接使用本地缓存的对象，而不是新创建对象，这一范围通常是[-128,127] => Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte,Short,Integer,Long,Character,Boolean；前面 4 种包装类默认创建了数值[-128，127] 的相应类型的缓存数据，Character创建了数值在[0,127]范围的缓存数据，Boolean 直接返回True Or False。如果超出对应范围仍然会去创建新的对象。

面向对象

• 关于构造器
  1.构造器不能重写，但是可以重载；
  2.但是子类不能重载父类的构造器(可以重载其他方法)；
  3.一个类如果没有定义构造方法，则自动提供无参构造器；如果定义了构造方法，则不会提供默认的无参构造器=> 会导致4的情况；
  4.Java 程序在执行子类的构造方法之前，如果没有用 super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
• 关于继承
  子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
• 关于多态
  1.方法具有多态性，属性不具有多态性；
  2.引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
  3.多态不能调用“只在子类存在但在父类不存在”的方法；
  4.如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。
  5.关于多态是如何实现的，参考周志明JVM
• 接口和抽象类
  1.接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
  2.接口中除了 static、final 变量，不能有其他变量，而抽象类中则不一定。
  3.一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口。
  4.接口方法默认修饰符是 public，抽象方法可以有 public、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）。
• String、StringBuilder、StringBuffer
  String对象不可变；
  StringBuilder原理：每次添加字符串的时候调用native方法以字符数组的方式存储所有字符，调用toString()方法时再使用字符数组生成String对象(见源码)
  StringBuffer原理类似StringBuilder，但是线程安全！

java核心技术(异常、集合、IO等)

• Collections 工具类和 Arrays 工具类常见方法
  参考：Collections 工具类和 Arrays 工具类常见方法

• 异常的层次结构
  
  注：异常类的printStackTrace()方法实际上打印的是System.err对象中的内容

• System.in等对象是如何初始化的
  System.class源码可知in、out、等对象是被定义为null的；他们的初始化实际上通过本地方法进行的！！参考：关于System.in（out、err）的一点疑问

• try catch finally
  面对必须要关闭的资源，我们总是应该优先使用try-with-resources而不是try-finally

• java线程状态的集合(与操作系统略有差别)
  
  

• 阻塞与等待的区别
  阻塞：一个线程因为等待临界区的锁被阻塞产生的状态 ；synchronize 关键字导致阻塞状态
  等待：一个线程进入了锁，但是需要等待其他线程执行某些操作。时间不确定
  当wait，join，park方法调用时，进入waiting状态。前提是这个线程已经拥有锁了。

• 文件与IO流
  参考原文：文件与 I\O 流(注意为什么要提供字符流)

• BIO、NIO、AIO
  参考：BIO,NIO,AIO 有什么区别?

• NIO与Netty的关系
  了解：Netty是什么，看完又涨知识了！
  

易错点/疑难点

• equals的最佳使用
  Object的equals方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals； <=> 不过更推荐使用 java.util.Objects中的equals方法，其源码如下：

   public static boolean equals(Object a, Object b) {
          return (a == b) || (a != null && a.equals(b));
      }
  

• 整型包装类值的比较
  必须使用equals(）方法
• 基本数据类型与包装数据类型的使用标准
  所有的 POJO 类属性必须使用包装数据类型。
  RPC 方法的返回值和参数必须使用包装数据类型。
  推荐所有的局部变量使用基本数据类型 => 栈上分配，减少堆的资源开销
• 不要在 foreach 循环里进行元素的 remove/add 操作

j2ee基本知识

• servlet概述
  1.servlet主要负责接收用户请求 HttpServletRequest,在doGet(),doPost()中做相应的处理(这两个方法在HttpServlet中，而不是Servlet)，并将回应HttpServletResponse反馈给用户；
  2.一个Servlet类只会有一个实例，在它初始化时调用init()方法，销毁时调用destroy()方法；
  3.Servlet不是线程安全，因此要谨慎使用类变量(因为servlet是单例的，多个请求对应同一个servlet时，造成多个线程并发访问同一个对象)

• Servlet接口中的方法
  public void init(ServletConfig config);
  public ServletConfig getServletConfig();
  public void service(ServletRequest req, ServletResponse res)
  public String getServletInfo();
  public void destroy();
  其中，init()、service()、destroy()与生命周期相关

• servlet生命周期
  1.Web容器加载Servlet并将其实例化后，Servlet生命周期开始；
  2.容器运行其init()方法进行Servlet的初始化；
  3.请求到达时调用Servlet的service()方法，service()方法会根据需要调用与请求对应的doGet或doPost等方法(这两个方法在HttpServlet类中)；
  4.当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的destroy()方法。
  注意：init方法和destroy方法只会执行一次，service方法客户端每次请求Servlet都会执行。

• GET和POST的区别
  颇具争议的话题，参考知乎讨论：GET 和 POST 到底有什么区别？
  更多理解：GET和POST两种基本请求方法的区别(关于这个博客中的说法，知乎讨论中有相应反驳…)

• Forward与Redirect
  转发是服务器行为，重定向是客户端行为
  forward:一般用于用户登陆的时候,根据角色转发到相应的模块. redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等

• JSP与servlet的关系
  1.jsp最终也会被转换成servlet，使用jsp只是为了方便页面开发!
  2.JSP侧重于视图，Servlet更侧重于控制逻辑，在MVC架构模式中，JSP适合充当视图（view）而Servlet适合充当控制器（controller）

• JSP九大内置对象及其作用域
  九大内置对象：
  
  四大作用域：
  
  九大对象所属作用域情况：
  

  详情参考：1.JSP九大内置对象，七大动作，三大指令
  2.JSP九大内置对象和四个作用域

• Servlet/JSP的单线程模式 与 多线程模式
  多线程模式：默认Servlet支持多线程模式，即有多个客户端同时请求同一个Servlet，服务器上的Servlet只会产生一个实例，但是会启动多个线程来响应客户请求，但是这样会导致线程安全问题，编程时建议不要在Servlet中定义成员属性来共享数据，以避免出现数据同步的问题。
  单线程模式：该模式同一时刻只有一个实例，不会出现信息同步与否的概念。若多个用户同时访问一个这种模式的页面，那么先访问者完全执行该页面后，后访问者才开始执行。设置方法参考：如何实现JSP或Servlet的单线程模式

常用关键字(final、static、this、super)

• final
  修饰：类、方法、变量
  1.修饰的类不能被继承，final类中的方法隐式指定为final方法
  2.修饰的方法不能重写
  3.修饰的变量是常量(基本类型不能修改，引用类型不能指向其他对象)
• static
  修饰：类(内部类)、方法、变量、代码块
  1.修饰类时只能修饰内部类：非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：a. 它的创建是不需要依赖外围类的创建； b. 它不能使用任何外围类的非static成员变量和方法。
  2.修饰方法：属于类的方法…
  3.修饰变量：属于类的变量…
  4.修饰代码块：静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次
• this
  this关键字用于引用类的当前实例 => 可选的，很多情况下不用也行，但是使用此关键字可能会使代码更易读或易懂
• super
  super关键字用于从子类访问父类的变量和方法

1.2 容器

集合概述

• 集合/容器层次关系
  
  小结：1.以Map结尾的容器全部实现了Map接口； 剩余容器全部实现了Collection接口； 2.具体的容器类(如ArrayList)既实现了对应的接口(List)，也继承了对应的抽象类(AbstractList，只是此处没有画出)
• 集合框架底层存储元素的数据结构
  • List接口下
    ArrayList：Object[] 数组
    Vector：Object[] 数组
    LinkedList：双向链表(jdk1.8)
  • Set接口下
    HashSet：底层用HashMap保存数据
    LinkedHashSet：是HashSet的子类，底层也是HashMap
    TreeSet：红黑树
  • Map接口下
    HashMap：jdk1.8前由数组+链表组成； JDK1.8 后解决冲突的方法有变化 => 当链表长度大于阈值(8)时，将链表转化为红黑树，以减少搜索时间
    LinkedHashMap：继承自HashMap，所以底层仍然是数组+链表/红黑树； 但是在上述结构的基础上添加了一条双向链表，从而保持键值对的插入顺序，更多参考：LinkedHashMap 源码详细分析（JDK1.8）
    Hashtable：同HashMap=>数组+链表(但是不会转换为红黑树)
    TreeMap：红黑树(需要排序时通常使用TreeMap)
• Iterator迭代器
  原理：迭代器模式
  使用方法：1.1.6.3. 如何使用？
• 线程安全的集合/容器
  常用的 Arraylist ,LinkedList,Hashmap,HashSet,TreeSet,TreeMapPriorityQueue 都不是线程安全的(Vector除外)； 如果要使用线程安全的集合，通常采用concurrent包

List

• ArrayList与Vector的区别
  1.ArrayList 是 List 的主要实现类，底层使用 Object[ ]存储，适用于频繁的查找工作，线程不安全 ；
  2.Vector 是 List 的古老实现类，底层使用 Object[ ]存储，线程安全的(因为使用了synchronized)
• ArrayList与LinckedList的区别
  Arraylist 与 LinkedList 区别?
• RandomAccess 接口
  这是一个标识接口，标识实现这个接口的类具有随机访问功能 =>ArrayList实现了RandomAccess接口，而LinkedList则没有
• ArrayList的扩容机制
  说一说 ArrayList 的扩容机制吧

Set

• Comparable 和 Comparator的区别
  Comparable：来自java.lang包，需要实现compareTo(T o)方法
  Comparator：来自java.util包，需要实现compare(T o1, T o2)方法
• 无序性的含义
  无序性不等于随机性 ，无序性是指存储的数据在底层数组中并非按照数组索引的顺序添加 ，而是根据数据的哈希值决定的
• HashSet、LinkedHashSet 和 TreeSet 三者的异同
  HashSet：Set 接口的主要实现类 ，HashSet 的底层是 HashMap，线程不安全的，可以存储 null 值；
  LinkedHashSet：HashSet 的子类，能够按照添加的顺序遍历；
  TreeSet：底层使用红黑树，能够按照添加元素的顺序进行遍历，排序的方式有自然排序和定制排序。

Map

• HashMap 和 Hashtable
  HashMap：HashMap 是非线程安全的； 效率高； 底层可能转换为红黑树；扩容机制与HashTable有所区别
  Hashtable：线程安全(使用synchronized)； 效率低； 底层数组+链表，不会转换为红黑树；扩容机制与HashMap有所区别
• HashMap与HashSet
  HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 clone()、writeObject()、readObject()是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法)
• HashMap 和 TreeMap
  TreeMap 主要多了对集合中的元素根据键排序的能力以及对集合内元素的搜索的能力(因为实现了NavigableMap接口)
  详情参考：HashMap 和 TreeMap 区别
• HashSet 如何检查重复
  1.计算要加入对象的hashCode
  2.若hashCode没有重复，则可以正常加入
  3.若hashCode重复，还需根据equals()方法判断hashCode重复的是否为同一个对象，若是同一个对象，则不能加入(equals也可能重写后只是判断内容)
• HashMap的底层实现
  参考：HashMap 的底层实现
  尚不明白其中hash()方法的原理与作用？？
• HashMap计算元素位置的方法
  下标的计算方法是：(n - 1) & hash => (参考put方法中调用的putVal()方法)
  原理：我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是 2 的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是 2 的 n 次方；）。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是 2 的幂次方。
• ConcurrentHashMap
  参考：ConcurrentHashMap 和 Hashtable 的区别

Collections工具类

• 排序

  void reverse(List list)//反转
  void shuffle(List list)//随机排序
  void sort(List list)//按自然排序的升序排序
  void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
  void swap(List list, int i , int j)//交换两个索引位置的元素
  void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面
  

• 查找、替换

  int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
  int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
  int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
  void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
  int frequency(Collection c, Object o)//统计元素出现次数
  int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
  boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素
  

• 同步控制
  略，不推荐使用(=> 应该使用JUC包)

Arrays工具类

• Arrays.asList()使用细节
  Arrays.asList()将数组转换为集合后,底层其实还是数组
  更多参考：Arrays.asList()避坑指南

源码之ArrayList

• 源码分析
  参考：ArrayList 源码
  重点关注：1.ArrayList的扩容机制(最终还是通过Arrays.copyOf()实现)；2.modCount；3.System.arraycopy()原生方法实现数组复制( add(int index, E element)方法中调用)；
• 关于modCount
  对于List接口下的容器而言，modCount定义在AbstractList类中，用于记录对象被修改的次数。为什么需要记录修改次数？
  =>