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这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!这样就会造成空间的浪费。
    4. ConcurrentHashMap和HashTable的区别? 
      1. ConcurrentHashMap结合了HashMap和HashTable二者的优势。HashMap没有考虑同步,hashtable考虑了同步的问题。但是hashtable在每次同步执行时都要锁住整个结构。 ConcurrentHashMap锁的方式是稍微细粒度的。 ConcurrentHashMap将hash表分为16个桶(默认值),诸如get,put,remove等常用操作只锁当前需要用到的桶。
    5. ConcurrentHashMap的具体实现方式:
      1. 该类包含两个静态内部类HashEntrySegment
      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#管理一枚。欢迎大家进来交流技术。




你可能感兴趣的:(Java,学习总结,Java干货交流区)