Java基础拾遗（二）

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

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

友情链接：

Java基础拾遗（一）

Java基础拾遗（二）

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这几个位置永远都不能存放元素了，空间浪费相当大，更糟的是这种情况中，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！这样就会造成空间的浪费。
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包下的容器都是安全失败的，可以在多线程下并发使用，并发修改。

Java基础知识点

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包，包含了所有关于日期、时间、时区、持续时间和时钟操作的类
面向对象的含义
1. 面向对象是一种思想，可以将复杂问题简单化。让我们从执行者变为了指挥者。使用封装、继承、多态来实现程序设计。
封装
继承
多态：指一个程序中同名的多个不同方法共存的情况
1. 通过子类对父类方法的覆盖实现
2. 通过同一个类中方法的重载实现(重载包括参数个数不同、参数类型不同和参数顺序不同三种情况)
3. 通过将子类的对象作为父类的对象实现
Java序列化和反序列化：
1. 序列化：把对象转换为字节序列的过程
2. 反序列化：把字节序列恢复为对象的过程
3. 对象序列化包括如下步骤：
  1. 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流
  2. 通过对象输出流的writeObject()方法写对象
4. 对象反序列化的步骤如下：
  1. 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流
  2. 通过对象输入流的readObject()方法读取对象
Java反射机制
1. 反射机制：在运行中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。即动态获取信息和动态调用对象方法的功能称为反射机制。
2. 反射机制的作用
  1. 在运行时判断任意一个对象所属的类
  2. 在运行时构造一个类的对象
  3. 在运行时判断任意一个类所具有的成员变量和方法
  4. 在运行时调用任意一个对象的方法，生成动态代理
3. 与反射相关的类;
  1. Class：表示类
  2. Field：表示成员变量
  3. Method：表示方法
  4. Constructor：表示构造器
抽象类和接口的区别：
1. 抽象类中可以没有抽象方法；接口中的方法必须是抽象方法；
2. 抽象类中可以有普通的成员变量；接口中的变量必须是static final类型的，必须被初始化,接口中只有常量，没有变量！！！
3. 抽象类只能单继承，接口可以继承多个父接口；
特殊运算符
1. ~X表示的意思是：加1取反。 ~3=-4 ~-2=1
2. 移位运算符：<<和>>和>>>
字节流和字符流的区别：
1. 字节流处理单元为1个字节，操作字节和字节数组
2. 字符流处理单元为2个字节，操作字符、字符串或字符数组
3. 字节流用来处理二进制数据，因为要处理很多文本数据，所以提出了字符流
4. 字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的
5. 字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

正则表达式

四大方法：
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. 通过引擎对符合规则的子串进行取出操作

[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]（减去）

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

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

基本数据类型分别占多少字节
不使用新变量，交换两个变量的值，比如有两个变量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 ;
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#管理一枚。欢迎大家进来交流技术。

秒客网

Java基础拾遗（二）

相关文章

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