java面试基础篇思维导图

这是一篇关于java面试基础篇的思维导图，包含了 java设计的基础知识、java的四种引用，强弱软虚等内容

JAVA面试基础篇

• java设计的基础知识
  • 八种基本数据类型的大小,以及他们的封装类
    • byte 大小:1字节
    • short 大小:2字节
    • int 大小:4字节 封装类Integer
      • .int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个对象，再任何引用使用前，必须为其指定一个对象，否则会报错。
    • long 大小:8字节
    • float 大小:4字节
    • double 大小:8字节
    • boolean 大小:1字节
      • 虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。 在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位。 这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点
    • char 大小:2字节 (默认值\u0000(null)) 封装类Chatater
    • 除去int,char外其他的都是首字母变大写
  • 表示符的命名规则
    • 标识符的含义
      • 是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符
    • 命名规则
      • 标识符可以包含英文字母，0-9的数字，$以及_ 标识符不能以数字开头 标识符不是关键字
    • 命名规范
      • 类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。 方法名规范：同变量名。
  • java有哪些特点?5点
    • 1.易学易用有丰富的类库
    • 2.面向对象(让程序耦合度更低,内聚性更高)
    • 3.与平台无关(可以跨平台)
    • 4.安全可靠
    • 5.支持多线程
  • a=a+b与a+=b有什么区别吗
    • +=操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,而a=a+b则不会自动进行类型转换.如 byte a = 127; byte b = 127; b = a + b; // 报编译错误:cannot convert from int to byte b += a; 以下代码是否有错,有的话怎么改？ short s1= 1; s1 = s1 + 1 有错误.short类型在进行运算时会自动提升为int类型,也就是说s1+1的运算结果是int类型,而s1是short类型,此时编译器会报错. short s1= 1; s1 += 1; +=操作符会对右边的表达式结果强转匹配左边的数据类型,所以没错.
  • 3*0.1==0.3返回值是什么
    • false,因为有些浮点数不能完全精确的表示出来.
• Java的四种引用，强弱软虚
  • 强引用
    • 强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收，使用方式: String str = new String("str");
  • 弱引用
    • 弱引用就是只要JVM垃圾回收器发现了它，就会将之回收，使用方式： WeakReference wrf = new WeakReference(str); 可用场景： Java源码中的java.util.WeakHashMap中的key就是使用弱引用，我的理解就是，一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作
  • 软引用
    • 软引用(匿名对象)在程序内存不足时，会被回收，使用方式： // 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的， // 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T SoftReference wrf = new SoftReference(new String("str" 可用场景：创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。
  • 虚引用
    • 虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入ReferenceQueue中。 注意哦，其它引用是被JVM回收后才被传入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有ReferenceQueue，使用例子： PhantomReference prf = new PhantomReference(new String("str"), new ReferencQueue()); 可用场景：对象销毁前的一些操作，比如说资源释放等。**Object.finalize()虽然也可以做这类动作，但是这个方式即不安全又低效
• String
  • equals与==的区别
    • ==
      • == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作. 1、比较的是操作符两端的操作数是否是同一个对象。 2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。 3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。
    • equals
      • equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的， 所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断 总结：所有比较是否相等时，都是用equals 并且在对常量相比较时，把常量写在前面，因为使用object的equals object可能为null 则空指针在阿里的代码规范中只使用equals ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成equals
  • String、String StringBuffer 和 StringBuilder 的区别是什么?
• 类与对象
  • 面向对象和面向过程的区别
    • 面向对象
      • 是把构成问题的事务分解成各个对象,而建立对象的目的也不是为了完成一个个步骤. 而是为了描述某个事物在解决整个问题的过程中发生的行为. 面向对象 有封装,继承多态的特性, 所以优点是,易维护,易复用,易扩展,可以设计出低耦合的系统, 但是性能比面向过程要低
    • 面向过程
      • 面向过程就是:先分析解决问题的步骤,然后用函数把步骤一步步实现,然后在使用的时候调用就行. 优点:性能比较高,所以单片机,嵌入式等硬件易用采用面向过程开发
  • static都有哪些用法
    • 静态变量,方法
      • 被static所修饰的变量/方法都属于类的静态资源,类实例所共享.
    • 静态代码块
      • 用于静态块,多用于初始化操作: public calss PreCache{ static{ //执行相关操作 }}
    • 修饰内部类
      • 此时称之为静态内部类
    • 静态导包
      • ,即import static.import static是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名,可以直接使用资源名,比如: import static java.lang.Math.*;public class Test{ public static void main(String[] args){ //System.out.println(Math.sin(20)); 传统做法 System.out.println(sin(20)); }}
  • Java创建对象有几种方式？
    • new创建新对象
    • 通过反射机制
    • 采用clone机制
    • 通过序列化机制
• 封装,继承,多态
  • instanceof 关键字的作用
    • nstanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为 boolean result = obj instanceof Class 其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
  • java自动装箱与拆箱
    • 装箱
      • 装箱就是自动将基本数据类型转换为包装器类型（int-->Integer）；调用方法：Integer的valueOf(int) 方法 在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行： Integer i = new Integer(10) 而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了 Integer i = 10;
    • 拆箱
      • 拆箱就是自动将包装器类型转换为基本数据类型（Integer-->int）。调用方法：Integer的intValue方法
  • 重载与重写的区别
    • 重写
      • 从字面上看，重写就是重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法 但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下，对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。 1.发生在父类与子类之间 2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同 3.访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private) 4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异
    • 重载
      • 在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。 同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。 重载总结： 1.重载Overload是一个类中多态性的一种表现 2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序) 3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函
  • final有哪些用法?
    • 修饰类
      • 被final修饰的类不可以被继承 除此之外,编译器对final域要遵守的两个重排序规则更好:在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序.
    • 修饰方法
      • 被final修饰的方法不可以被重写 被final修饰的方法,JVM会尝试将其内联,以提高运行效率
    • 修饰变量
      • 被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
    • 修饰常量
      • 被final修饰的常量,在编译阶段会存入常量池中
  • java反射的作用与原理
    • 什么是反射?
      • 反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。在java中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。 这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制
    • 哪里会用到反射机制？
      • jdbc就是典型的反射 Class.forName('com.mysql.jdbc.Driver.class');//加载MySQL的驱动类 这就是反射。如hibernate，struts等框架使用反射实现的。
    • 反射的实现方式
      • 第一步：获取Class对象，有4中方法： 1）Class.forName(“类的路径”)； 2）类名.class 3）对象名.getClass() 4）基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象
    • 实现Java反射的类
      • 1）Class：表示正在运行的Java应用程序中的类和接口注意：所有获取对象的信息都需要Class类来实现。 2）Field：提供有关类和接口的属性信息，以及对它的动态访问权限。 3）Constructor：提供关于类的单个构造方法的信息以及它的访问权限 4）Method：提供类或接口中某个方法的信息
    • 反射机制的优缺点
      • 优点： 1） 能够运行时动态获取类的实例，提高灵活性； 2）与动态编译结合 缺点： 1）使用反射性能较低，需要解析字节码，将内存中的对象进行解析。解决方案： 1、通过setAccessible(true)关闭JDK的安全检查来提升反射速度； 2、多次创建一个类的实例时，有缓存会快很多 3、ReflectASM工具类，通过字节码生成的方式加快反射速度2）相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）
• 接口,内部类,与lambda
  • 深拷贝和浅拷贝的区别是什么?
    • 浅拷贝
      • 被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象. 换言之,浅拷贝仅仅复制所考虑的对象(变量),而不复制它所引用的对象
    • 深拷贝
      • 被复制对象的所有变量都含有与原来的对象相同的值.而那些引用其他对象的变量将指向被复制过的新对象.而不再是原有的那些被引用的对象.换言之. 深拷贝把要复制的对象所引用的对象都复制了一遍.
• 集合的问题
  • Hashcode的作用
    • java的集合有两类，一类是List，还有一类是Set。前者有序可重复，后者无序不重复。当我们在set中插入的时候怎么判断是否已经存在该元素呢，可以通过equals方法。但是如果元素太多，用这样的方法就会比较慢 于是有人发明了哈希算法来提高集合中查找元素的效率。这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。 hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次
  • 说说List,Set,Map三者的区别？
    • List
      • List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象
    • Set
      • 不允许重复的集合。不会有多个元素引用相同的对象
    • Map
      • 使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。
  • ArrayList和linkedList的区别
    • ArrayList
      • ArrayList底层的实现是Array, 可以看作是能够自动增长容量的数组,是通过数组扩容实现的 它的查找速度快,增删速度慢.因为这需要重排数组中的所有数据
    • LinkedList
      • LinkList是一个双链表, 在添加和删除元素时具有比ArrayList更好的性能. 但在get与set方面弱于ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。
  • Collection包结构，与Collections的区别
    • Collection
      • Collection是集合类的上级接口，子接口有 Set、List、LinkedList、ArrayList、Vector、Stack、Set
    • Collections
      • Collections是集合类的一个帮助类， 它包含有各种有关集合操作的静态多态方法， 用于实现对各种集合的搜索、排序、线程安全化等操作。 此类不能实例化，就像一个工具类，服务于Java的Collection框架
  • 泛型的常用特点
    • 泛型的定义
      • 泛型是Java SE 1.5之后的特性，《Java 核心技术》中对泛型的定义是： “泛型” 意味着编写的代码可以被不同类型的对象所重用
    • 泛型的概念
      • 泛型”，顾名思义，“泛指的类型”。我们提供了泛指的概念，但具体执行的时候却可以有具体的规则来约束，比如我们用的非常多的ArrayList就是个泛型类，ArrayList作为集合可以存放各种元素，如Integer, String，自定义的各种类型等，但在我们使用的时候通过具体的规则来约束，如我们可以约束集合中只存放Integer类型的元素，如 List iniData = new ArrayList()
    • 泛型的好处
      • 以集合来举例，使用泛型的好处是我们不必因为添加元素类型的不同而定义不同类型的集合，如整型集合类，浮点型集合类，字符串集合类，我们可以定义一个集合来存放整型、浮点型，字符串型数据，而这并不是最重要的，因为我们只要把底层存储设置了Object即可，添加的数据全部都可向上转型为Object。更重要的是我们可以通过规则按照自己的想法控制存储的数据类型。
  • 有没有可能两个不相等的对象有相同的hashcode
    • 有可能
      • 哈希表就像是一个数组 通过哈希函数计算哈希值,然后放到哈希表中 例如是余数法 h(item) =item % (槽的大小) 在产生hash冲突时,两个不相等的对象就会有相同的 hashcode 值.当hash冲突产生时,一般有以下几种方式来处理
    • 拉链法:
      • 每个哈希表节点都有一个next指针,多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表进行存储.
    • 开放定址法
      • 一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入
    • 再哈希
      • :又叫双哈希法,有多个不同的Hash函数.当发生冲突时,使用第二个,第三个....等哈希函数计算地址,直到无冲突.
  • HashMap和HashTable的区别
    • 1、两者父类不同
      • HashMap是继承自AbstractMap类，而Hashtable是继承自Dictionary类。不过它们都实现了同时实现了map、Cloneable（可复制）、Serializable（可序列化）这三个接口。
    • 2、对外提供的接口不同
      • Hashtable比HashMap多提供了elments() 和contains() 两个方法。 elments() 方法继承自Hashtable的父类Dictionnary。elements() 方法用于返回此Hashtable中的value的枚举。 contains()方法判断该Hashtable是否包含传入的value。它的作用与containsValue()一致。事实上，contansValue() 就只是调用了一下contains() 方法。
    • 3、对null的支持不同
      • Hashtable：key和value都不能为null。 HashMap：key可以为null，但是这样的key只能有一个，因为必须保证key的唯一性；可以有多个key值对应的value为null。
    • 4、安全性不同
      • HashMap是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。 Hashtable是线程安全的，它的每个方法上都有synchronized 关键字，因此可直接用于多线程中。 虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。 ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定
• IO流相关
  • Java 中 IO 流
    • Java 中 IO 流分为几种?
      • 按照流的流向分
        • 可以分为输入流和输出流；
      • 按照操作单元划分
        • 划分为字节流和字符流
      • 按照流的角色划分
        • 节点流和处理流。
      • 规律
        • Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的 InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。 OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
  • Java 序列化中如果有些字段不想进行序列化，怎么办？
    • 对于不想进行序列化的变量，使用 transient 关键字修饰。 transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量，不能修饰类和方法。
  • Java IO与 NIO的区别
• 异常相关
  • try catch finally，try里有return，finally还执行么？
    • 执行，并且finally的执行早于try里面的return
    • 结论
      • 1、不管有木有出现异常，finally块中代码都会执行； 2、当try和catch中有return时，finally仍然会执行； 3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的； 4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
  • OOM你遇到过哪些情况，SOF你遇到过哪些情况
    • OutOfMemoryError异常
      • 除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError(OOM)异常的可能。
      • Java Heap 溢出
        • 一般的异常信息：java.lang.OutOfMemoryError:Java heap spacess。 java堆用于存储对象实例，我们只要不断的创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，就会在对象数量达到最大堆容量限制后产生内存溢出异常。出现这种异常，一般手段是先通过内存映像分析工具(如Eclipse Memory Analyzer)对dump出来的堆转存快照进行分析，重点是确认内存中的对象是否是必要的，先分清是因为内存泄漏(Memory Leak)还是内存溢出(Memory Overflow)。如果是内存泄漏，可进一步通过工具查看泄漏对象到GCRoots的引用链。于是就能找到泄漏对象是通过怎样的路径与GC Roots相关联并导致垃圾收集器无法自动回收。如果不存在泄漏，那就应该检查虚拟机的参数(-Xmx与-Xms)的设置是否适当。
      • 虚拟机栈和本地方法栈溢出
        • 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常这里需要注意当栈的大小越大可分配的线程数就越少。
      • 运行时常量池溢出
        • 异常信息：java.lang.OutOfMemoryError:PermGenspace 如果要向运行时常量池中添加内容，最简单的做法就是使用String.intern()这个Native方法。该方法的作用是：如果池中已经包含一个等于此String的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并且返回此String对象的引用。由于常量池分配在方法区内，我们可以通过-XX:PermSize和-XX:MaxPermSize限制方法区的大小，从而间接限制其中常量池的容量。
      • 方法区溢出
        • 方法区用于存放Class的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等。 也有可能是方法区中保存的class对象没有被及时回收掉或者class信息占用的内存超过了我们配置。 异常信息：java.lang.OutOfMemoryError:PermGenspace方法区溢出也是一种常见的内存溢出异常，一个类如果要被垃圾收集器回收，判定条件是很苛刻的。在经常动态生成大量Class的应用中，要特别注意这点。
    • StackOverflowError 异常
      • 当应用程序递归太深而发生堆栈溢出时，抛出该错误。 因为栈一般默认为1-2m，一旦出现死循环或者是大量的递归调用，在不断的压栈过程中，造成栈容量超过1m而导致溢出。栈溢出的原因：递归调用，大量循环或死循环，全局变量是否过多，数组、List、map数据过大。
  • Excption与Error包结构
• 多线程
  • 简述线程、程序、进程的基本概念。以及他们之间关系是什么?
    • 线程
      • 与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
    • 程序
      • 是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码
    • 进程
      • 是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段
  • 线程有哪些基本状态?