Java基础拾遗（二）

（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/76358523冷血之心的博客）

马上就要秋招了，新的一轮笔试面试马上就要开始轰炸了，在这关键的节骨眼上，要做到查缺补漏，夯实基础，特此总结~

友情链接：

Java基础拾遗（一）

Java基础拾遗（二）

1. Java集合相关知识
   1. HashMap和Hashtable的区别
      1. HashMap没有考虑同步，是线程不安全的；Hashtable使用了synchronized关键字，是线程安全的；
      2. 前者允许null作为Key；后者不允许null作为Key
   2. HashMap如何处理hash冲突？
      1. 拉链法
      2. 线性探测再散列法
      3. 二次探测再散列法
      4. 伪随机探测再散列法
   3. HashMap的长度为什么是2的幂次方？
      1. 通过将Key的hash值与length-1进行&运算，实现了当前Key的定位，2的幂次方可以减少冲突（碰撞）的次数，提高HashMap查询效率
      2. 如果length为2的次幂  则length-1 转化为二进制必定是11111……的形式，在于h的二进制与操作效率会非常的快，而且空间不浪费；如果length不是2的次幂，比如length为15，则length-1为14，对应的二进制为1110，在于h与操作，最后一位都为0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！这样就会造成空间的浪费。
      3. 
   4. ConcurrentHashMap和HashTable的区别？ 
      1. ConcurrentHashMap结合了HashMap和HashTable二者的优势。HashMap没有考虑同步，hashtable考虑了同步的问题。但是hashtable在每次同步执行时都要锁住整个结构。 ConcurrentHashMap锁的方式是稍微细粒度的。 ConcurrentHashMap将hash表分为16个桶（默认值），诸如get,put,remove等常用操作只锁当前需要用到的桶。
   5. ConcurrentHashMap的具体实现方式：
      1. 该类包含两个静态内部类HashEntry和Segment；
      2. 前者用来封装映射表的键值对，后者用来充当锁的角色；
      3. Segment是一种可重入的锁ReentrantLock，每个Segment守护一个HashEntry数组里得元素，当对HashEntry数组的数据进行修改时，必须首先获得对应的Segment锁。
   6. 常用集合的初始容量和加载因子
      1. List
         1. ArrayList的初始容量是10；加载因子为0.5； 扩容增量：原容量的 0.5倍+1；一次扩容后长度为16
         2. Vector初始容量为10，加载因子是1。扩容增量：原容量的 1倍，如 Vector的容量为10，一次扩容后是容量为20
      1. Set
         1. HashSet，初始容量为16，加载因子为0.75； 扩容增量：原容量的 1 倍； 如 HashSet的容量为16，一次扩容后容量为32
      2. Map
         1. HashMap，初始容量16，加载因子为0.75； 扩容增量：原容量的 1 倍； 如 HashMap的容量为16，一次扩容后容量为32
         2. HashMap扩容是指链表中的元素个数超过了16*0.75=12之后开始扩容
   7. List和Set的区别：
      1. List元素是有序的，可以重复
      2. Set元素是无序的，不可以重复
   8. 集合分类：
      1. Map接口和Collection接口是所有集合框架的父接口；
         1. Collection接口的子接口包括：Set接口和List接口；
         2. Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等
         3. Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等
         4. List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等
   9. Set接口
      1. HashSet
         1. 通过元素的hashCode和equals方法保证元素的唯一性
         2. 添加的元素，必须实现了这两个方法，缺一不可
      2. TreeSet
         1. 让元素自身具备比较性
            1. 让元素实现Comparable接口，覆盖compareTo方法。
         2. 让集合自身具备比较性
            1. 自定义一个比较器类，实现Comparator接口，覆盖compare方法，建立集合对象时，将比较器传入。
         3. Comparable接口和Comparator接口的比较
            1. 前者简单，但是如果需要重新定义比较类型时，需要修改源代码。
            2. 后者不需要修改源代码，自定义一个比较器，实现自定义的比较方法。
   10. Iterator和ListIterator的区别是什么？
       1. 前者可以遍历list和set集合；后者只能用来遍历list集合
       2. 前者只能前向遍历集合；后者可以前向和后向遍历集合
       3. 后者实现了前者，增加了一些新的功能。
   11. Java集合的快速失败机制“fail-fast”
       1. 是java集合的一种错误检测机制，当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。
          1. 例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。
          2. 迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
       2. 解决办法：
          1. 在遍历过程中，所有涉及到改变modCount值得地方全部加上synchronized。
          2. 使用CopyOnWriteArrayList来替换ArrayList
             1. 通过底层拷贝数组，在拷贝的数组上进行操作
             2. 修改完成之后，改变原有数据
   12. Java集合的安全失败机制“fail-safe”
       1. 采用安全失败机制的集合容器，在遍历时不是直接在集合内容上进行访问，而是先复制原有集合内容，在拷贝的集合上进行遍历
       2. java.util.concurrent包下的容器都是安全失败的，可以在多线程下并发使用，并发修改。
2. Java基础知识点
   1. JDK8有哪些新特性？
      1. Lambda表达式和函数式接口：
         1. Lambda表达式（也称为闭包），允许我们将函数当成参数传递给某个方法，或者把代码本身当做数据处理；
         2. 函数式接口：指的是只有一个函数的接口，java.lang.Runnable和java.util.concurrent.Callable就是函数式接口的例子；java8提供了一个特殊的注解@Functionallnterface来标明该接口是一个函数式接口
      2. 引入重复注解： Java 8中使用@Repeatable注解定义重复注解
      3. 更好的类型判断：Value.defaultValue( )
      4. 注解的使用场景拓宽
      5. 加入了新的包java.time包，包含了所有关于日期、时间、时区、持续时间和时钟操作的类
   2. 面向对象的含义
      1. 面向对象是一种思想，可以将复杂问题简单化。让我们从执行者变为了指挥者。使用封装、继承、多态来实现程序设计。
   3. 封装
   4. 继承
   5. 多态：指一个程序中同名的多个不同方法共存的情况
      1. 通过子类对父类方法的覆盖实现
      2. 通过同一个类中方法的重载实现(重载包括参数个数不同、参数类型不同和参数顺序不同三种情况)
      3. 通过将子类的对象作为父类的对象实现
   6. Java序列化和反序列化：
      1. 序列化：把对象转换为字节序列的过程
      2. 反序列化：把字节序列恢复为对象的过程
      3. 对象序列化包括如下步骤：
         1. 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流
         2. 通过对象输出流的writeObject()方法写对象
      4. 对象反序列化的步骤如下：
         1. 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流
         2. 通过对象输入流的readObject()方法读取对象
   7. Java反射机制
      1. 反射机制：在运行中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。即动态获取信息和动态调用对象方法的功能称为反射机制。
      2. 反射机制的作用
         1. 在运行时判断任意一个对象所属的类
         2. 在运行时构造一个类的对象
         3. 在运行时判断任意一个类所具有的成员变量和方法
         4. 在运行时调用任意一个对象的方法，生成动态代理
      3. 与反射相关的类;
         1. Class：表示类
         2. Field：表示成员变量
         3. Method：表示方法
         4. Constructor：表示构造器
   8. 抽象类和接口的区别：
      1. 抽象类中可以没有抽象方法；接口中的方法必须是抽象方法；
      2. 抽象类中可以有普通的成员变量；接口中的变量必须是static final类型的，必须被初始化,接口中只有常量，没有变量！！！
      3. 抽象类只能单继承，接口可以继承多个父接口；
   9. 特殊运算符
      1. ~X表示的意思是：加1取反。  ~3=-4    ~-2=1
      2. 移位运算符：<<和>>和>>>
   10. 字节流和字符流的区别：
       1. 字节流处理单元为1个字节，操作字节和字节数组
       2. 字符流处理单元为2个字节，操作字符、字符串或字符数组
       3. 字节流用来处理二进制数据，因为要处理很多文本数据，所以提出了字符流
       4. 字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的
       5. 字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容
   11. 正则表达式
       1. 四大方法：
          1. 匹配：String matches（regex）用规则来匹配整个字符串
          2. 切割：String split（regex）
          3. 替换：String replaceAll（regex，str）
          4. 获取：
             1. 将正则表达式封装成对象  Pattern p = Pattern.compile(regex)
             2. 让正则对象和要操作的字符串相关联 Matcher m = p.matcher(String)
             3. 关联后，获取正则匹配引擎  while(m.find()){System.out.println(m.group( ));}
             4. 通过引擎对符合规则的子串进行取出操作

       2. [abc]	a、b 或 c（简单类）
          [^abc]	任何字符，除了 a、b 或 c（否定）
          [a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
          [a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
          [a-z&&[def]]	d、e 或 f（交集）
          [a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
          [a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）

       3. .	任何字符（与行结束符可能匹配也可能不匹配）
          \d	数字：[0-9]
          \D	非数字： [^0-9]
          \s	空白字符：[ \t\n\x0B\f\r]
          \S	非空白字符：[^\s]
          \w	单词字符：[a-zA-Z_0-9]
          \W	非单词字符：[^\w]

       4. X+	X，一次或多次
          X{n}	X，恰好 n 次
          X{n,}	X，至少 n 次
          X{n,m}	X，至少 n 次，但是不超过 m 次

   12. 基本数据类型分别占多少字节
       1. 
   13. 不使用新变量，交换两个变量的值，比如有两个变量a和b。
       1. 基于加减法：
          1. a = a+b ;
          2. b = a-b ;
          3. a = a-b ;
       2. 基于异或运算:
          1. a = a^b ;
          2. b = a^b ;
          3. a = a^b ;
   14. Java类加载机制：
       1. 定义：
          1. 类加载指将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。
       2. 类的生命周期：
          1. 加载--验证--准备--解析--初始化--使用--卸载
          2. 加载：
             1. 查找并加载类的二进制数据
          3. 验证：
             1. 确保被加载的类的正确性
                1. 文件格式验证
                2. 元数据 验证
                3. 字节码验证
                4. 符号引用验证
          4. 准备：
             1. 为类的静态变量分配内存，并将其初始化为默认值
             2. 假设一个类变量的定义为public static int val = 3;，那么变量val在准备阶段过后的初始值不是3而是0。
          5. 解析：
             1. 把类中符号引用转换为直接引用
          6. 初始化：
             1. 为类的静态变量赋予正确的初始值，JVM负责对类进行初始化，主要对类变量进行初始化。
       3. 类加载器：
          1. 启动类加载器Bootstrap ClassLoader
          2. 扩展类加载器ExtClassloader
          3. 应用类加载器AppClassLoader
          4. 自定义加载器
          5. 类加载器的职责：
             1. 全盘负责
             2. 父类委托
             3. 缓存机制
          6. 父类委托机制：（双亲委派模型）
             1. 如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。
             2. 意义：
                1. 系统类防止内存中出现多份同样的字节码
                2. 保证java程序安全稳定运行
       4. Java中类的加载有三种方法：
          1. 命令行启动应用时候由JVM初始化加载
          2. 通过Class.forName( )方法动态加载
          3. 通过ClassLoader.loadClass( )方法动态加载

如果对你有帮助，记得点赞哦~欢迎大家关注我的博客，可以进群366533258一起交流学习哦~

本群给大家提供一个学习交流的平台，内设菜鸟Java管理员一枚、精通算法的金牌讲师一枚、Android管理员一枚、蓝牙BlueTooth管理员一枚、Web前端管理一枚以及C#管理一枚。欢迎大家进来交流技术。