适宜阅读人群需要面试的初/中/高级 java 程序员想要查漏补缺的人想要不断完善和扩充自己 java 技术栈的人java 面试官具体面试题下面一起来看 208 道面试题，具体的内容。一、Java 基础1.JDK 和 JRE 有什么区别？2.== 和 equals 的区别是什么？3.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？4.final 在 java 中有什么作用？5.java 中的 Math.round(-1.5) 等于多少？6.String 属于基础的数据类型吗？7.java 中操作字符串都有哪些类？它们之间有什么区别？8.String str="i"与 String str=new String("i")一样吗？9.如何将字符串反转？10.String 类的常用方法都有那些？11.抽象类必须要有抽象方法吗？12.普通类和抽象类有哪些区别？13.抽象类能使用 final 修饰吗？14.接口和抽象类有什么区别？15.java 中 IO 流分为几种？16.BIO、NIO、AIO 有什么区别？17.Files的常用方法都有哪些？二、容器18.java 容器都有哪些？19.Collection 和 Collections 有什么区别？20.List、Set、Map 之间的区别是什么？21.HashMap 和 Hashtable 有什么区别？22.如何决定使用 HashMap 还是 TreeMap？23.说一下 HashMap 的实现原理？24.说一下 HashSet 的实现原理？25.ArrayList 和 LinkedList 的区别是什么？26.如何实现数组和 List 之间的转换？27.ArrayList 和 Vector 的区别是什么？28.Array 和 ArrayList 有何区别？29.在 Queue 中 poll()和 remove()有什么区别？30.哪些集合类是线程安全的？31.迭代器 Iterator 是什么？32.Iterator 怎么使用？有什么特点？33.Iterator 和 ListIterator 有什么区别？34.怎么确保一个集合不能被修改？三、多线程35.并行和并发有什么区别？36.线程和进程的区别？37.守护线程是什么？38.创建线程有哪几种方式？39.说一下 runnable 和 callable 有什么区别？40.线程有哪些状态？41.sleep() 和 wait() 有什么区别？42.notify()和 notifyAll()有什么区别？43.线程的 run()和 start()有什么区别？44.创建线程池有哪几种方式？45.线程池都有哪些状态？46.线程池中 submit()和 execute()方法有什么区别？47.在 java 程序中怎么保证多线程的运行安全？48.多线程锁的升级原理是什么？49.什么是死锁？50.怎么防止死锁？51.ThreadLocal 是什么？有哪些使用场景？52.说一下 synchronized 底层实现原理？53.synchronized 和 volatile 的区别是什么？54.synchronized 和 Lock 有什么区别？55.synchronized 和 ReentrantLock 区别是什么？56.说一下 atomic 的原理？四、反射57.什么是反射？58.什么是 java 序列化？什么情况下需要序列化？59.动态代理是什么？有哪些应用？60.怎么实现动态代理？五、对象拷贝61.为什么要使用克隆？62.如何实现对象克隆？63.深拷贝和浅拷贝区别是什么？六、Java Web64.jsp 和 servlet 有什么区别？65.jsp 有哪些内置对象？作用分别是什么？66.说一下 jsp 的 4 种作用域？67.session 和 cookie 有什么区别？68.说一下 session 的工作原理？69.如果客户端禁止 cookie 能实现 session 还能用吗？70.spring mvc 和 struts 的区别是什么？71.如何避免 sql 注入？72.什么是 XSS 攻击，如何避免？73.什么是 CSRF 攻击，如何避免？七、异常74.throw 和 throws 的区别？75.final、finally、finalize 有什么区别？76.try-catch-finally 中哪个部分可以省略？77.try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？78.常见的异常类有哪些？八、网络79.http 响应码 301 和 302 代表的是什么？有什么区别？80.forward 和 redirect 的区别？81.简述 tcp 和 udp的区别？82.tcp 为什么要三次握手，两次不行吗？为什么？83.说一下 tcp 粘包是怎么产生的？84.OSI 的七层模型都有哪些？85.get 和 post 请求有哪些区别？86.如何实现跨域？87.说一下 JSONP 实现原理？九、设计模式88.说一下你熟悉的设计模式？89.简单工厂和抽象工厂有什么区别？十、Spring/Spring MVC90.为什么要使用 spring？91.解释一下什么是 aop？92.解释一下什么是 ioc？93.spring 有哪些主要模块？94.spring 常用的注入方式有哪些？95.spring 中的 bean 是线程安全的吗？96.spring 支持几种 bean 的作用域？97.spring 自动装配 bean 有哪些方式？98.spring 事务实现方式有哪些？99.说一下 spring 的事务隔离？100.说一下 spring mvc 运行流程？101.spring mvc 有哪些组件？102.@RequestMapping 的作用是什么？103.@Autowired 的作用是什么？十一、Spring Boot/Spring Cloud104.什么是 spring boot？105.为什么要用 spring boot？106.spring boot 核心配置文件是什么？107.spring boot 配置文件有哪几种类型？它们有什么区别？108.spring boot 有哪些方式可以实现热部署？109.jpa 和 hibernate 有什么区别？110.什么是 spring cloud？111.spring cloud 断路器的作用是什么？112.spring cloud 的核心组件有哪些？十二、Hibernate113.为什么要使用 hibernate？114.什么是 ORM 框架？115.hibernate 中如何在控制台查看打印的 sql 语句？116.hibernate 有几种查询方式？117.hibernate 实体类可以被定义为 final 吗？118.在 hibernate 中使用 Integer 和 int 做映射有什么区别？119.hibernate 是如何工作的？120.get()和 load()的区别？121.说一下 hibernate 的缓存机制？122.hibernate 对象有哪些状态？123.在 hibernate 中 getCurrentSession 和 openSession 的区别是什么？124.hibernate 实体类必须要有无参构造函数吗？为什么？十三、Mybatis125.mybatis 中 #{}和 ${}的区别是什么？126.mybatis 有几种分页方式？127.RowBounds 是一次性查询全部结果吗？为什么？128.mybatis 逻辑分页和物理分页的区别是什么？129.mybatis 是否支持延迟加载？延迟加载的原理是什么？130.说一下 mybatis 的一级缓存和二级缓存？131.mybatis 和 hibernate 的区别有哪些？132.mybatis 有哪些执行器（Executor）？133.mybatis 分页插件的实现原理是什么？134.mybatis 如何编写一个自定义插件？十四、RabbitMQ135.rabbitmq 的使用场景有哪些？136.rabbitmq 有哪些重要的角色？137.rabbitmq 有哪些重要的组件？138.rabbitmq 中 vhost 的作用是什么？139.rabbitmq 的消息是怎么发送的？140.rabbitmq 怎么保证消息的稳定性？141.rabbitmq 怎么避免消息丢失？142.要保证消息持久化成功的条件有哪些？143.rabbitmq 持久化有什么缺点？144.rabbitmq 有几种广播类型？145.rabbitmq 怎么实现延迟消息队列？146.rabbitmq 集群有什么用？147.rabbitmq 节点的类型有哪些？148.rabbitmq 集群搭建需要注意哪些问题？149.rabbitmq 每个节点是其他节点的完整拷贝吗？为什么？150.rabbitmq 集群中唯一一个磁盘节点崩溃了会发生什么情况？151.rabbitmq 对集群节点停止顺序有要求吗？十五、Kafka152.kafka 可以脱离 zookeeper 单独使用吗？为什么？153.kafka 有几种数据保留的策略？154.kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？155.什么情况会导致 kafka 运行变慢？156.使用 kafka 集群需要注意什么？十六、Zookeeper157.zookeeper 是什么？158.zookeeper 都有哪些功能？159.zookeeper 有几种部署模式？160.zookeeper 怎么保证主从节点的状态同步？161.集群中为什么要有主节点？162.集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还可以使用吗？163.说一下 zookeeper 的通知机制？十七、MySql164.数据库的三范式是什么？165.一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 mysql 数据库，又插入了一条数据，此时 id 是几？166.如何获取当前数据库版本？167.说一下 ACID 是什么？168.char 和 varchar 的区别是什么？169.float 和 double 的区别是什么？170.mysql 的内连接、左连接、右连接有什么区别？171.mysql 索引是怎么实现的？172.怎么验证 mysql 的索引是否满足需求？173.说一下数据库的事务隔离？174.说一下 mysql 常用的引擎？175.说一下 mysql 的行锁和表锁？176.说一下乐观锁和悲观锁？177.mysql 问题排查都有哪些手段？178.如何做 mysql 的性能优化？十八、Redis179.redis 是什么？都有哪些使用场景？180.redis 有哪些功能？181.redis 和 memecache 有什么区别？182.redis 为什么是单线程的？183.什么是缓存穿透？怎么解决？184.redis 支持的数据类型有哪些？185.redis 支持的 java 客户端都有哪些？186.jedis 和 redisson 有哪些区别？187.怎么保证缓存和数据库数据的一致性？188.redis 持久化有几种方式？189.redis 怎么实现分布式锁？190.redis 分布式锁有什么缺陷？191.redis 如何做内存优化？192.redis 淘汰策略有哪些？193.redis 常见的性能问题有哪些？该如何解决？十九、JVM194.说一下 jvm 的主要组成部分？及其作用？195.说一下 jvm 运行时数据区？196.说一下堆栈的区别？197.队列和栈是什么？有什么区别？198.什么是双亲委派模型？199.说一下类加载的执行过程？200.怎么判断对象是否可以被回收？201.java 中都有哪些引用类型？202.说一下 jvm 有哪些垃圾回收算法？203.说一下 jvm 有哪些垃圾回收器？204.详细介绍一下 CMS 垃圾回收器？205.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？206.简述分代垃圾回收器是怎么工作

最近在备战面试的过程中，整理一下面试题。大多数题目都是自己手敲的，网上也有很多这样的总结。自己感觉总是很乱，所以花了很久把自己觉得重要的东西总结了一下。面向对象和面向过程的区别面向过程：   优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。缺点：没有面向对象易维护、易复用、易扩展面向对象：   优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护缺点：性能比面向过程低Java语言有哪些特点？1. 简单易学；2. 面向对象（封装，继承，多态）；3. 平台无关性（Java虚拟机实现平台无关性）；4. 可靠性；5. 安全性；6. 支持多线程（C++语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而Java语言却提供了多线程支持）；7. 支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的，因此Java语言不仅支持网络编程而且很方便）；8. 编译与解释并存；什么是字节码？采用字节码的最大好处是什么？什么Java是虚拟机？先看下java中的编译器和解释器：   Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行，这就是上面提到的Java的特点的编译与解释并存的解释。 Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。采用字节码的好处：   Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。什么是Java虚拟机：任何一种可以运行Java字节码的软件均可看成是Java的虚拟机（JVM）什么是Java程序的主类？应用程序和小程序的主类有何不同？一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main（）方法的类。而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。什么是JDK?什么是JRE？JDK: 顾名思义它是给开发者提供的开发工具箱,是给程序开发者用的。它除了包括完整的JRE（Java Runtime Environment），Java运行环境，还包含了其他供开发者使用的工具包。 JRE:普通用户而只需要安装JRE（Java Runtime Environment）来 来运行Java程序。而程序开发者必须安装JDK来编译、调试程序。环境变量Path和ClassPath的作用是什么？如何设置这两个环境变量？Java环境变量PATH和CLASSPATH - 简书 http://www.jianshu.com/p/d63b099cf283Java应用程序与小程序之间有那些差别？简单说应用程序是从主线程启动(也就是main()方法)。applet小程序没有main方法，主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动)，嵌入浏览器这点跟flash的小游戏类似。字符型常量和字符串常量的区别形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符含义上: 字符常量相当于一个整形值(ASCII值),可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)占内存大小 字符常量只占一个字节 字符串常量占若干个字节(至少一个字符结束标志)Java语言采用何种编码方案？有何特点？Java语言采用Unicode编码标准，Unicode（标准码），它为每个字符制订了一个唯一的数值，因此在任何的语言，平台，程序都可以放心的使用。构造器Constructor是否可被override在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以Constructor也就不能被override,但是可以overload,所以你可以看到一个类中有多个构造函数的情况。重载和重写的区别重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。   重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；如果父类方法访问修饰符为private则子类中就不是重写。java 面向对象编程三大特性------封装、继承、多态blog.csdn.net/jianyuerens…java中equals方法的用法以及==的用法www.cnblogs.com/bluestorm/a…String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？可变性  String类中使用字符数组保存字符串，private final char value[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[]value，这两种对象都是可变的。   线程安全性String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。   性能每次对String 类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。 对于三者使用的总结： 如果要操作少量的数据用 = String 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer自动装箱与拆箱装箱：将基本类型用它们对应的引用类型包装起来；拆箱：将包装类型转换为基本数据类型；   Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率，由编译器来完成，编译器会在编译期根据语法决定是否进行装箱和拆箱动作。类、方法、成员变量和局部变量的可用修饰符 -blog.csdn.net/yttcjj/arti…在一个静态方法内调用一个非静态成员为什么是非法的？由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。在Java中定义一个不做事且没有参数的构造方法的作用Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。import java和javax有什么区别www.cnblogs.com/EasonJim/p/…接口和抽象类的区别是什么？1.接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法 2.接口中的实例变量默认是final类型的，而抽象类中则不一定 3.一个类可以实现多个接口，但最多只能实现一个抽象类 4.一个类实现接口的话要实现接口的所有方法，而抽象类不一定 5.接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。成员变量与局部变量的区别有那些？从语法形式上，看成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；成员变量和局部变量都能被final所修饰；从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值。创建一个对象用什么运算符？对象实体与对象引用有何不同？new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）什么是方法的返回值？返回值在类的方法里的作用是什么？方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！一个类的构造方法的作用是什么？若一个类没有声明构造方法，改程序能正确执行吗？为什么？主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。构造方法有哪些特性？1. 名字与类名相同；2. 没有返回值，但不能用void声明构造函数；3. 生成类的对象时自动执行，无需调用。静态方法和实例方法有何不同？静态方法和实例方法的区别主要体现在两个方面：在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制对象的相等与指向他们的引用相等，两者有什么不同？对象的相等 比的是内存中存放的内容是否相等而 引用相等 比较的是他们指向的内存地址是否相等。在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？帮助子类做初始化工作。什么是多态机制？Java语言是如何实现多态的？blog.csdn.net/bornlili/ar…equals 和 == 的区别？通俗点讲：==是看看左右是不是一个东西。equals是看看左右是不是长得一样。如何记住嘛。如果单纯是想记住，==：等于。equals：相同。两个长得一样的人，只能说长的相同(equals)，但是不等于他们俩是一个人。你只要记住equals，==就不用记了。术语来讲的

一、Java基础部分1. HashMap和Hashtable各有什么特点，它们有什么区别？（必背题，超级重要）HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。HashMap不能保证随着时间的推移Map中的元素次序是不变的。2. HashMap的工作原理？HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。当两个不同的键对象的hashcode相同时会发生什么？ 它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。1和2参考博客链接这里还有许多相关问题的描述，都是比较重要的！建议将其背熟！3. ArrayList和LinkList各自的特点和区别？1、ArrayList和LinkedList可想从名字分析，它们一个是Array(动态数组)的数据结构，一个是Link(链表)的数据结构，此外，它们两个都是对List接口的实现。前者是数组队列，相当于动态数组；后者为双向链表结构，也可当作堆栈、队列、双端队列2、当随机访问List时（get和set操作），ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。3、当对数据进行增加和删除的操作时(add和remove操作)，LinkedList比ArrayList的效率更高，因为ArrayList是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。4、从利用效率来看，ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。5、ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。4. RESTFul风格接口的特点？此题是现在做应用开发常问的题目，RestFul风格在现在的应用开发还是比较常用的，所以还是比较重要，建议进行了解：以下是作者自认为不错的一篇关于RestFul架构风格的博客，推荐！博客·链接5. 面向对象的七种设计原则面向对象七大设计原则：1、 开闭原则（OCP：Open Closed Principle）核心：对扩展开放，对修改关闭。即在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。根据开闭原则，在设计一个软件系统模块（类，方法）的时候，应该可以在不修改原有的模块（修改关闭）的基础上，能扩展其功能（扩展开放）。2、 里氏替换原则（LSP：Liskov Substitution Principle）核心：在任何父类出现的地方都可以用他的子类来替代（子类应当可以替换父类并出现在父类能够出现的任何地方）1.子类必须完全实现父类的方法。在类中调用其他类是务必要使用父类或接口，如果不能使用父类或接口，则说明类的设计已经违背了LSP原则。2.子类可以有自己的个性。子类当然可以有自己的行为和外观了，也就是方法和属性3.覆盖或实现父类的方法时输入参数可以被放大。即子类可以重载父类的方法，但输入参数应比父类方法中的大，这样在子类代替父类的时候，调用的仍然是父类的方法。即以子类中方法的前置条件必须与超类中被覆盖的方法的前置条件相同或者更宽松。4.覆盖或实现父类的方法时输出结果可以被缩小。3、 单一职责原则（SRP：Single responsibility principle）核心：解耦和增强内聚性（高内聚，低耦合）类被修改的几率很大，因此应该专注于单一的功能。如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题。4、 接口隔离原则(ISP：Interface Segregation Principle)核心思想：不应该强迫客户程序依赖他们不需要使用的方法。接口分离原则的意思就是：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口当中.分离接口的两种实现方法：1.使用委托分离接口。（Separation through Delegation）2.使用多重继承分离接口。（Separation through Multiple Inheritance）5、 依赖倒置原则(DIP：Dependence Inversion Principle)核心：要依赖于抽象，不要依赖于具体的实现1.高层模块不应该依赖低层模块，两者都应该依赖其抽象（抽象类或接口）2.抽象不应该依赖细节（具体实现）3.细节（具体实现）应该依赖抽象。三种实现方式:1.通过构造函数传递依赖对象2.通过setter方法传递依赖对象3.接口声明实现依赖对象6、 迪米特原则(最少知识原则)（LOD：Law of Demeter）核心思想：一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。（类间解耦，低耦合）意思就是降低各个对象之间的耦合，提高系统的可维护性；在模块之间只通过接口来通信，而不理会模块的内部工作原理，可以使各个模块的耦合成都降到最低，促进软件的复用注：1.在类的划分上，应该创建有弱耦合的类；2.在类的结构设计上，每一个类都应当尽量降低成员的访问权限；3.在类的设计上，只要有可能，一个类应当设计成不变；4.在对其他类的引用上，一个对象对其它对象的引用应当降到最低；5.尽量降低类的访问权限；6.谨慎使用序列化功能；7.不要暴露类成员，而应该提供相应的访问器(属性)7、 组合/聚合复用原则（CRP：Composite Reuse Principle）核心思想：尽量使用对象组合，而不是继承来达到复用的目的。该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。复用的种类：1.继承2.合成聚合注：在复用时应优先考虑使用合成聚合而不是继承6. 谈谈堆和栈的区别！a.堆栈空间分配栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表b.堆栈缓存方式栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。c.堆栈数据结构区别堆（数据结构）：堆可以被看成是一棵树，如：堆排序。栈（数据结构）：一种先进后出的数据结构。7. 谈谈你所了解的设计模式，并简单描述其特点和用法，或简单写一个某某设计模式！1. 单例设计模式2. 工厂设计模式3. 代理模式4. 观察者设计模式5. 适配器模式6. 策略模式7. 门面模式8. 桥接模式来一个参考链接几种常用的设计模式参考博客链接注：设计模式有很多，这里列举几种常用的！读者需要自行将这几种设计模式理解清楚！前五种是常用也是常考的！8. 熟悉HTTP基本的状态码！一些常见的状态码为：200 - 服务器成功返回网页404 - 请求的网页不存在503 - 服务不可用具体详细的可以参考博客 HTTP状态码详细博客链接9. List、Set和Map的特点和区别（重点）List：1.可以允许重复的对象。2.可以插入多个null元素。3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。4.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。Set：1.不允许重复对象2.无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。3.只允许一个 null 元素4.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。Map：1.不是collection的子接口或者实现类。Map是一个接口。2.Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。3.TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。4.Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。5.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）10.监听器、过滤器、拦截器、servlet的区别eb.xml 的加载顺序是：context- param -> listener -> filter -> servlet监听器（listener）：在request、session、application三个对象创建消亡或者往其中增/删/改属性时自动执行指定代码的功能组件。生命周期：随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。作用：做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。过滤器（filter）：拦截请求，filter能够在一个请求到达控制层之前预处理用户请求，也可以在离开控制层时处理http 响应,进行一些设置以及逻辑判断,然后再传入servlet或者struts的 action进行业务逻辑，基于函数回调。生命周期：它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当

又是金三银四的时候，我希望这份面试题能够祝你一臂之力！自我和项目相关1、自我介绍2、你觉得自己的优点是？你觉得自己有啥缺点？3、你有哪些 offer？4、你为什么要离开上家公司？你上家公司在xxx，我们公司在xxx，离这么远为什么要选择我们这里？5、上家公司的同事和领导是怎么评价你的？6、介绍下你的上家公司是做哪块的吧7、在上家公司你做了哪些项目？8、你在项目中是什么角色？9、这个项目的数据量和并发量多大？10、这个项目用的什么技术？11、项目过程中有遇到什么很印象深刻的问题吗？12、是怎么解决的这些问题？13、项目有没有还可以继续优化的地方？14、该怎么优化？有什么思路没？15、叫你设计一个并发xxx，数据存储量xxx 量级的系统，你该如何设计？从你知道的点尽可能的多说出些？Java 基础1、Object 对象的方法有哪些？分别有什么作用？该什么场景用？2、Integer 的常量缓存池3、Java 特性？什么是多态？举个例子4、重载重写的区别？5、画下 HashMap 的结构图？HashMap 、 HashTable 和 ConcurrentHashMap 的区别？使用场景分别是？6、HashMap 中怎么解决冲突的？7、ConcurrentHashMap 和 HashTable 中线程安全的区别？为啥建议用 ConcurrentHashMap ？能把 ConcurrentHashMap 里面的实现详细的讲下吗？8、保证线程安全的还有其他的方式吗？9、讲下 Synchronized？10、讲下 ReentrantLock 可重入锁？ 什么是可重入锁？为什么要设计可重入锁？11、Synchronized 和 ReentrantLock 有什么区别？这两个有没有深入了解源码？12、讲下 Volatile 吧？他是怎样做到同步的？13、Volatile 为什么不支持原子性？举个例子14、Atomic 怎么设计的？有用过里面的类吗？15、线程安全类和线程不安全的类，项目使用的时候你会怎么选择？怎么判断项目代码哪里会有线程不安全问题？16、Map、List、Set 分别说下你了解到它们有的线程安全类和线程不安全的类？17、TreeSet 清楚吗？能详细说下吗？18、ThreadLocal 了解吗？项目有用过吗？可以说说19、JUC 里面你还知道什么其他的类吗？比如 CountDownLatch、Condition20、从源码详细说下 Java 里面的线程池吧，使用线程池有什么要注意的地方？你们公司有规范吗？JVM1、JAVA 类加载器2、Java 内存结构（注：不是 Java 内存模型，别搞混）3、怎么判断对象是否可 GC？Java 对象有哪些引用类型？有什么区别？4、OOM 出现的有哪些场景？为什么会发生？5、Minor GC 和 Full GC 有什么区别？分析过 GC 日志吗？6、说下你知道的垃圾回收算法7、说下你知道的垃圾收集器8、CMS 和 G1 的区别知道吗？使用场景分别是？你项目中用的是哪个？9、你还知道哪些 JVM 调优参数？10、假如线上服务发生 OOM，有哪些措施可以找到问题？11、假如线上服务 CPU 很高该怎么做？有哪些措施可以找到问题？12、假如线上应用频繁发生 Full GC，有哪些措施可以找到问题？13、一般线上环境遇到 JVM 问题，你会使用哪些工具来分析？找到问题后又该如何去解决呢？Spring1、说下你对 Spring 生态的了解？2、说下你对 Spring AOP 和 IOC 的理解？看过实现原理吗？3、说下 Bean 在 Spring 中的生命周期？4、讲下你知道的 Spring 注解有哪些？该什么场景使用？5、Spring 事务知道吗？有了解过吗？6、说下你刚才说的 SpringBoot 吧，你觉得 SpringBoot 有什么优点？7、SpringBoot 自动化配置是怎么做的？有看过实现源码吗？8、Spring Boot 中最核心的注解 SpringBootApplication 有看过源码分析过吗？9、你的项目中 SpringBoot 用到了哪些和其他技术栈整合的？10、使用 Spring 或者 SpringBoot 有遇到过什么印象深刻的问题吗？当时是怎么解决的？数据库1、你的项目使用的是什么数据库？2、你对数据库了解多少？说下数据库的索引实现和非主键的二级索引3、说下 MySQL 的索引原理4、讲下 InnoDB 和 MyISAM 的区别？使用场景是？5、有和 ElasticSearch 的索引原理对比过吗？6、如何判断一个查询 sql 语句是否使用了索引？7、数据库事务特性和隔离级别8、项目数据库表是你设计的吗？一般要注意什么？如何考虑扩展性？9、项目 MySQL 的数据量和并发量有多大？量大后的影响有哪些，有考虑吗？SQL 调优有哪些技巧？10、说下你项目里面关于数据库印象最深的一个问题？当时是怎么解决的其他1、描述下网页一个 Http 请求到 www.54tianzhisheng.cn/，到后端的整个请求过程2、有比较过 Http 和 RPC 吗？如果叫你设计一个高性能的 Http 或者 RPC，你会从哪些方面考虑？3、项目中我看使用了 xxx （ElasticSearch、Hbase、Redis、Flink 等），有深入了解它们的原理和懂点调优技巧吗？4、项目中我看使用了 xxx （ElasticSearch、Hbase、Redis、Mysql 等），有深入了解它们数据同步是怎么做吗？5、项目中我看使用了 xxx （ElasticSearch、Hbase、Redis、Mysql 等），有深入了解它们常见的监控指标吗？6、如果叫你设计一个秒杀系统，你会从哪些方面考虑？7、如果叫你设计一个电商系统，你会从哪些方面考虑？8、如果叫你设计一个监控告警系统，你会从哪些方面考虑？总结本文的面试题以 HR & 技术官角度常问的面试题，技术方面从 Java 基础、JVM、Spring、数据库、拓展题等方面考察你，当然面试官可能还会问些其他的技术点，我一篇文章也难以概全。总的来说，还是得多准备充分，面试时灵活答辩，相信你最后能拿到满意的 offer！加油，骚年！

1、什么是Mybatis？（1）Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。（2）MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。（3）通过xml 文件或注解的方式将要执行的各种 statement 配置起来，并通过java对象和 statement中sql的动态参数进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射为java对象并返回。（从执行sql到返回result的过程）。2、Mybaits的优点：（1）基于SQL语句编程，相当灵活，不会对应用程序或者数据库的现有设计造成任何影响，SQL写在XML里，解除sql与程序代码的耦合，便于统一管理；提供XML标签，支持编写动态SQL语句，并可重用。（2）与JDBC相比，减少了50%以上的代码量，消除了JDBC大量冗余的代码，不需要手动开关连接；（3）很好的与各种数据库兼容（因为MyBatis使用JDBC来连接数据库，所以只要JDBC支持的数据库MyBatis都支持）。（4）能够与Spring很好的集成；（5）提供映射标签，支持对象与数据库的ORM字段关系映射；提供对象关系映射标签，支持对象关系组件维护。3、MyBatis框架的缺点：（1）SQL语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求。（2）SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。4、MyBatis框架适用场合：（1）MyBatis专注于SQL本身，是一个足够灵活的DAO层解决方案。（2）对性能的要求很高，或者需求变化较多的项目，如互联网项目，MyBatis将是不错的选择。5、MyBatis与Hibernate有哪些不同？（1）Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句。（2）Mybatis直接编写原生态sql，可以严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，因为这类软件需求变化频繁，一但需求变化要求迅速输出成果。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件，则需要自定义多套sql映射文件，工作量大。 （3）Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件，如果用hibernate开发可以节省很多代码，提高效率。 6、#{}和${}的区别是什么？#{}是预编译处理，${}是字符串替换。Mybatis在处理#{}时，会将sql中的#{}替换为?号，调用PreparedStatement的set方法来赋值；Mybatis在处理${}时，就是把${}替换成变量的值。使用#{}可以有效的防止SQL注入，提高系统安全性。7、当实体类中的属性名和表中的字段名不一样 ，怎么办 ？第1种： 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。1     <select id=”selectorder” parametertype=”int” resultetype=”me.gacl.domain.order”>2 select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};3 </select>第2种： 通过<resultMap>来映射字段名和实体类属性名的一一对应的关系。1 <select id="getOrder" parameterType="int" resultMap="orderresultmap">2 select * from orders where order_id=#{id}3 </select>45 <resultMap type=”me.gacl.domain.order” id=”orderresultmap”>6 <!–用id属性来映射主键字段–>7 <id property=”id” column=”order_id”>89 <!–用result属性来映射非主键字段，property为实体类属性名，column为数据表中的属性–>10 <result property = “orderno” column =”order_no”/>11 <result property=”price” column=”order_price” />12 </reslutMap>8、 模糊查询like语句该怎么写?第1种：在Java代码中添加sql通配符。1 string wildcardname = “%smi%”;2 list<name> names = mapper.selectlike(wildcardname);34 <select id=”selectlike”>5 select * from foo where bar like #{value}6 </select>第2种：在sql语句中拼接通配符，会引起sql注入1 string wildcardname = “smi”;2 list<name> names = mapper.selectlike(wildcardname);34 <select id=”selectlike”>5      select * from foo where bar like "%"#{value}"%"6 </select>9、通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？Dao接口即Mapper接口。接口的全限名，就是映射文件中的namespace的值；接口的方法名，就是映射文件中Mapper的Statement的id值；接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MapperStatement。在Mybatis中，每一个<select>、<insert>、<update>、<delete>标签，都会被解析为一个MapperStatement对象。举例：com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面 id 为 findStudentById 的 MapperStatement。Mapper接口里的方法，是不能重载的，因为是使用 全限名+方法名 的保存和寻找策略。Mapper 接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Mapper接口生成代理对象proxy，代理对象会拦截接口方法，转而执行MapperStatement所代表的sql，然后将sql执行结果返回。10、Mybatis是如何进行分页的？分页插件的原理是什么？Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。11、Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？第一种是使用<resultMap>标签，逐一定义数据库列名和对象属性名之间的映射关系。第二种是使用sql列的别名功能，将列的别名书写为对象属性名。有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。12、如何执行批量插入?首先,创建一个简单的insert语句:1 <insert id=”insertname”>2     insert into names (name) values (#{value})3 </insert> 然后在java代码中像下面这样执行批处理插入:1 list<string> names = new arraylist();2 names.add(“fred”);3 names.add(“barney”);4 names.add(“betty”);5 names.add(“wilma”);67 // 注意这里 executortype.batch8 sqlsession sqlsession = sqlsessionfactory.opensession(executortype.batch);9 try {10 namemapper mapper = sqlsession.getmapper(namemapper.class);11 for (string name : names) {12 mapper.insertname(name);13 }14 sqlsession.commit();15 }catch(Exception e){16 e.printStackTrace();17 sqlSession.rollback();18 throw e;19     }20     finally {21     sqlsession.close();22 }13、如何获取自动生成的(主)键值?insert 方法总是返回一个int值 ，这个值代表的是插入的行数。如果采用自增长策略，自动生成的键值在 insert 方法执行完后可以被设置到传入的参数对象中。示例：1 <insert id=”insertname” usegeneratedkeys=”true” keyproperty=”id”>2 insert into names (name) values (#{name})3 </insert> 1     name name = new name();2 name.setname(“fred”);34 int rows = mapper.insertname(name);5 // 完成后,id已经被设置到对象中6 system.out.println(“rows inserted = ” + rows);7 system.out.println(“generated key value = ” + name.getid());14、在mapper中如何传递多个参数?1 （1）第一种：2 //DAO层的函数3 Public UserselectUser(String name,String area);4 //对应的xml,#{0}代表

1、#{}和${}的区别是什么？#{}和${}的区别是什么？在Mybatis中，有两种占位符#{}解析传递进来的参数数据${}对传递进来的参数原样拼接在SQL中#{}是预编译处理，${}是字符串替换。使用#{}可以有效的防止SQL注入，提高系统安全性。2、当实体类中的属性名和表中的字段名不一样 ，怎么办 ？当实体类中的属性名和表中的字段名不一样 ，怎么办 ？第1种： 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致1 <select id=”selectorder” parametertype=”int” resultetype=”me.gacl.domain.order”>2 select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};3 </select>第2种： 通过来映射字段名和实体类属性名的一一对应的关系1 <select id="getOrder" parameterType="int" resultMap="orderresultmap">2 select * from orders where order_id=#{id}3 </select>4 <resultMap type=”me.gacl.domain.order” id=”orderresultmap”>5 <!–用id属性来映射主键字段–>6 <id property=”id” column=”order_id”>7 <!–用result属性来映射非主键字段，property为实体类属性名，column为数据表中的属性–>8 <result property = “orderno” column =”order_no”/>9 <result property=”price” column=”order_price” />10 </reslutMap>我认为第二种方式会好一点。3、如何获取自动生成的(主)键值?如何获取自动生成的(主)键值?如果我们一般插入数据的话，如果我们想要知道刚刚插入的数据的主键是多少，我们可以通过以下的方式来获取需求：user对象插入到数据库后，新记录的主键要通过user对象返回，通过user获取主键值。解决思路：通过LAST_INSERT_ID()获取刚插入记录的自增主键值，在insert语句执行后，执行select LAST_INSERT_ID()就可以获取自增主键。mysql:1 <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">2 <selectKey keyProperty="id" order="AFTER" resultType="int">3 select LAST_INSERT_ID()4 </selectKey>5 INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})6 </insert>oracle:实现思路：先查询序列得到主键，将主键设置到user对象中，将user对象插入数据库。1 <!-- oracle2 在执行insert之前执行select 序列.nextval() from dual取出序列最大值，将值设置到user对象 的id属性3 -->4 <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">5 <selectKey keyProperty="id" order="BEFORE" resultType="int">6 select 序列.nextval() from dual7 </selectKey>89 INSERT INTO USER(id,username,birthday,sex,address) VALUES( 序列.nextval(),#{username},#{birthday},#{sex},#{address})10 </insert>4、在mapper中如何传递多个参数?在mapper中如何传递多个参数?第一种：使用占位符的思想在映射文件中使用#{0},#{1}代表传递进来的第几个参数**使用@param注解:来命名参数 **#{0},#{1}方式1 //对应的xml,#{0}代表接收的是dao层中的第一个参数，#{1}代表dao层中第二参数，更多参数一致往后加即可。23 <select id="selectUser"resultMap="BaseResultMap">4 select * fromuser_user_t whereuser_name = #{0} anduser_area=#{1}5 </select>@param注解方式1 public interface usermapper {2 user selectuser(@param(“username”) string username,3 @param(“hashedpassword”) string hashedpassword);4 } 1 <select id=”selectuser” resulttype=”user”>2 select id, username, hashedpassword3 from some_table4 where username = #{username}5 and hashedpassword = #{hashedpassword}6 </select> 第二种：使用Map集合作为参数来装载1 try{2 //映射文件的命名空间.SQL片段的ID，就可以调用对应的映射文件中的SQL345 /**6 * 由于我们的参数超过了两个，而方法中只有一个Object参数收集7 * 因此我们使用Map集合来装载我们的参数8 */9 Map<String, Object> map = new HashMap();10 map.put("start", start);11 map.put("end", end);12 return sqlSession.selectList("StudentID.pagination", map);13 }catch(Exception e){14 e.printStackTrace();15 sqlSession.rollback();16 throw e;17 }finally{18 MybatisUtil.closeSqlSession();19 } 1 <!--分页查询-->2 <select id="pagination" parameterType="map" resultMap="studentMap">34 /*根据key自动找到对应Map集合的value*/5 select * from students limit #{start},#{end};67 </select>5、Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理不？Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理不？Mybatis动态sql可以让我们在Xml映射文件内，以标签的形式编写动态sql，完成逻辑判断和动态拼接sql的功能。Mybatis提供了9种动态sql标签：trim|where|set|foreach|if|choose|when|otherwise|bind。其执行原理为，使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。6、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？如果配置了namespace那么当然是可以重复的，因为我们的Statement实际上就是namespace+id如果没有配置namespace的话，那么相同的id就会导致覆盖了。7、为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。8、通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？Dao接口，就是人们常说的Mapper接口，接口的全限名，就是映射文件中的namespace的值，接口的方法名，就是映射文件中MappedStatement的id值，接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement举例：1 com.mybatis3.mappers.StudentDao.findStudentById，23 可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中，每一个<select>、<insert>、<update>、<delete>标签，都会被解析为一个MappedStatement对象。Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，

下列面试题都是在网上收集的，本人抱着学习的态度找了下参考答案，有不足的地方还请指正，更多精彩内容可以关注我的微信公众号：Java团长1、面向对象的特征有哪些方面？抽象：将同类对象的共同特征提取出来构造类。继承：基于基类创建新类。封装：将数据隐藏起来，对数据的访问只能通过特定接口。多态性：不同子类型对象对相同消息作出不同响应。2、访问修饰符public,private,protected,以及不写（默认）时的区别？​protected 当前类，同包，异包子类。3、String 是最基本的数据类型吗？答：不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type），剩下的都是引用类型（reference type），Java 5以后引入的枚举类型也算是一种比较特殊的引用类型。4、float f=3.4;是否正确？答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？答：对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。6、Java有没有goto？答：goto 是Java中的保留字，在目前版本的Java中没有使用。（根据James Gosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）7、int和Integer有什么区别？答：Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。Java 为每个原始类型提供了包装类型：原始类型: boolean，char，byte，short，int，long，float，double包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Doubleclass AutoUnboxingTest {public static void main(String[] args) {Integer a = new Integer(3);Integer b = 3; // 将3自动装箱成Integer类型int c = 3;System.out.println(a == b); // false 两个引用没有引用同一对象System.out.println(a == c); // true a自动拆箱成int类型再和c比较}}最近还遇到一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：public class Test03 {public static void main(String[] args) {Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;System.out.println(f1 == f2);System.out.println(f3 == f4);}}如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}IntegerCache是Integer的内部类，其代码如下所示：/*** Cache to support the object identity semantics of autoboxing for values between* -128 and 127 (inclusive) as required by JLS.** The cache is initialized on first usage. The size of the cache* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.* During VM initialization, java.lang.Integer.IntegerCache.high property* may be set and saved in the private system properties in the* sun.misc.VM class.*/private static class IntegerCache {static final int low = -128;static final int high;static final Integer cache[];static {// high value may be configured by propertyint h = 127;String integerCacheHighPropValue =sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");if (integerCacheHighPropValue != null) {try {int i = parseInt(integerCacheHighPropValue);i = Math.max(i, 127);// Maximum array size is Integer.MAX_VALUEh = Math.min(i, Integer.MAX_VALUE - (-low) -1);} catch( NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.}}high = h;cache = new Integer[(high - low) + 1];int j = low;for(int k = 0; k < cache.length; k++)cache[k] = new Integer(j++);// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}简单的说，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。提醒：越是貌似简单的面试题其中的玄机就越多，需要面试者有相当深厚的功力。8、&和&&的区别？答：&运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。补充：如果你熟悉JavaScript，那你可能更能感受到短路运算的强大，想成为JavaScript的高手就先从玩转短路运算开始吧。9、解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。答：通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间；而通过new关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为Eden、Survivor（又可分为From Survivor和To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据；程序中的字面量（literal）如直接书写的100、"hello"和常量都是放在常量池中，常量池是方法区的一部分，。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过JVM的启动参数来进行调整，栈空间用光了会引发StackOverflowError，而堆和常量池空间不足则会引发OutOfMemoryError。String str = new String("hello");上面的语句中变量str放在栈上，用new创建出来的字符串对象放在堆上，而"hello"这个字面量是放在方法区的。补充1：较新版本的Java（从Java 6的某个更新开始）中，由于JIT编译器的发展和"逃逸分析"技术的逐渐成熟，栈上分配、标量替换等优化技术使得对象一定分配在堆上这件事情已经变得不那么绝对了。补充2：运行时常量池相当于Class文件常量池具有动态性，Java语言并不要求常量一定只有编译期间才能产生，运行期间也可以将新的常量放入池中，String类的intern()方法就是这样的。看看下面代码的执行结果是什么并且比较一下Java 7以前和以后的运行结果是否一致。String s1 = new StringBuilder("go").append("od").toString();System.out.println(s1.intern() == s1);String s2 = new StringBuilder("ja").append("va").toString();System.out.println(s2.intern() == s2);10、Math.round(11.5) 等于多少？Math

Linux下如何查找大文件和大目录 1： 如何查找大文件？ 其实很多时候，你需要了解当前系统下有哪些大文件，比如文件大小超过100M或1G（阀值视具体情况而定）。那么如何把这些大文件搜索出来呢？例如我

1. 什么是shell脚本？shell是计算机的壳 ，是用户与操作系统交互的方式。如果你要对计算机发布指令，让计算机去按照你的意愿做事，那么你就需要告诉计算机去做什么事，怎么样去做。一般来说你可以用像

&& 和& 的区别 按位与：a&b是把a和b都转换成二进制数然后再进行与的运算；逻辑与：a&&b就是当且仅当两个操作数均为 true时，其结果才为 tr

二叉树和二叉查找树之间的区别 凡是每个节点都最多有两个叉的树，都叫二叉树。 查找树和排序树是一个东西。特点是中序遍历一遍的结果是单调的。这种树建出来可以用来做二分搜索。 平衡树一般是排序树的一种，并且

（1）快排是递归排序，为啥排序效率也挺高？快排是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序

115道Java经典面试题（面中率最高、最全） Java是一个支持并发、基于类和面向对象的计算机编程语言。下面列出了面向对象软件开发的优点： 代码开发模块化，更易维护和修改。 代码复用。 增强代码的可

C++经典面试题（最全，面中率最高） 1.new、delete、malloc、free关系 delete会调用对象的析构函数,和new对应free只会释放内存，new调用构造函数。malloc与fre

Java内存模型和JVM内存管理 一、Java内存模型： 1、主内存和工作内存（即是本地内存）： Java内存模型的主要目标是定义程序中各个变量的访问规则，即在JVM中将变量存储到内存和从内存中取出变

Java堆外内存管理 1、JVM可以使用的内存分外2种：堆内存和堆外内存： 堆内存完全由JVM负责分配和释放，如果程序没有缺陷代码导致内存泄露，那么就不会遇到java.lang.OutOfMemory

这里有10个经典的Java面试题，也为大家列出了答案。这是Java开发人员面试经常容易遇到的问题，相信你了解和掌握之后一定会有所提高。让我们一起来看看吧。 1.Java的HashMap是如何工作的？ HashMap是一个针对数据结构的键值，每个键都会有相应的值，关键是识别这样的值。 HashMap 基于 hashing 原理，我们通过 put ()和 get ()方法储存和获取对象。当我们将键值对传递给 put ()方法时，它调用键对象的 hashCode ()方法来计算 hashcode，让后找到 bucket 位置来储存值对象。当获取对象时，通过键对象的 equals ()方法找到正确的键值对，然后返回值对象。HashMap 使用 LinkedList 来解决碰撞问题，当发生碰撞了，对象将会储存在 LinkedList 的下一个节点中。 HashMap 在每个 LinkedList 节点中储存键值对对象。 2.什么是快速失败的故障安全迭代器？ 快速失败的Java迭代器可能会引发ConcurrentModifcationException在底层集合迭代过程中被修改。故障安全作为发生在实例中的一个副本迭代是不会抛出任何异常的。快速失败的故障安全范例定义了当遭遇故障时系统是如何反应的。例如，用于失败的快速迭代器ArrayList和用于故障安全的迭代器ConcurrentHashMap。 3.Java BlockingQueue是什么？ Java BlockingQueue是一个并发集合util包的一部分。BlockingQueue队列是一种支持操作，它等待元素变得可用时来检索，同样等待空间可用时来存储元素。 4.什么时候使用ConcurrentHashMap？ 在问题2中我们看到ConcurrentHashMap被作为故障安全迭代器的一个实例，它允许完整的并发检索和更新。当有大量的并发更新时，ConcurrentHashMap此时可以被使用。这非常类似于Hashtable，但ConcurrentHashMap不锁定整个表来提供并发，所以从这点上ConcurrentHashMap的性能似乎更好一些。所以当有大量更新时ConcurrentHashMap应该被使用。 5.哪一个List实现了最快插入？ LinkedList和ArrayList是另个不同变量列表的实现。ArrayList的优势在于动态的增长数组，非常适合初始时总长度未知的情况下使用。LinkedList的优势在于在中间位置插入和删除操作，速度是最快的。 LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。 ArrayList实现了可变大小的数组。它允许所有元素，包括null。 每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。 6.Iterator和ListIterator的区别 ●ListIterator有add()方法，可以向List中添加对象，而Iterator不能。●ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。 ●ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。●都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iierator仅能遍历，不能修改。 7.什么是CopyOnWriteArrayList，它与ArrayList有何不同？ CopyOnWriteArrayList是ArrayList的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。相比较于ArrayList它的写操作要慢一些，因为它需要实例的快照。 CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差，但是读操作因为操作的对象和写操作不是同一个对象，读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的"="将引用指向新的数组对象上来，这个几乎不需要时间，这样读操作就很快很安全，适合在多线程里使用，绝对不会发生ConcurrentModificationException ，因此CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。 8.迭代器和枚举之间的区别 如果面试官问这个问题，那么他的意图一定是让你区分Iterator不同于Enumeration的两个方面： ●Iterator允许移除从底层集合的元素。●Iterator的方法名是标准化的。 9.Hashmap如何同步? 当我们需要一个同步的HashMap时，有两种选择： ●使用Collections.synchronizedMap（..）来同步HashMap。●使用ConcurrentHashMap的 这两个选项之间的首选是使用ConcurrentHashMap，这是因为我们不需要锁定整个对象，以及通过ConcurrentHashMap分区地图来获得锁。 10.IdentityHashMap和HashMap的区别 IdentityHashMap是Map接口的实现。不同于HashMap的，这里采用参考平等。 ●在HashMap中如果两个元素是相等的，则key1.equals(key2) ●在IdentityHashMap中如果两个元素是相等的，则key1 == key2

 1.Java中是如何区分重载方法的？ 通过重载方法的参数类型和顺序来进行区分的。 注意：若参数类型和顺序均相同时，不管参数名是否相同，编译器均会报错，提示方法已经被定义。且不能根据返回值类型来区分，如果根据返回值来区分的话，有时程序里调用方法时并不需要返回值，那么程序都无法确定该调用那个重载方法。 2.阅读以下程序，解释其中的错误。public static void testLong(long i) {System.out.println("test long");} public static void testFloat(float i) {System.out.println("test float");}public static void main(String[] args) {testLong(50);testFloat(1.5);}testLong没有问题，因为传递的参数50是int型的，而接收方参数是long型的，小范围可以自动转型为大范围的数据类型；testFloat不会通过编译，因为传递的参数1.5是double类型的，而接收方参数是float类型的，大范围转型为小范围数据类型需要显式转换，即改为testFloat(1.5f)。 3.阅读以下程序，解释其中的错误。public static class A {A(int i) {System.out.println("A(int i)");}}public static void main(String[] args) {A a = new A();}在定义了自定义构造器后，若要使用默认构造器，则需要显式指定默认构造器，否则A a = new A();不能编译通过。 4.阅读以下程序，解释其中的错误。 public static class A {A() {System.out.println("A()");}A(int i) {System.out.println("A(int i)");}A(int i, int j) {A();A(i);System.out.println("A(int i, int j)");}}在一个构造器中调用其它构造器时，需要使用this关键字进行调用，如this()；在一个构造器中可调用仅一个其它构造器，并且调用其它构造器的语句需放在调用者（即发出调用行为的构造器）语句块的第一行。 5.阅读以下程序，写出执行结果。public static class A {private int i;private String j;int getI() {return i;}String getJ() {return j;}A(int i) {i = i;}A(String j) {this.j = j;}}public static void main(String[] args) {System.out.println(new A(5).getI());System.out.println(new A("hello").getJ());}执行结果为：  hello 对于i = i;这个语句而言，它并未改变实例变量i的值，且i的默认值为0，因此结果也为0，若需要改变实例变量i的值，需要改为this.i = i; 6.在一个类中，声明了若干个static方法和非static方法，请谈谈声明的static方法是否能访问声明的非static方法，说明理由？ static方法不能访问非static方法，因为static方法是属于这个类本身的一个方法，在编译期间就已经确定了；而非static方法是属于这个类的对象的方法，需要在实例化之后才能访问到。若在static方法中访问非static方法，将不能通过编译。 7.static关键字为何不能修饰局部变量？ static关键字修饰的变量或方法是属于类的，在编译时就已经确定了；而普通变量或方法是属于该由类生成的对象，需要在实例化后才能确定。因此，若static关键字修饰了方法的局部变量，一方面方法需要在实例化之后才能确定，另一方面static修饰的变量需要在编译时确定，这就会导致矛盾。 8.finalize()有何用途？什么情况下需要调用这个函数？ 在需要释放内存的地方调用finalize()，则在下一轮垃圾回收时会回收占用的内存，一般情况下不需要显式调用此函数。 垃圾回收器只能回收那些由new关键字创建的对象所占用的内存，那么有些不是通过这种方式（比如调用C++本地方法）所占用的内存如何回收呢？那么就需要使用finalize()了。由于C++中需要使用free()函数来释放内存，所以Java程序在调用C++时需要调用finalize()方法来释放内存。 9.列出并简要解释几种常见垃圾回收技术。 引用计数：每个对象都包含了一个引用计数器，每被引用一次，计数器都加1，引用者被置为null或者销毁，计数器就减1。垃圾收集器进行轮询，一旦发现计数器的值小于1，就回收该对象占用的内存。 停止复制：在垃圾回收机制运行时，程序需要停止运行，将每个活动的对象由一个堆转移到另一个堆，留下的垃圾会被回收。 标记清除：从堆栈和静态存储区域开始，寻找到活的对象就对其进行标记，所有的标记过程完成后，就对垃圾进行回收。

Java 线程面试问题 在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分。如果你想获得任何股票投资银行的前台资讯职位，那么你应该准备很多关于多线程的问题。在投资银行业务中多线程和并发是一个非常受欢迎的话题，特别是电子交易发展方面相关的。他们会问面试者很多令人混淆的Java线程问题。面试官只是想确信面试者有足够的Java线程与并发方面的知识，因为候选人中有很多只浮于表面。用于直接面向市场交易的高容量和低延时的电子交易系统在本质上是并发的。下面这些是我在不同时间不同地点喜欢问的Java线程问题。我没有提供答案，但只要可能我会给你线索，有些时候这些线索足够回答问题。现在引用Java5并发包关于并发工具和并发集合的问题正在增多。那些问题中ThreadLocal、Blocking Queue、Counting Semaphore和ConcurrentHashMap比较流行。 15个Java多线程面试题及回答 1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？ 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 2)在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？ lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。 3)在java中wait和sleep方法的不同？ 通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 4）用Java实现阻塞队列。 这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序；第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。 5）用Java写代码来解决生产者——消费者问题。 与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。 6）用Java编程一个会导致死锁的程序，你将怎么解决？ 这是我最喜欢的Java线程面试问题，因为即使死锁问题在写多线程并发程序时非常普遍，但是很多侯选者并不能写deadlock free code（无死锁代码？），他们很挣扎。只要告诉他们，你有N个资源和N个线程，并且你需要所有的资源来完成一个操作。为了简单这里的n可以替换为2，越大的数据会使问题看起来更复杂。通过避免Java中的死锁来得到关于死锁的更多信息。 7) 什么是原子操作，Java中的原子操作是什么？ 非常简单的java线程面试问题，接下来的问题是你需要同步一个原子操作。 8) Java中的volatile关键是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？ 自从Java 5和Java内存模型改变以后，基于volatile关键字的线程问题越来越流行。应该准备好回答关于volatile变量怎样在并发环境中确保可见性、顺序性和一致性。 9) 什么是竞争条件？你怎样发现和解决竞争？ 这是一道出现在多线程面试的高级阶段的问题。大多数的面试官会问最近你遇到的竞争条件，以及你是怎么解决的。有些时间他们会写简单的代码，然后让你检测出代码的竞争条件。可以参考我之前发布的关于Java竞争条件的文章。在我看来这是最好的java线程面试问题之一，它可以确切的检测候选者解决竞争条件的经验，or writing code which is free of data race or any other race condition。关于这方面最好的书是《Concurrency practices in Java》。 10) 你将如何使用thread dump？你将如何分析Thread dump？ 在UNIX中你可以使用kill -3，然后thread dump将会打印日志，在windows中你可以使用”CTRL+Break”。非常简单和专业的线程面试问题，但是如果他问你怎样分析它，就会很棘手。 11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？ 这是另一个非常经典的java多线程面试问题。这也是我刚开始写线程程序时候的困惑。现在这个问题通常在电话面试或者是在初中级Java面试的第一轮被问到。这个问题的回答应该是这样的，当你调用start()方法时你将创建新的线程，并且执行在run()方法里的代码。但是如果你直接调用run()方法，它不会创建新的线程也不会执行调用线程的代码。阅读我之前写的《start与run方法的区别》这篇文章来获得更多信息。 12) Java中你怎样唤醒一个阻塞的线程？ 这是个关于线程和阻塞的棘手的问题，它有很多解决方法。如果线程遇到了IO阻塞，我并且不认为有一种方法可以中止线程。如果线程因为调用wait()、sleep()、或者join()方法而导致的阻塞，你可以中断线程，并且通过抛出InterruptedException来唤醒它。我之前写的《How to deal with blocking methods in java》有很多关于处理线程阻塞的信息。 13)在Java中CycliBarriar和CountdownLatch有什么区别？ 这个线程问题主要用来检测你是否熟悉JDK5中的并发包。这两个的区别是CyclicBarrier可以重复使用已经通过的障碍，而CountdownLatch不能重复使用。 14) 什么是不可变对象，它对写并发应用有什么帮助？ 另一个多线程经典面试问题，并不直接跟线程有关，但间接帮助很多。这个java面试问题可以变的非常棘手，如果他要求你写一个不可变对象，或者问你为什么String是不可变的。 15) 你在多线程环境中遇到的共同的问题是什么？你是怎么解决它的？ 多线程和并发程序中常遇到的有Memory-interface、竞争条件、死锁、活锁和饥饿。问题是没有止境的，如果你弄错了，将很难发现和调试。这是大多数基于面试的，而不是基于实际应用的Java线程问题。 补充的其它几个问题： 1) 在java中绿色线程和本地线程区别？ 2) 线程与进程的区别？ 3) 什么是多线程中的上下文切换？ 4)死锁与活锁的区别，死锁与馅饼的区别？ 5) Java中用到的线程调度算法是什么？ 6) 在Java中什么是线程调度？ 7) 在线程中你怎么处理不可捕捉异常？ 8) 什么是线程组，为什么在Java中不推荐使用？ 9) 为什么使用Executor框架比使用应用创建和管理线程好？ 10) 在Java中Executor和Executors的区别？ 11) 如何在Windows和Linux上查找哪个线程使用的CPU时间最长？

问题一：在多线程环境中使用HashMap会有什么问题？在什么情况下使用get()方法会产生无限循环？ HashMap本身没有什么问题，有没有问题取决于你是如何使用它的。比如，你在一个线程里初始化了一个HashMap然后在多个其他线程里对其进行读取，这肯定没有任何问题。有个例子就是使用HashMap来存储系统配置项。当有多于一个线程对HashMap进行修改操作的时候才会真正产生问题，比如增加、删除、更新键值对的时候。因为put()操作可以造成重新分配存储大小（re-sizeing）的动作，因此有可能造成无限循环的发生，所以这时需要使用Hashtable或者ConcurrentHashMap，而后者更优。 问题二：不重写Bean的hashCode()方法是否会对性能带来影响？ 这个问题非常好，每个人可能都会有自己的体会。按照我掌握的知识来说，如果一个计算hash的方法写得不好，直接的影响是，当向HashMap中添加元素的时候会更频繁地造成冲突，因此最终增加了耗时。但是自从Java 8开始，这种影响不再像前几个版本那样显著了，因为当冲突的发生超出了一定的限度之后，链表类的实现将会被替换成二叉树（binary tree）实现，这时你仍可以得到O(logN)的开销，优于链表类的O(n)。 问题三：对于一个不可修改的类，它的每个对象是不是都必须声明成final的？ 不尽然，因为你可以通过将成员声明成非final且private，并且不要在除了构造函数的其他地方来修改它。不要为它们提供setter方法，同时不会通过任何函数泄露出对此成员的引用。需要记住的是，把对象声明成final仅仅保证了它不会被重新赋上另外一个值，你仍然可以通过此引用来修改引用对象的属性。这一点是关键，面试官通常喜欢听到你强调这一点。 问题四：String的substring()方法内部是如何实现的？ 又一个Java面试的好问题，你应该答出“substring方法通过原字符串创建了一个新的对象”，否则你的回答肯定是不能令人满意的。这个问题也经常被拿来测试应聘者对于substring()可能带来的内存泄漏风险是否有所了解。直到Java 1.7版本之前，substring会保存一份原字符串的字符数组的引用，这意味着，如果你从1GB大小的字符串里截取了5个字符，而这5个字符也会阻止那1GB内存被回收，因为这个引用是强引用。 到了Java 1.7，这个问题被解决了，原字符串的字符数组已经不再被引用，但是这个改变也使得substring()创建字符串的操作更加耗时，以前的开销是O(1)，现在最坏情况是O(n)。  问题五：能否写一个单例模式，并且保证实例的唯一性？ 这算是Java一个比较核心的问题了，面试官期望你能知道在写单例模式时应该对实例的初始化与否进行双重检查。记住对实例的声明使用Volatile关键字，以保证单例模式是线程安全的。下面是一段示例，展示了如何用一种线程安全的方式实现了单例模式： public class Singleton {     private static volatile Singleton _instance;     /**     * Double checked locking code on Singleton     * @return Singelton instance     */    public static Singleton getInstance() {        if (_instance == null) {            synchronized (Singleton.class) {                if (_instance == null) {                    _instance = new Singleton();                }            }        }        return _instance;    } } 问题六：你在写存储过程或者在Java里调用存储过程的时候如何来处理错误情况？ 这是个很棘手的Java面试题，答案也并不固定。我的答案是，写存储过程的时候一旦有操作失败，则一定要返回错误码。但是在调用存储过程的时候出错的话捕捉SQLException却是唯一能做的。 问题七：Executor.submit()和Executor.execute()这两个方法有什么区别？ 此问题来自另外一篇文章，《15个最流行的java多线程面试问题》，现在对熟练掌握并发技能的开发者的需求越来越大，因此这个问题也越来越引起大家的重视。答案是：前者返回一个Future对象，可以通过这个对象来获得工作线程执行的结果。 当我们考察异常处理的时候，又会发现另外一个不同。当你使用execute提交的任务抛出异常时，此异常将会交由未捕捉异常处理过程来处理（uncaught exception handler），当你没有显式指定一个异常处理器的话，默认情况下仅仅会通过System.err打印出错误堆栈。当你用submit来提交一个任务的时候，这个任务一旦抛出异常（无论是否是运行时异常），那这个异常是任务返回对象的一部分。对这样一种情形，当你调用Future.get()方法的时候，这个方法会重新抛出这个异常，并且会使用ExecutionException进行包装。 问题八：工厂模式和抽象工厂模式有何不同？ 抽象工厂模式提供了多一级的抽象。不同的工厂类都继承了同一个抽象工厂方法，但是却根据工厂的类别创建不同的对象。例如，AutomobileFactory, UserFactory, RoleFactory都继承了AbstractFactory，但是每个工厂类创建自己对应类型的对象。下面是工厂模式和抽象工厂模式对应的UML图。  问题九：什么是单例模式？创建单例对象的时候是将整个方法都标记为synchronized好还是仅仅把创建的的语句标记为synchronized好？ 在Java中，单例类是指那些在整个Java程序中只存在一份实例的类，例如java.lang.Runtime就是一个单例类。在Java 4版本及以前创建单例会有些麻烦，但是自从Java 5引入了Enum类型之后，事情就变得简单了。可以去看看我的关于如何使用Enum来创建单例类的文章，同时再看看问题五来看看如何在创建单例类的时候进行双重检查。 问题十：能否写一段用Java 4或5来遍历一个HashMap的代码？ 事实上，用Java可以有四种方式来遍历任何一个Map，一种是使用keySet()方法获取所有的键，然后遍历这些键，再依次通过get()方法来获取对应的值。第二种方法可以使用entrySet()来获取键值对的集合，然后使用for each语句来遍历这个集合，遍历的时候获得的每个键值对已经包含了键和值。这种算是一种更优的方式，因为每轮遍历的时候同时获得了key和value，无需再调用get()方法，get()方法在那种如果bucket位置有一个巨大的链表的时候的性能开销是O(n)。第三种方法是获取entrySet之后用iterator依次获取每个键值对。第四种方法是获得key set之后用iterator依次获取每个key，然后再根据key来调用get方法。 问题十一：你在什么时候会重写hashCode()和equals()方法？ 当你需要根据业务逻辑来进行相等性判断、而不是根据对象相等性来判断的时候你就需要重写这两个函数了。例如，两个Employee对象相等的依据是它们拥有相同的emp_id，尽管它们有可能是两个不同的Object对象，并且分别在不同的地方被创建。同时，如果你准备把它们当作HashMap中的key来使用的话，你也必须重写这两个方法。现在，作为Java中equals-hashcode的一个约定，当你重写equals的时候必须也重写hashcode，否则你会打破诸如Set, Map等集合赖以正常工作的约定。你可以看看我的另外一篇博文来理解这两个方法之间的微妙区别与联系。 问题十二：如果不重写hashCode方法会有什么问题？ 如果不重写equals方法的话，equals和hashCode之间的约定就会被打破：当通过equals方法返回相等的两个对象，他们的hashCode也必须一样。如果不重写hashCode方法的话，即使是使用equals方法返回值为true的两个对象，当它们插入同一个map的时候，因为hashCode返回不同所以仍然会被插入到两个不同的位置。这样就打破了HashMap的本来目的，因为Map本身不允许存进去两个key相同的值。当使用put方法插入一个的时候，HashMap会先计算对象的hashcode，然后根据它来找到存储位置(bucket)，然后遍历此存储位置上所有的Map.Entry对象来查看是否与待插入对象相同。如果没有提供hashCode的话，这些就都做不到了。 问题十三：我们要同步整个getInstance()方法，还是只同步getInstance()方法中的关键部分？ 答案是：仅仅同步关键部分（Critical Section）。这是因为，如果我们同步整个方法的话，每次有线程调用getInstance()方法的时候都会等待其他线程调用完成才行，即使在此方法中并没有执行对象的创建操作。换句话说，我们只需要同步那些创建对象的代码，而创建对象的代码只会执行一次。一旦对象创建完成之后，根本没有必要再对方法进行同步保护了。事实上，从性能上来说，对方法进行同步保护这种编码方法非常要命，因为它会使性能降低10到20倍。下面是单例模式的UML图。  再补充一下，创建线程安全的单例对象有多种方法，你也可以顺便提一下。 问题十四：HashMap，在调用get()方法的时候equals()和hashCode()方法都起了什么样的作用？ 这个问题算是对问题十二的补充，应聘者应该知道的是，一旦你提到了hashCode()方法，人们很可能要问HashMap是如何使用这个函数的。当你向HashMap插入一个key的时候，首先，这个对象的hashCode()方法会被调用，调用结果用来计算将要存储的位置(bucket)。 因为某个位置上可能以链表的方式已经包含了多个Map.Entry对象，所以HashMap会使用equals()方法来将此对象与所有这些Map.Entry所包含的key进行对比，以确定此key对象是否已经存在。 问题十五：在Java中如何避免死锁？ 你可以通过打破互相等待的局面来避免死锁。为了达到这一点，你需要在代码中合理地安排获取和释放锁的顺序。如果获得锁的顺序是固定的，并且获得的顺序和释放的顺序刚好相反的话，就不会产生出现死锁的条件了。 问题十六：创建字符串对象的时候，使用字面值和使用new String()构造器这两种方式有什么不同？ 当我们使用new String构造器来创建字符串的时候，字符串的值会在堆中创建，而不会加入JVM的字符串池中。相反，使用字面值创建的String对象会被放入堆的PermGen段中。例如： String str=new String(“Test”); 这句代码创建的对象str不会放入字符串池中，我们需要显式调用String.intern()方法来将它放入字符串池中。仅仅当你使用字面值创建字符串时，Java才会自动将它放入字符串池中，比如：String s=”Test”。顺便提一下，这里有个容易被忽视的地方，当我们将参数“Test”传入构造器的时候，这个参数是个字面值，因此它也会在字符串池中保存另外一份。想了解更多关于字面值字符串和字符串对象之间的差别，请看这篇文章。 下图很好地解释了这种差异。  问题十七：什么是不可修改对象(Immutable Object)？你能否写一个例子？ 不可修改对象是那些一旦被创建就不能修改的对象。对这种对象的任何改动的后果都是会创建一个新的对象，而不是在原对象本身做修改。例如Java中的String类就是不可修改的。大多数这样的类通常都是final类型的，因为这样可以避免自己被继承继而被覆盖方法，在覆盖的方法里，不可修改的特性就难以得到保证了。你通常也可以通过将类的成员设置成private但是非final的来获

ThreadLocal(线程变量副本)Synchronized实现内存共享，ThreadLocal为每个线程维护一个本地变量。采用空间换时间，它用于线程间的数据隔离，为每一个使用该变量的线程提供一个副本，每个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。ThreadLocal类中维护一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值为对应线程的变量副本。ThreadLocal在Spring中发挥着巨大的作用，在管理Request作用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。Spring中绝大部分Bean都可以声明成Singleton作用域，采用ThreadLocal进行封装，因此有状态的Bean就能够以singleton的方式在多线程中正常工作了。友情链接：深入研究java.lang.ThreadLocal类Java内存模型：Java虚拟机规范中将Java运行时数据分为六种。1.程序计数器：是一个数据结构，用于保存当前正常执行的程序的内存地址。Java虚拟机的多线程就是通过线程轮流切换并分配处理器时间来实现的，为了线程切换后能恢复到正确的位置，每条线程都需要一个独立的程序计数器，互不影响，该区域为“线程私有”。2.Java虚拟机栈：线程私有的，与线程生命周期相同，用于存储局部变量表，操作栈，方法返回值。局部变量表放着基本数据类型，还有对象的引用。3.本地方法栈：跟虚拟机栈很像，不过它是为虚拟机使用到的Native方法服务。4.Java堆：所有线程共享的一块内存区域，对象实例几乎都在这分配内存。5.方法区：各个线程共享的区域，储存虚拟机加载的类信息，常量，静态变量，编译后的代码。6.运行时常量池：代表运行时每个class文件中的常量表。包括几种常量：编译时的数字常量、方法或者域的引用。友情链接： Java中JVM虚拟机详解“你能不能谈谈，java GC是在什么时候，对什么东西，做了什么事情？”在什么时候：1.新生代有一个Eden区和两个survivor区，首先将对象放入Eden区，如果空间不足就向其中的一个survivor区上放，如果仍然放不下就会引发一次发生在新生代的minor GC，将存活的对象放入另一个survivor区中，然后清空Eden和之前的那个survivor区的内存。在某次GC过程中，如果发现仍然又放不下的对象，就将这些对象放入老年代内存里去。2.大对象以及长期存活的对象直接进入老年区。3.当每次执行minor GC的时候应该对要晋升到老年代的对象进行分析，如果这些马上要到老年区的老年对象的大小超过了老年区的剩余大小，那么执行一次Full GC以尽可能地获得老年区的空间。对什么东西：从GC Roots搜索不到，而且经过一次标记清理之后仍没有复活的对象。做什么： 新生代：复制清理； 老年代：标记-清除和标记-压缩算法； 永久代：存放Java中的类和加载类的类加载器本身。GC Roots都有哪些： 1. 虚拟机栈中的引用的对象 2. 方法区中静态属性引用的对象，常量引用的对象 3. 本地方法栈中JNI（即一般说的Native方法）引用的对象。友情链接：Java GC的那些事（上）友情链接：Java GC的那些事（下）友情链接：CMS垃圾收集器介绍Synchronized 与Lock都是可重入锁，同一个线程再次进入同步代码的时候.可以使用自己已经获取到的锁。Synchronized是悲观锁机制，独占锁。而Locks.ReentrantLock是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。 ReentrantLock适用场景某个线程在等待一个锁的控制权的这段时间需要中断需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程，锁可以绑定多个条件。具有公平锁功能，每个到来的线程都将排队等候。友情链接： Synchronized关键字、Lock，并解释它们之间的区别StringBuffer是线程安全的，每次操作字符串，String会生成一个新的对象，而StringBuffer不会；StringBuilder是非线程安全的友情链接：String、StringBuffer与StringBuilder之间区别fail-fast：机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件happens-before:如果两个操作之间具有happens-before 关系，那么前一个操作的结果就会对后面一个操作可见。1.程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。2.监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。3.volatile变量规则：对一个volatile域的写，happens- before于任意后续对这个volatile域的读。4.传递性：如果A happens- before B，且B happens- before C，那么A happens- before C。5.线程启动规则：Thread对象的start()方法happens- before于此线程的每一个动作。Volatile和Synchronized四个不同点：1 粒度不同，前者针对变量 ，后者锁对象和类2 syn阻塞，volatile线程不阻塞3 syn保证三大特性，volatile不保证原子性4 syn编译器优化，volatile不优化 volatile具备两种特性：1.保证此变量对所有线程的可见性，指一条线程修改了这个变量的值，新值对于其他线程来说是可见的，但并不是多线程安全的。2.禁止指令重排序优化。Volatile如何保证内存可见性:1.当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存。2.当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。同步：就是一个任务的完成需要依赖另外一个任务，只有等待被依赖的任务完成后，依赖任务才能完成。异步：不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，只要自己任务完成了就算完成了，被依赖的任务是否完成会通知回来。（异步的特点就是通知）。 打电话和发短信来比喻同步和异步操作。阻塞：CPU停下来等一个慢的操作完成以后，才会接着完成其他的工作。非阻塞：非阻塞就是在这个慢的执行时，CPU去做其他工作，等这个慢的完成后，CPU才会接着完成后续的操作。非阻塞会造成线程切换增加，增加CPU的使用时间能不能补偿系统的切换成本需要考虑。友情链接：Java并发编程之volatile关键字解析CAS（Compare And Swap） 无锁算法： CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。友情链接：非阻塞同步算法与CAS(Compare and Swap)无锁算法线程池的作用： 在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。常用线程池：ExecutorService 是主要的实现类，其中常用的有 Executors.newSingleThreadPool(),newFixedThreadPool(),newcachedTheadPool(),newScheduledThreadPool()。友情链接：线程池原理友情链接：线程池原理解析类加载器工作机制：1.装载：将Java二进制代码导入jvm中，生成Class文件。2.连接：a）校验：检查载入Class文件数据的正确性 b）准备：给类的静态变量分配存储空间 c）解析：将符号引用转成直接引用3：初始化：对类的静态变量，静态方法和静态代码块执行初始化工作。双亲委派模型：类加载器收到类加载请求，首先将请求委派给父类加载器完成 用户自定义加载器->应用程序加载器->扩展类加载器->启动类加载器。友情链接：深入理解Java虚拟机笔记—双亲委派模型 友情链接：JVM类加载的那些事友情链接：JVM（1）：Java 类的加载机制一致性哈希：Memcahed缓存：数据结构：key,value对使用方法：get,put等方法友情链接：hashcode(),equal()方法深入解析Redis数据结构: String—字符串（key-value 类型）Hash—字典(hashmap) Redis的哈希结构可以使你像在数据库中更新一个属性一样只修改某一项属性值List—列表 实现消息队列Set—集合 利用唯一性Sorted Set—有序集合 可以进行排序 可以实现数据持久化友情链接： Spring + Redis 实现数据的缓存java自动装箱拆箱深入剖析谈谈Java反射机制如何写一个不可变类？索引：B+，B-,全文索引Mysql的索引是一个数据结构，旨在使数据库高效的查找数据。常用的数据结构是B+Tree，每个叶子节点不但存放了索引键的相关信息还增加了指向相邻叶子节点的指针，这样就形成了带有顺序访问指针的B+Tree，做这个优化的目的是提高不同区间访问的性能。什么时候使用索引：经常出现在group by,order by和distinc关键字后面的字段经常与其他表进行连接的表，在连接字段上应该建立索引经常出现在Where子句中的字段经常出现用作查询选择的字段Java学习交流QQ群：589809992 我们一起学Java！友情链接：MySQL：InnoDB存储引擎的B+树索引算法友情链接：MySQL索引背后的数据结构及算法原理Spring IOC （控制反转，依赖注入）Spring支持三种依赖注入方式，分别是属性（Setter方法）注入，构造注入和接口注入。在Spring中，那些组成应用的主体及由Spring IOC容器所管理的对象被称之为Bean。Spring的IOC容器通过反射的机制实例化Bean并建立Bean之间的依赖关系。简单地讲，Bean就是由Spring IOC容器初始化、装配及被管理的对象。获取Bean对象的过程，首先通过Resource加载配置文件并启动IOC容器，然后通过getBean方法获取bean对象，就可以调用他的方法。Spring Bean的作用域：Singleton：Spring IOC容器中只有一个共享的Bean实例，一般都是Singleton作用域。Prototype：每一个请求，会产生一个新的Bean实例。Request：每一次http请求会产生一个新的Bean实例。友情链接： Spring框架IOC容器和AOP解析友情链接：浅谈Spring框架注解的用法分析友情链接：关于Spring的69个面试问答——终极列表代理的共有优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。Java静态代理：代理对象和目标对象实现了相同的接口，目标对象作为代理对象的一个属性，具体接口实现中，代理对象可以在调用目标对象相应方法前后加上其他业务处理逻辑。缺点：一个代理类只能代理一个业务类。如果业务类增加方法时，相应的代理类也要增加方法。Java动态代理：Java动态代理是写一个类实现InvocationHandler接口，重写Invoke方法，在Invoke方法可以进行增强处理的逻辑的编写，这个公共代理类在运行的时候才能明确自己要代理的对象，同时可以实现该被代理

java后端1年经验和技术总结（1）1.引言毕业已经一年有余，这一年里特别感谢技术管理人员的器重，以及同事的帮忙，学到了不少东西。这一年里走过一些弯路，也碰到一些难题，也受到过做为一名开发却经常为系统维护和发布当救火队员的苦恼。遂决定梳理一下自己所学的东西，为大家分享一下。经过一年意识到以前也有很多认识误区，比如：偏爱收集，经常收集各种资料视频塞满一个个硬盘，然后心满意足的看着容量不行动。不重基础，总觉得很多基础东西不需要再看了，其实不懂的地方很多，计算机程序方面任何一个结果都必有原因，不要只会用不知道原理，那是加工厂出来的。现在ide查看代码那么方便，ctrl+点击就进入了JDK查看实现细节。好高骛远，在计算机基础不牢固的情况下，总想着要做架构，弄分布式，搞大数据之类。不重视性能，只求能实现功能，sql查询是不是可以优化，是否有算法妙用，大对象是否要清除。不重视扩展性，模块之间紧密耦合，常用方法不提取成工具类，调用关系混乱等问题。……本文重点不在这些，故只列举了一小部分，下面进入正题。2.语法基础2.1 Java类初始化顺序这是所有情况的类初始化顺序，如果实际类中没有定义则跳过：父类静态变量——父类静态代码块——子类静态代码块——父类非静态变量——父类非静态代码块——父类构造函数——子类非静态变量——子类非静态代码块——子类构造函数2.2 值传递和引用传递可能很多人对此不屑一顾，心想老子都工作一年了，对这些还不熟悉吗？但实际情况并非这样，JDK中东西全部熟悉了吗？以一个最简单的例子开始，你觉得下图中代码执行完之后fatherList中的元素是什么？ 这是一个最基础的值传递和引用传递的例子，你觉得好简单，已经想跃跃欲试的挑战了，那么请看下面的，StringBuffer很好理解，但是当你执行一遍之后发现是不是和预想中的输出不一样呢？String不是引用类型吗，怎么会这样呢？如果你无法理解，那么请看下String的实现源码，了解下其在内存中分配的实现原理。 2.3 集合的使用这部分几乎每个人都会用到，而且大家还都不陌生。下图来源于互联网，供大家复习一下。但是利用集合的特性进行巧妙的组合运用能解决优化很多复杂问题。Set不可重复性，List的顺序性，Map的键值对，SortSet/SortMap的有序性，我在工作中有很多复杂的业务都巧妙的使用了这些，涉及到公司保密信息，我就不贴出代码了。工作越久越发现这些和越巧妙。2.3 异常处理1.看着try、catch、finally非常容易，如果和事务传播结合在一起，就会变得极其复杂。2.finally不一定必须执行，return在catch/finally中处理情况（建议亲自操刀试一下）。3.catch中可以继续抛自定义异常（并把异常一步步传递到控制层，利用切面抓取封装异常，返回给调用者）。2.4 面向对象思想一提起面向对象，大家都知道抽象、封装、继承、和多态。但是实际工作经验中又知道多少呢，对于项目中如何巧用估计更不要提了。共性的机会每个都需要用的建立基类，如每个控制层方法可能要通过security获取一个登录用户id，用于根据不同的用户操作不同的数据，可以抽象出一个应用层基类，实现获取id的protect方法。同理DAO层可以利用泛型提取出一个包含增删改查的基类。多态的Override：基类的引用变量不仅可以指向基类的实例对象，也可以指向其子类的实例对象，如果指向子类的实例对象，其调用的方法应该是正在运行的那个对象的方法。在策略模式中使用很普遍。提到面向对象，就不可避免的要说设计模式，在工作中，一个技术大牛写的一个类似策略模式（更复杂一点），十分巧妙的解决了各种业务同一个方法，并且实现了订单、工单、业务的解耦，看得我是非常佩服。我想很多面试中都会问道单例模式吧，还没有理解的建议去看一看。 3.多线程3.1 线程安全这个是老生常谈的问题了，但是确实是问题和bug高发区。线程同步问题不需要单独写了，想必大家都清楚，不太熟悉的建议百度一下。3.1.1 线程安全问题1.代码中如果有同步操作，共享变量要特别注意（这个一般都能意识到）2多个操作能修改数据表中同一条数据的。（这个容易被忽略，业务A可能操作表a，业务B也可以操作表a，业务A、B即使在不同的模块和方法中，也会引起线程安全问题。例如如果一个人访问业务A接口，另一个人访问业务B接口，在web中每个业务请求都是会有单独的一个线程进行处理的，就会出现线程安全问题）。3.不安全的类型使用，例如StringBuffer、StringBuild，HashTable、HashMap等。在工作中我就遇到过有人在for循环进行list的remove，虽然编译器不报错，程序可以运行，但是结果却可想而知。4.Spring的bean默认是单例的，如果有类变量就要特别小心了（一般情况下是没人在控制层、业务层、DAO层等用类变量的，用的话建议是final类型，例如日志log，gson等）。5.多个系统共享数据库情况，这个其实和分布式系统类似用户重复提交问题（即使代码中从数据库读取是否存在进行限制不能解决问题）3.1.2 线程安全解决在需要同步的地方采用安全的类型。JDK锁机制，lock、tryLock，synchronized，wait、notify、notifyAll等Concurrent并发工具包，在处理一些问题上，谁用谁知道。强烈建议查看源码！数据表加锁。（除非某个表的访问频率极低，否则不建议使用）涉及分布式的，采用中间件技术例如zookeeper等解决。3.2 异步异步使用场景不影响主线程，且响应较慢的业务。例如IO操作，第三方服务（短信验证码、app推送、云存储上传等）。如果异步任务很多，就需要使用任务队列了，任务队列可以在代码级别实现，也可以利用redis（优势太明显了）。3.3 多线程通信这方面文章非常多，这里不在详述。1.共享变量方式（共享文件、全局变量，信号量机制等）2.消息队列方式3. 忙等，锁机制3.4多线程实现1.集成Thread类，重写（这里的重写指的是override）run方法，调用start方法执行。2.实现Runable接口，实现run方法，以Runable实例创建thread对象。3.实现Callable接口，实现call方法，FutureTask包装callable接口，FutureTask对象创建thread对象，常用语异步操作，建议使用匿名内部类，方便阅读和使用。额外需要说明的是：1.理解thread的join方法；2.不要认为volitate是线程安全的（不明白原因的建议去看jvm运行时刻内存分配策略）；3.sleep时间片结束后并不保证立马获取cpu。4.ThreadLocal能够为每一个线程维护变量副本，常用于在多线程中用空间换时间。4. 开源框架4.1 Hibernate、Mybatis相信每一个java程序员对这些都不陌生，这里不再详述。需要说明的主要以下几点：1.hibernate一级缓存（内置session缓存），二级缓存（可装配sessionFactory缓存），二级缓存会引起并发问题。2.hibernate延迟加载原理理解。3.hibernate 的get、load方法，sava、persist、savaOrUpdate方法区别4.session重建了关联关系却并没有同数据库进行同步和更新5.hibernate session关联关系：detached对象、persistent对象6.Spring data集成，注解方式配置属性和实体。7.mybatis 插件。8.分页查询（数据库）。9.连接池技术4.2 Spring IOC4.1.1 Spring bean1.bean注入 注解方式方便易读，引用第三方（数据库连接，数据库连接池，JedisPool等）采用配置文件方式。2. bean作用域：Singleton，prototype，request，session，global session3.bean生命周期:如下图所示（图片来源于互联网）： 4.3 Spring AOP基本概念：关注点、切面Aspect、切入点pointcut、连接点joinpoint、通知advice、织入weave、引入introduction。Spring AOP支持5中类型通知，分别是MethodBeforeAdvice、AfterReturningAdvice、ThrowsAdvice、MethodInterceptor、IntroductionInterceptor（吐槽一下名字太长）实现方式如下:1.基于代理的AOP2.基于@Aspect注解驱动的切面。（强烈推荐：可读性好，易维护，易扩展，开发快）3.纯POJO切面。4.注入式Aspect切面。4.4 Srping事务4.4.1 事务传播概念：某些操作需要保证原子性，如果中间出错，需要事务回滚。如果某个事务回滚，那么调用该事务的方法中的事务的作出如何的动作，就是事务传播。短时间内写不清楚，建议访问 http://www.cnblogs.com/yangy608/archive/2010/12/15/1907065.html 查看。事务传播属性：1. PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。2. PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。3. PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。4. PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。5. PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。6. PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。事务隔离级别： 1. ISOLATION_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，充许令外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。3. ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。4.5 其他Spring 技术栈spring boot 轻量级启动框架spring security 用户权限管理，根据角色和用户，实现UserDetailsService，进行自定义权限管理。spring task 代码级定时任务，注解方式，使用起来非常方便。需要注意的是，如果某次定时任务出了异常而没有进行处理，会导致接下来定时任务失效。如果各个任务相互独立，可以简单用try，catch包围（之前就吃过这方面的亏）。spring data 注解方式定义实体，属性等spring mvc 简单明了的mvc框架。url传值、数组传值、对象传值、对象数组等传值类型，上传/下载文件类型需要注意。spring restful 注意命名，对命名要求很严格。spring shell 命令行方式执行命令，救火、导入导出数据等用起来非常方便、制作报表。5. Web基础 5.1 web容器启动1.web.xml加载顺序: listener -> filter -> servlet2.webt容器启动过程，java新手很怕配置文件，理解完这些有助于熟悉配置文件 http://blog.csdn.net/u014431852/article/details/47042

1）jvm有很多种，其实jvm是一个标准，sun做的那个叫hotspot，作者就是后来v8的作者lars bak，其他公司也做过jvm，其中做得比较好的有bea的jrockit，其他的包括ibm的r9，apple的jvm等在内，都做得不行，所以jvm主要是整合淘汰掉这些做得不好的jvm(s)，整合成一个统一的openjdk。2）java是典型的oop语言，其执行效率的优化，最早就是lars bak等人从smalltalk等长期优化的经验中总结出来并apply到hotspot上去滴，而smalltalk在早期apple机上搞出了那种拖拖拽拽就开发出app的做法，后来vc，delphi之类的其实都是抄袭或者说借鉴apple的smalltalk的做法，jobs说微软从头到尾都在抄袭apple是空穴来风，这里空穴来风跟王垠使用的空穴来风是一个意思，有趣的是，java的gui并没有继承这种搞法，反而对这种拖拖拽拽就作出app的做法批判有加，到今天，其实java的gui都还不能真正做到拖拖拽拽就作出来，问题很多，个人建议对于纯java的gui开发，还是以写代码为主。3）jee也是一个或者说是一堆标准，知乎上有些人把maven，jenkins都算做jee是不对滴，jee的标准核心是ejb，其实就是一个xml配置化的java文件，这个标准在4的时候，达到了顶峰状态，几乎所有的挨踢大厂都主动支持该标准，之后开始走下坡路，支持的厂越来越少。4）java和javascript的关系比很多人认为的要密切，javascript里面的java这四个字母可不是白叫的，比如js的版权和商标都控制在oracle手里，oracle对于js的支持甚至超过其对java的支持，并且喜欢捆绑销售，比如jvm里面就有一个js引擎。5）jvm里面除了js engine以外还有一个浏览器排版引擎webkit，就是apple safari和google chrome用的那个那个。6）java支持绝大多数脚本语言，你能叫得上名字的脚本语言，几乎都可以在jvm上执行，比如常见的js，ruby，python，甚至php，lua，只不过除了js以外你需要找到相关的脚本引擎。7）spring的版权被控制在vmware手里，其实spring的那一大堆东西，本质上是一个非标准的jee实现，比如在jee里面用的inject，在spring里面就是autowire，当然spring曾经深刻滴影响了jee，所以有些东西比如di标准，是spring影响下制定出来的，所以spring的做法会比较特例一点。8）maven上的jars数量前两天突破800万，其他语言的类库，排名第二的是npm，大概数量是maven的十分之一，也就是几十万，不知道现在突破100万没有，然后是gem，也就是ruby那个，大概是十几万，下来是python的module，大概数量级是几万，没突破十万。9）java的标准是由一个叫做jcp的组织制定的，所有标准需要经过jcp的执行委员会通过方可执行，jcp几乎包括了你所知道的绝大多数知名挨踢公司和组织，比如google，apple，ibm，intel，arm，red hat，twitter等，还有一些教育机构，比如我国的北京大学，阿里最近一次申请jcp执行委员会成员资格，似乎投票不通过，最近一次执行委员会新增两个成员是arm和jetbrains。10）微软也曾经是jcp甚至是java的主要贡献者，但是利益驱使下，想扩展java，从而破坏java跨平台的特性，所以跟sun闹翻，其本质原因就是想让客户写的java代码跟windows绑定，sun坚决不同意，闹翻，今天回头看这个结果，只能说：双输，sun挂了，微软的ria也离挂不太远了，silverlight已经放弃了，比起当年ie自带有jvm的支持来说，那完全就是两回事。11）除了微软以外，jcp还缺少一个重要组织apache，因为apache跟oracle也闹翻了，oracle似乎并不在乎开源组织，而更在意商业公司的支持。12）java曾经有一个内置的数据库，9之后被剥离。13）j2me是j2se的子集。14）vert.x作者tim fox最早在vmware做spring时候看到了node.js，萌生出了制作支持多核的node.x的想法，并在离开vmware后加入red hat将其实现，vmware看到后开始耍无赖，claim node.x后来改叫vert.x的版权，不惜跟red hat打官司，后来各方妥协，将其交给eclipse foundation。15）oracle在收购bea之前，一开始的目标并不是bea和bea的weblogic，而是jboss，但是jboss表现出了极为有种的一面，在oracle收购成功之前，投入了red hat的怀抱，因为都是开源组织，从此jboss成了red hat的一个子部门，oracle收购jboss失败之后，转向bea，庄思浩气死了，但是没用，最后还是被恶意收购。16）sun在玩不下去之前最早尝试接触的目标是ibm，ibm嫌太贵，放弃之后，被转手给了oracle。17）vert.x的作者tim fox在离开red hat之前曾经发过twitter抱怨，外人比如我们，猜测是因为red hat内部已经有了一个jboss，所以跟vert.x在应用上有了重叠，所以导致tim fox的出走，但是出走之后，red hat答应对vert.x做持续性的战略投入，所以vert.x core的几个developers，其实拿的是red hat的工资，但是vert.x的版权并不在red hat手里，而在eclipse foundation手里。18）vert.x的几个核心开发人员都是google summer of code的导师，每年年初时候会招收在校大学生搞项目。19）教育机构相关：scala的作者马丁是德国人，eth的博导，groovy的主要领导人是法国人，jruby背后是东京大学，jboss的作者是法国大学校x的校友，x就是伽罗瓦考不进去的那所大学，伽罗瓦进不了x，所以改读巴黎高师，tim fox毕业于帝国理工，主席去的那个，netty作者trustin lee是acm银牌，现在line工作，毕业于sky里面的延世大学，kotlin是毛子公司jetbrains的作品，看linkedin，很多人毕业自圣彼得堡大学，spring作者rod johnson是悉尼大学的音乐博士，hibernate作者gavin king是澳洲莫那什大学的数学本科毕业生，james gosling这种cmu和calgory的估计烂大街了，sun是斯坦福大学网络的意思，夹带两个私货，aspectj有一个维护小组在mcgill，hbase跟waterloo关系密切。20）java早期被人认为慢，跟java坚持不用硬件加速渲染有关，死活就是不肯接入directx和opengl，7之后总算开窍，搞了一个图形引擎接入了directx／opengl。21）casssandra是facebook做失败的项目，被贡献给了apache之后老树开花。22）groovy被贡献给了apache，现在叫做apache groovy，ceylon被贡献给了eclipse，现在叫做eclipse ceylon。23）netflix现在是java shop，之前是用.net的。先想到这么多，有空再写。我的Java学习交流QQ群：589809992  禁止闲聊，非喜勿进！

概要在大数据量高并发访问时，经常会出现服务或接口面对暴涨的请求而不可用的情况，甚至引发连锁反映导致整个系统崩溃。此时你需要使用的技术手段之一就是限流，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等。在限流时，常见的两种算法是漏桶和令牌桶算法算法。限流算法令牌桶(Token Bucket)、漏桶(leaky bucket)和计数器算法是最常用的三种限流的算法。1. 令牌桶算法 令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。 当桶满时，新添加的令牌被丢弃或拒绝。令牌桶算法示例public class RateLimiterDemo {private static RateLimiter limiter = RateLimiter.create(5);public static void exec() {limiter.acquire(1);try {// 处理核心逻辑TimeUnit.SECONDS.sleep(1);System.out.println("--" + System.currentTimeMillis() / 1000);} catch (InterruptedException e) {e.printStackTrace();}}}Guava RateLimiter 提供了令牌桶算法可用于平滑突发限流策略。该示例为每秒中产生5个令牌，每200毫秒会产生一个令牌。limiter.acquire() 表示消费一个令牌。当桶中有足够的令牌时，则直接返回0，否则阻塞，直到有可用的令牌数才返回，返回的值为阻塞的时间。2. 漏桶算法 它的主要目的是控制数据注入到网络的速率，平滑网络上的突发流量，数据可以以任意速度流入到漏桶中。漏桶算法提供了一种机制，通过它，突发流量可以被整形以便为网络提供一个稳定的流量。 漏桶可以看作是一个带有常量服务时间的单服务器队列，如果漏桶为空，则不需要流出水滴，如果漏桶（包缓存）溢出，那么水滴会被溢出丢弃。3. 计数器限流算法计数器限流算法也是比较常用的，主要用来限制总并发数，比如数据库连接池大小、线程池大小、程序访问并发数等都是使用计数器算法。使用计数器限流示例1public class CountRateLimiterDemo1 {private static AtomicInteger count = new AtomicInteger(0);public static void exec() {if (count.get() >= 5) {System.out.println("请求用户过多，请稍后在试！"+System.currentTimeMillis()/1000);} else {count.incrementAndGet();try {//处理核心逻辑TimeUnit.SECONDS.sleep(1);System.out.println("--"+System.currentTimeMillis()/1000);} catch (InterruptedException e) {e.printStackTrace();} finally {count.decrementAndGet();}}}}使用AomicInteger来进行统计当前正在并发执行的次数，如果超过域值就简单粗暴的直接响应给用户，说明系统繁忙，请稍后再试或其它跟业务相关的信息。弊端：使用 AomicInteger 简单粗暴超过域值就拒绝请求，可能只是瞬时的请求量高，也会拒绝请求。使用计数器限流示例2public class CountRateLimiterDemo2 {private static Semaphore semphore = new Semaphore(5);public static void exec() {if(semphore.getQueueLength()>100){System.out.println("当前等待排队的任务数大于100，请稍候再试...");}try {semphore.acquire();// 处理核心逻辑TimeUnit.SECONDS.sleep(1);System.out.println("--" + System.currentTimeMillis() / 1000);} catch (InterruptedException e) {e.printStackTrace();} finally {semphore.release();}}}使用Semaphore信号量来控制并发执行的次数，如果超过域值信号量，则进入阻塞队列中排队等待获取信号量进行执行。如果阻塞队列中排队的请求过多超出系统处理能力，则可以在拒绝请求。相对Atomic优点：如果是瞬时的高并发，可以使请求在阻塞队列中排队，而不是马上拒绝请求，从而达到一个流量削峰的目的。我的Java学习交流QQ群：589809992  禁止闲聊，非喜勿进！

Java中异常提供了一种识别及响应错误情况的一致性机制，有效地异常处理能使程序更加健壮、易于调试。异常之所以是一种强大的调试手段，在于其回答了以下三个问题：什么出了错?在哪出的错?为什么出错?在有效使用异常的情况下，异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪“抛出，异常信息回答了“为什么“会抛出，如果你的异常没有回答以上全部问题，那么可能你没有很好地使用它们。有三个原则可以帮助你在调试过程中最大限度地使用好异常，这三个原则是：具体明确提早抛出延迟捕获为了阐述有效异常处理的这三个原则，本文通过杜撰个人财务管理器类JCheckbook进行讨论，JCheckbook用于记录及追踪诸如存取款,票据开具之类的银行账户活动。具体明确Java定义了一个异常类的层次结构,其以Throwable开始，扩展出Error和Exception，而Exception又扩展出RuntimeException.如图1所示.图1.Java异常层次结构这四个类是泛化的，并不提供多少出错信息，虽然实例化这几个类是语法上合法的(如:new Throwable())，但是最好还是把它们当虚基类看，使用它们更加特化的子类。Java已经提供了大量异常子类，如需更加具体，你也可以定义自己的异常类。例 如：java.io package包中定义了Exception类的子类IOException，更加特化确的是 FileNotFoundException，EOFException和ObjectStreamException这些IOException的子 类。每一种都描述了一类特定的I/O错误：分别是文件丢失,异常文件结尾和错误的序列化对象流.异常越具体，我们的程序就能更好地回答”什么出了错”这个 问题。捕 获异常时尽量明确也很重要。例如：JCheckbook可以通过重新询问用户文件名来处理FileNotFoundException，对于 EOFException，它可以根据异常抛出前读取的信息继续运行。如果抛出的是ObjectStreamException，则程序应该提示用户文件 已损坏，应当使用备份文件或者其他文件。Java让明确捕获异常变得容易,因为我们可以对同一try块定义多个catch块，从而对每种异常分别进行恰当的处理。1234567891011121314151617181920File prefsFile = new File(prefsFilename); try{    readPreferences(prefsFile);}catch (FileNotFoundException e){    // alert the user that the specified file    // does not exist}catch (EOFException e){    // alert the user that the end of the file    // was reached}catch (ObjectStreamException e){     // alert the user that the file is corrupted}catch (IOException e){    // alert the user that some other I/O    // error occurred}JCheckbook 通过使用多个catch块来给用户提供捕获到异常的明确信息。举例来说：如果捕获了FileNotFoundException，它可以提示用户指定另一 个文件，某些情况下多个catch块带来的额外编码工作量可能是非必要的负担，但在这个例子中，额外的代码的确帮助程序提供了对用户更友好的响应。除前三个catch块处理的异常之外，最后一个catch块在IOException抛出时给用户提供了更泛化的错误信息.这样一来，程序就可以尽可能提供具体的信息，但也有能力处理未预料到的其他异常。有 时开发人员会捕获范化异常，并显示异常类名称或者打印堆栈信息以求＂具体＂。千万别这么干！用户看到java.io.EOFException或者堆栈信息 只会头疼而不是获得帮助。应当捕获具体的异常并且用＂人话＂给用户提示确切的信息。不过，异常堆栈倒是可以在你的日志文件里打印。记住，异常和堆栈信息是用来帮助开发人 员而不是用户的。最后，应该注意到JCheckbook并没有在readPreferences()中捕获异常，而是将捕获和处理异常留到用户界面层来做，这样就能用对话框或其他方式来通知用户。这被称为＂延迟捕获＂，下文就会谈到。提早抛出异常堆栈信息提供了导致异常出现的方法调用链的精确顺序，包括每个方法调用的类名，方法名，代码文件名甚至行数，以此来精确定位异常出现的现场。1234567java.lang.NullPointerExceptionat java.io.FileInputStream.open(Native Method)at java.io.FileInputStream.<init>(FileInputStream.java:103)at jcheckbook.JCheckbook.readPreferences(JCheckbook.java:225)at jcheckbook.JCheckbook.startup(JCheckbook.java:116)at jcheckbook.JCheckbook.<init>(JCheckbook.java:27)at jcheckbook.JCheckbook.main(JCheckbook.java:318)以 上展示了FileInputStream类的open()方法抛出NullPointerException的情况。不过注意 FileInputStream.close()是标准Java类库的一部分，很可能导致这个异常的问题原因在于我们的代码本身而不是Java API。所以问题很可能出现在前面的其中一个方法，幸好它也在堆栈信息中打印出来了。不幸的是，NullPointerException是Java中信息量最少的（却也是最常遭遇且让人崩溃的）异常。它压根不提我们最关心的事情：到底哪里是null。所以我们不得不回退几步去找哪里出了错。通过逐步回退跟踪堆栈信息并检查代码，我们可以确定错误原因是向readPreferences()传入了一个空文件名参数。既然readPreferences()知道它不能处理空文件名，所以马上检查该条件：123456789101112public void readPreferences(String filename)throws IllegalArgumentException{    if (filename == null){         throw new IllegalArgumentException("filename is null");    }  //if    //...perform other operations...    InputStream in = new FileInputStream(filename);    //...read the preferences file...}通过提早抛出异常（又称＂迅速失败＂），异常得以清晰又准确。堆栈信息立即反映出什么出了错（提供了非法参数值），为什么出错（文件名不能为空值），以及哪里出的错（readPreferences()的前部分）。这样我们的堆栈信息就能如实提供：12345java.lang.IllegalArgumentException: filename is nullat jcheckbook.JCheckbook.readPreferences(JCheckbook.java:207)at jcheckbook.JCheckbook.startup(JCheckbook.java:116)at jcheckbook.JCheckbook.<init>(JCheckbook.java:27)at jcheckbook.JCheckbook.main(JCheckbook.java:318)另外，其中包含的异常信息（＂文件名为空＂）通过明确回答什么为空这一问题使得异常提供的信息更加丰富，而这一答案是我们之前代码中抛出的NullPointerException所无法提供的。通过在检测到错误时立刻抛出异常来实现迅速失败，可以有效避免不必要的对象构造或资源占用，比如文件或网络连接。同样，打开这些资源所带来的清理操作也可以省却。延迟捕获菜鸟和高手都可能犯的一个错是，在程序有能力处理异常之前就捕获它。Java编译器通过要求检查出的异常必须被捕获或抛出而间接助长了这种行为。自然而然的做法就是立即将代码用try块包装起来，并使用catch捕获异常，以免编译器报错。问 题在于，捕获之后该拿异常怎么办？最不该做的就是什么都不做。空的catch块等于把整个异常丢进黑洞，能够说明何时何处为何出错的所有信息都会永远丢失。把异常写到日志中还稍微好点，至少还有记录可查。但我们总不能指望用户去阅读或者理解日志文件和异常信息。让readPreferences()显示错误信息对话框也不合适，因为虽然JCheckbook目前是桌面应用程序，但我们还计划将它变成基于HTML的Web应用。那样的话，显示错误对话框显然不是个选择。同时，不管HTML还是C/S版本，配置信息都是在服务器上读取的，而错误信息需要显示给Web浏览器或者客户端程序。 readPreferences()应当在设计时将这些未来需求也考虑在内。适当分离用户界面代码和程序逻辑可以提高我们代码的可重用性。在有条件处理异常之前过早捕获它，通常会导致更严重的错误和其他异常。例如，如果上文的readPreferences()方法在调用FileInputStream构造方法时立即捕获和记录可能抛出的FileNotFoundException，代码会变成下面这样：1234567891011121314151617public void readPreferences(String filename){   //...    InputStream in = null;    // DO NOT DO THIS!!!try{    in = new FileInputStream(filename);}catch (FileNotFoundException e){    logger.log(e);} in.read(...); //...}上 面的代码在完全没有能力从FileNotFoundException中恢复过来的情况下就捕获了它。如果文件无法找到，下面的方法显然无法读取它。如果 readPreferences()被要求读取不存在的文件时会发生什么情况？当然，FileNotFoundException会被记录下来，如果我们 当时去看日志文件的话，就会知道。然而当程序尝试从文件中读取数据时会发生什么？既然文件不存在，变量in就是空的，一个 NullPointerException就会被抛出。调试程序时，本能告诉我们要看日志最后面的信息。那将会是NullPointerException，非常让人讨厌的是这个异常非常不具体。错误信息不仅误导我们什么出了错（真正的错误是FileNotFoundException而不是NullPointerException），还误导了错误的出处。真正 的问题出在抛出NullPointerException处的数行之外，这之间有可能存在好几次方法的调用和类的销毁。我们的注意力被这条小鱼从真正的错误处吸引了过来，一直到我们往回看日志才能发现问题的源头。既然readPreferences() 真正应该做的事情不是捕获这些异常，那应该是什么？看起来有点有悖常理，通常最合适的做法其实是什么都不做，不要马上捕获异常。把责任交给 readPreferences()的调用者，让它来研究处理配置文件缺失的恰当方法，它有可能会提示用户指定其他文件，或者使用默认值，实在不行的话也 许警告用户并退出程序

最近我在接受采访时被问到我关于成为一名伟大程序员的见解。这是一个有趣的问题，我认为我们都可以是伟大的程序员，无论我们的天赋如何，如果我们遵循一些规则的话——我相信——这应该是常识。实际上，这些规则并不只适用于编程领域，也适合任何专业。当然，这10个要点中的所有内容并不都是完全正儿八经的，有些事情只是我的看法，你的情况可能会有所不同，所以如果出现矛盾的话，不要耿耿于怀。这些要点是：1.学习如何提问提问题的程序员基本上有这些类型：完美主义者：特别是在询问关于某些开源工具的问题时，他们可能已经通过代码进行了调试，发现了问题的真正原因。但是即使没有发现真正原因，完美主义者也会讲明白这个问题，重现步骤，建议可能行得通的解决方法，或者甚至是，建议可能行得通的修复途径。事实上，完美主义者没有问题。只有答案。话匣子：这个人实际上没有问问题。他们表明他们的想法，有时会到处放置浮夸的问号。对于问题，他们给出的是他们的思路流程，如果你揣着答案等的话，他们要么自己找到了答案，要么在多封电子邮件之后才问出真正的问题。“哦，对了，我发现这个需求是完全错误的，我用一些其他的技术解决了这个问题。实际上，我完全改变了库。”呵呵。只希望他们别再问问题了。笨蛋：代码在这。我不知道哪里出错了？请帮帮我。经理：对于这种类型的人，时间就是金钱。问题一定很短，答案越快越好。令人令人啼笑皆非的是，因为保持问题简短（意即：不完整，不简洁），大多数情况下，会丢失很多重要的细节，然后为了解答问题，程序员只能请求更多细节。所以，经理（自然会失望，因为他得到的并非是一个答案而是一个新的问题）会再次发送一个短的讯息，并且更紧急地要求答案。循环往复。最后可能需要1-2周的时间才能解答。抱怨者：这类人不问问题。他们一直一直抱怨，直到问题消失。如果情况没有变好，那就有了更多的理由抱怨。现在应该清楚的是，一个精心准备的问题（简明扼要，简单，简短，但有足够的细节）将会产生更佳的答案。如果你确切知道对于该问题你需要学习什么，那么更有可能得偿所愿。2.学习如何不提出问题实际上，最好尽量避免提问。或许你可以自己弄清楚呢？当然情况并不总是如此。许多事情你根本无法知道，通过询问领域专家，有助于找到抵达成功最快和最有效的途径。但是，经常自己去尝试解决问题有很多好处：通过这种艰辛的方法学到的东西能够更好地保存到记忆中——我们将牢牢记住所学到东西。自己去寻找答案更有价值。你不会制造“噪音”。还记得前面所说的“话匣子”吗？除非你询问的人有责任回答问题（从而推迟他们的工作），否则他们可能会在不了解你的思维过程的情况下，来尝试回答每一个不完整的“问题”。这对任何人都没有帮助。通过推迟问问题（至少一段时间），你可以收集更多的相关信息，然后提供给可能能够回答问题的人。想想“完美主义者”，他们首先花更多时间寻找细节，然后自己解答问题。通过训练你可以更擅于提问。这需要时间。3.不要遗留破碎的窗户最近有一篇非常有趣的文章，是关于不要留下破窗户的。文章的本质是永远不要妥协于质量。永远不要成为逃兵。永远不要遗留…破碎的窗户。以下引用自这篇文章：“当我们采取一些捷径在最短的时间内提供一些东西时，反映了我们的粗心大意的代码会让我们之后的开发人员（来自同一个团队，未来的团队，甚至我们自己！）得出一个重要的结论：对我们所生产的代码付出足够的关注并不重要。应用程序渐渐开始恶化将是一个不可阻挡的过程。”其实，这并非意味着要成为一个完美主义者。有时，修复破碎的窗户是可以推迟的。但是，通常情况下，对于允许窗户被打破和保持打破状态，没有人会觉得开心。我们程序员不开心，我们的客户不开心，我们的用户不开心，我们的项目经理也不开心。这是一种态度，是作为专业人士的核心内容。Benjamin Franklin怎么看呢？“低价格的甜蜜被遗忘之后，低质量的苦涩将回味悠长。”一切都是如此。“低价”是我们用一种草率的方式来实现某些东西而获得的快速胜利。4.软件应该是确定性的。这就是要瞄准的目标！在理想化的世界中，软件中的一切都应该是“确定性的”。我们都应该是函数式程序员，编写没有副作用的纯粹的函数。如String.contains()。无论执行以下操作多少次：assertTrue("abcde".contains("bc"));…结果总是相同的，都是预期的结果。哪怕宇宙爆炸对这一计算也没有影响。这是确定性的。我们也可以在我们自己的程序中，而不仅仅是在标准库中做到这一目标。我们可以尝试尽可能多地编写无副作用的确定性模块。这真的与我们选择什么技术无关。确定性编程可以用任何语言完成——即使函数语言有更多工具也可以通过更复杂的类型系统来防止意外的副作用。但是我所示的例子是一个Java示例。对象方向允许确定性。对的，像PL / SQL这样的程序语言允许确定性。如果要在索引中使用函数，那么需要请求确定性的函数：CREATE INDEX upper_first_name ON customer (upper (first_name));-- Deterministic function here: -----------^^^^^^^^^^^^^^^^^^这又是一个规则问题。有副作用的过程/方法/“函数”是为“破窗户”。有副作用也许会更容易维护，当然希望最终可以消灭副作用。但这通常是自己骗自己。当将来的某一天意外突现的时候，就是你付出昂贵代价的时候。别不相信，说曹操曹操就到。5.接受意料之外的事情程序员始终应该遵守墨菲定律。一切都可能被打破。并且它即将被打破。作为软件工程师，我们应该谨记它是会破掉的。因为我们的世界是不确定的，所以我们正在实现的业务需求也是不确定的。我们只有在终于能够确定的时候，才能实现技巧#4（确定论）。否则，我们将不可避免地进入不确定论的世界（也就是“现实世界”），即一个将会出错的世界。所以，要以此为基础。接受意料之外的事情。训练你内心的洪荒之力，从积极的角度预见各种麻烦。当然，如何以简洁的方式写代码来预见各种麻烦就是另一个故事了。如何从那些可能会失败的东西（因此不需要处理）中辨别那些将会失败的东西（因此需要处理），还是需要通过一些实践滴。6.不要货物崇拜。不要教条主义。始终具体情况具体对待。所有教给你的内容都存在潜在的错误。即使是那些流行语。引用一句很不错的话：“我的职业生涯至少有50％是为了帮助或解脱由教条主义引发的一个个灾难。我们的职业充满了虚假。我们喜欢把自己当作数学家，坚持最纯粹的思想，认为它们一定是正确的。那是一条歧路。我们的职业构建在数学的基础之上，但除非你进入范畴论或关系代数的时髦世界（即便你真的进入，我也怀疑一切是否是“正确的”），否则你就得面对现实世界务实的业务需求。好吧，坦率地说，这离完美还有十万八千里。让我们来看看一些最流行的编程语言：CJavaSQL你真的觉得这些语言一点都不像数学吗？行，不如我们先来讨论段错误，Java泛型和SQL三值逻辑。这些语言是由实用主义者建立的平台。所有这些都有一些非常酷的理论背景，但最终，还是有了这些工具。对于建立在语言之上的所有东西也是如此：库，框架，设计模式，甚至架构。没有什么是对的或是错的。一切都是为某些上下文设计的工具。想想在其上下文中的工具。永远不要把这个工具当成一个独立的理由。我们不是“为艺术而艺术”。所以对这些质疑说不：XMLJSON功能编程面向对象编程设计模式微服务三层架构DDDTDD实际上：*DD不胜枚举所有这些都是某些给定上下文的好工具，但并不总是如此，要学会具体情况具体对待。保持好奇心，开发创造力，知道何时才需要使用这些工具，将有助于你成为一个更优秀的程序员。7.就是干这是真理。话说，总有一些牛人出类拔萃，能够傲视群雄，让人鞭长莫及。但大多数程序员只达到“好”的级别，或是有潜力达到“好”的程度。那么怎么才能成为一名好的程序员呢？正如罗马不是一天建成的，伟大的软件也不是一天可以写成的，受欢迎的人并非我们这个时代唯一的英雄。我遇到过许多默默无闻但伟大的程序员，他们孜孜不倦地攻克软件难题，解决了许多小公司隐蔽的问题。伟大的程序员都有一个共同点：遇到问题就是干。练习，实践。每天都致力于工作与学习，然后变得越来越优秀。想要更擅长SQL？那就干吧！每天都尝试用一些新功能编写一个SQL语句。使用window functions。分组。递归。分区的外连接。MODEL和/或MATCH_RECOGNIZE子句。不需要每次都交付生产，就是为了实践。这些都是有价值的。8.专注一个主题（从长远的角度）可能只有很少一部分“优秀的”全栈开发人员独领风骚。事实上，大多数全栈开发人员都将位于中间水平。当然，一个小团队可能只需要几个全栈开发人员，就可以涵盖很多业务逻辑，快速推出一个新的软件。但是，软件将非常笨拙，“马马虎虎能工作”。也许这对于只要可行即可的产品阶段来说就已足够，但从长远来看，会导致全栈开发人员将没有时间来正确分析（或预见！）更复杂的问题。主要专注一个主题，并真正擅长这个方面。真金不怕火来炼，只要你有本事，那么走到哪里都需要。所以，致力于你的职业生涯，做一些真正好的东西，而不是“差不多就行”。9.涉猎广泛虽然你应该主要关注一个主题，但不应该完全遗忘其他方面。你永远不能马上真正擅长SQL、扩大、扩展、低级性能、CSS、面向对象、需求工程、架构等等的所有内容（见技巧#8）。这是不可能的。但你至少应该明白它们每一个的本质。你需要明白何时SQL是正确选择（以及何时不是）。何时低级别性能的调整很重要（何时不是）。CSS原则上如何工作。面向对象、FP优点。等等。你应该花一些时间涉猎这些（以及更多）概念和技术，以便更好地了解它们的重要性。知道何时应用它们，然后再找专业人士来实际执行工作。涉猎新的范式和技术，有助于你用全然不同的思维方式思考，可能你会在以后的日常工作中不自觉地以某种方式用到它们。10.保持简单，傻瓜式爱因斯坦曾说：“Everything should be made as simple as possible, but no simpler.”（“任何事情都应该尽可能简化,直到没法再简化为止。”）没有人能够处理巨大的复杂性。在软件中不能，在生活的任何其他方面也不能。复杂性是好软件的杀手，因此简单性是使能者。易于明白。难于实现。你需要大量时间和实践才能识别和生产出简单。当然，你可以遵循许多规则来实现简单化。最简单的规则之一就是使用只有几个参数的方法/函数。让我们来看看吧。前面提到的String.contains()方法就是如此。我们可以写”abcde”.contains(“bcd”)，不阅读任何文档，每个人都能立即了解这做什么以及为什么。该方法做了一件事情，并且只做这一件。没有复杂的上下文/设置/其他传递给该方法的参数。没有“特殊情况”，也没有任何警告。此外，在库中简化比在业务逻辑中要简单得多。那么我们能实现吗？也许吧。通过实践。通过重构。但像伟大的软件一样，简单性也不是一天可以搞定的。（高级技巧：应用康威定律。在一个业务超级复杂的环境中编写又好又简单的软件是完全不可能的。要么你选择复杂性和丑陋，要么你最好摆脱那个业务）。我的Java学习交流QQ群：589809992 我们一起学Java！

面向对象编程的基本理念与核心设计思想解释下多态性（polymorphism），封装性（encapsulation），内聚（cohesion）以及耦合（coupling）。继承（Inheritance）与聚合（Aggregation）的区别在哪里。你是如何理解干净的代码（Clean Code）与技术负债（Technical Debt）的。描述下常用的重构技巧。阐述下 SOLID原则。其他的譬如 KISS,DRY,YAGNI 等原则又是什么含义。什么是设计模式（Design Patterns）？你知道哪些设计模式？你有了解过存在哪些反模式（Anti-Patterns）吗？你会如何设计登陆舰/数学表达式计算程序/一条龙？你知道哪些基本的排序算法，它们的计算复杂度如何？在给定数据的情况下你会倾向于使用哪种算法呢？尝试编写如下代码： -计算指定数字的阶乘 -开发 Fizz Buzz 小游戏 -倒转句子中的单词 -回文字符串检测 -枚举给定字符串的所有排列组合Java 核心概念equals 与 hashCode 的异同点在哪里？Java 的集合中又是如何使用它们的。描述下 Java 中集合（Collections），接口（Interfaces），实现（Implementations）的概念。LinkedList 与 ArrayList 的区别是什么？基础类型（Primitives）与封装类型（Wrappers）的区别在哪里？final 与 static 关键字可以用于哪里？它们的作用是什么？阐述下 Java 中的访问描述符（Access Modifiers）。描述下 String,StringBuilder 以及 StringBuffer 区别。接口（Interface）与抽象类（Abstract Class）的区别在哪里。覆盖（Overriding）与重载（OverLoading）的区别在哪里。异常分为哪几种类型？以及所谓的handle or declare原则应该如何理解？简述垃圾回收器的工作原理。你是如何处理内存泄露或者栈溢出问题的？如何构建不可变的类结构？关键点在哪里？什么是 JIT 编译？Java学习交流QQ群：589809992 我们一起学Java！Java 8 / Java 7 为我们提供了什么新功能？即将到来的 Java 9 又带来了怎样的新功- - 能？Hibernate / 数据库请解释下 ORM。简述下 Hibernate 的优劣特性。Hibernate 与 JPA 区别在哪？Hibernate 最新版提供了哪些特性？什么是懒加载（Lazy Loading）？什么是 N+1 难题？介绍一些熟悉的 Hibernate 注释。简介下 Hibernate Session 与 SessionFactory。Entity Beans 的状态有哪些。Hibernate 中的缓存分为几层。Hibernate 中事务的支持分为几级？什么是乐观锁（Optimistic Locking）？简述下 ACID 原则。简述下数据库正则化（Normalizations）。请介绍下你日常工作中优化慢查询（Slow Query）的策略。Spring新版的 Spring 中有哪些新特性？介绍下 Spring 的优势与缺陷。什么是控制反转（Inversion of Control）与依赖注入（Dependency Injection）？你用过哪些 Spring 的模块？Spring 中是如何使用依赖注入的？Spring 中提供了几种自动注入的机制？介绍下 Spring MVC。Spring 中 Scopes 有哪些？Spring 中 Bean 的生命周期包含哪些步骤？Java学习交流QQ群：589809992 我们一起学Java！Spring Bean 与 EJB Bean 的区别在哪里？其他主题介绍下切面编程（Aspect Oriented Programming）。概述下 GET 与 POST 的区别。Web Server、Web Container 与 Application Server 的区别是什么？简要介绍下从浏览器输入 URL 开始到获取到请求界面之后 Java Web 应用中发生了什么。什么是 N 层架构？微服务（MicroServices）与巨石型应用（Monolithic Applications）之间的区别在哪里？你知道哪些商业级设计模式？你是如何测试一个应用的？知道哪些测试框架？你是如何测试单个方法的？在你的职业生涯中，算得上最困难的技术挑战是什么？什么是领域驱动开发（Domain Driven Development）？介绍下一些你最爱的 IDE 的常用插件。除了 IDE 之外，你的日常工作中还会用到哪些工具？你使用什么版本管理工具？分支（Branch）与标签（Tag）之间的区别在哪里？你常用的持续集成（Continuous Integration）、静态代码分析（Static Code Analysis）工具有哪些？我有一个微信公众号，经常会分享一些Java技术相关的干货。如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会，主要是和一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE相关的、和Java中各个框架相关的内容。经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。1. JVM相关(包括了各个版本的特性)对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资深开发者来说，不会JVM几乎是不可接受的。JVM作为java运行的基础，很难相信对于JVM一点都不了解的人可以把java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证java开发能力的高低。在JVM这个大类中，我认为需要掌握的知识有：JVM内存模型和结构GC原理，性能调优调优：Thread Dump， 分析内存结构class 二进制字节码结构， class loader 体系 ， class加载过程 ， 实例创建过程方法执行过程Java各个大版本更新提供的新特性(需要简单了解)2. Java的运行（基础必备）这条可能出看很简单，java程序的运行谁不会呢？不过很多时候， 我们只是单纯通过IDE去执行java程序，底层IDE又是如何执行java程序呢？很多人并不了解。这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。 这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。在这里需要掌握的知识有：javac 编译java文件为 class 文件java 命令的使用， 带package的java类如何在命令行中启动java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)3. 数据类型这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断主要知识点：基本类型： int， long， float， double， boolean ， 。。。对应的对象类型： Integer 等类型到基本类型的转换， 装箱和拆箱Object类型： equals， hashcodeString 类型的特点4. 对象和实例，对象的创建在这方面，开发者需要了解class和instance的概念以及之间的差别， 这是java面向对象特性的一个基础。主要知识点有：Class和 Instance 的概念Instance 创建的过程：1。 无继承：分配内存空间， 初始化变量， 调用构造函数2。 有继承：处理静态动作， 分配内存空间， 变量定义为初始值 ， 从基类->子类， 处理定义处的初始化， 执行构造方法需要注意的点：静态属性等从基类->子类进行初始化默认无参构造方法相关的特性5. 访问控制这也是java封装特性的一个基础，需要掌握的有：public protected default private 对于class， method， field 的修饰作用6. 流程控制Java 流程控制的基础， 虽然有些语法不一定很常用，但是都需要了解，并且在合适的地方使用它们。需要掌握的有：if， switch， loop， for， while 等流程控制的语法7. 面向对象编程的概念这是一个java的核心概念，对于任何java开发者都需要熟练掌握。Java中很多特性或者说知识点都是和java面向对象编程概念相关的。在我的理解，一个好的开发者不仅仅需要了解这些特性（知识点）本身，也更需要知道这些对象在java的面向对象编程概念中是如何体现出来的，这样更有利于开发者掌握java这门开发语言，以及其他面向对象编程的语言。在这里只是简单罗列了一下，主要的知识点包括有：面向对象三大特性：封装，继承，多态; 各自的定义概念，有哪些特性体现出来，各自的使用场景静态多分派，动态单分派的概念重载的概念和使用继承：接口多实现，基类单继承抽象，抽象类，接口多态：方法覆盖的概念和使用接口回调8. Static静态属性在java日常开发中也是经常使用，需要了解和 static 关键字相关的用法，还有和其他关键字的配合使用， 如是否可以和 abstract， final 等关键字联合使用。主要需要掌握的有：静态属性的定义，使用，以及类加载时如何初始化静态方法的定义和使用静态类的定义和使用静态代码块的定义和初始化时机9. 基础知识点这里主要罗列一些散落的，没有系统归类的一些java知识点。在日常的开发中用到也不少。 这块内容其实还有很多，目前只是暂时归纳了这几个在这里：包括有：equals ， hashcode ， string/stringbuffer ，final ， finally ， finalize10.集合框架这个是一个需要多加掌握的部分，做java开发，可以说没有不用到集合框架的，这很重要。但是这里的知识点并不难，但是对于集合最好要了解内部的实现方式，因为这样有助于你在各个不同的场景选择适合的框架来解决问题，比如有1W个元素的集合，经常要进行contains判断操作，知道了集合的特性或者内部实现，就很容易做出正确的选择。这里包括了如下内容(并发相关不包含在内)：集合框架的体系： 基础Collection ，Map具体集合实现的内容， List ，Set ，Map 具体的实现，内部结构， 特殊的方法， 适用场景等集合相关的工具类 Collections 等的用法11.异常框架异常在java的开发中可能没有那么被重视。一般遇到异常，直接上抛，或者随便catch一下处理之后对于程序整体运行也没有什么大的影响。不过在企业级设计开发中， 异常的设计与处理的好坏，往往就关系着这个系统整体的健壮性。一个好的系统的异常对于开发者来说，处理应该统一，避免各处散落很多异常处理逻辑；对于系统来说，异常应该是可控的，并且是易于运维的，某些异常出现后，应该有应对的方法，知道如何运维处理，所以虽然异常框架很简单，但是对于整个企业级应用开发来说，异常处理是很重要的，处理好异常就需要了解Java中的异常体系。这部分需要掌握的知识点不多，主要就是：异常的体系：ThrowableExceptionRuntimeExceptionErrorRuntimeException 和 一般 Exception 的区别， 具体处理方法等Java学习交流QQ群：589809992 我们一起学Java！12. Java IOIO 在java中不仅仅是文件读写那么简单，也包括了 socket 网络的读写等等一切的输入输出操作。比如说 标准HTTP请求中Post的内容的读取也是一个输出的过程，等等…对于IO，Java不仅提供了基本Input、Output相关的api，也提供了一些简化操作的Reader、Writer等api，在某些开发（涉及大量IO操作的项目）中也很重要，一般日常的开发中也会涉及（日志，临时文件的读写等）。在这中的知识点主要有：基本IO的体系： 包括有InputStream ， OutputStream， Reader/Writer， 文件读取，各种流读取等NIO 的概念， 具体使用方式和使用场景13.多线程并发多线程是Java中普遍认为比较难的一块。多线程用好了可以有效提高cpu使用率， 提升整体系统效率， 特别是在有大量IO操作阻塞的情况下；但是它也是一柄双刃剑， 如果用不好，系统非但提升不大，或者没有提升，而且还会带来多线程之间的调试时等问题。在多线程中内容有很多，只是简单说明一下Java中初步使用多线程需要掌握的知识点，以后有机会单独再详细介绍一些高级特性的使用场景。多线程的实现和启动callable 与 runable 区别syncrhoized ，reentrantLock 各自特点和比对线程池future 异步方式获取执行结果concurrent 包lock..14.网络Java中也是提供了可以直接操作 TCP协议、UDP协议的API。在需要强调网络性能的情况下，可以直接使用TCP/UDP 进行通讯。在查看Tomcat等的源码中，就可以看到这些相关API的使用情况。不过一般也比较少会直接使用TCP，会使用诸如MINA、Netty这样的框架来进行处理，因为这个方面的开发涉及不多，所以就不再详细罗列了。15.时间日期处理几乎对于每个应用来说，时间日期的处理也是绕不过去的，但是JDK8 之前的时间相关API用法并不友好。在那个时代，可以选择Joda等时间框架。到了JDK8 发布之后，全新的时间API基本融合了其他框架的优点，已经可以很好的直接使用了。对于Java开发者来说，需要熟练地使用API来对时间和日期做相关的处理。具体知识点不再罗列，会在以后再写个专门的文章来总结一下JDK8中时间日期API的用法。16.XML解析/ JSON解析其实这两块内容都不是J2SE里面的内容，但是在日常开发中，和其他程序交互，和配置文件交互，越来越离不开这两种格式的解析。不过对于一个开发者来说，能够了解一些XML/JSON具体解析的原理和方法，有助于你在各个具体的场景中更好的选择合适你的方式来使得你的程序更有效率和更加健壮。XML： 需要了解 DOM解析和 SAX解析的基本原理和各自的适用场景JSON： 需要了解一些常用JSON框架的用法， 如 Jackson， FastJson， Gson 等。。17.Maven的使用Maven也不是Java里面的内容，但是maven是革命性的，给java开发带来了巨大的便利。从依赖的引入和管理，开发流程的更新和发布产出，乃至版本的更新，使用maven可以大大简化开发过程中的复杂度，从而节省大量时间。可以说，maven已经成为java开发者的标配了。所以我把maven也作为一个java开发者对于基础必备的知识点。以后会再放上一些我的一些对于maven使用的经验和技巧等，这里就不再细说了。18.泛型这是JDK5开始引入的新概念，其实是个语法糖，在编写java代码时会有些许便利， 一般的应用或者是业务的开发，只需要简单使用，不一定会用到定义泛型这样的操作， 但是开发一些基础公共组件会使用到，可以在需要的时候再细看这个部分，一般情况下只要会简单使用即可。19.标注也是jdk5 之后引入的。spring是个优秀的框架，最开始就以xml作为标准的配置文件。不过到了Spring3 之后，尤其是 spring-boot 兴起之后，越来越推崇使用标注来简化xml配置文件了，对于开发者来说，可以节省不少xml配置的时间。但是劣势是在于标注散落在各个类中，不像xml，可以对所有配置有个全局性的理解和管理，所以还没有办法说完全就取代所有的xml。对于一般开发者，会使用标注即可，一些公共组建的开发者可能会需要了解标注的定义和实现，可以在具体需要的时候再细看。20.RMIRemoteMethodInvocation ，Java语言特有的远程调用接口，使用还是比较简单方便。不过需要跨语言的情况下，就需要使用 webservice 等其他方式来支持。一般来说，程序都不需要使用RMI，不过可以在特定的情况下使用，我就在一个项目中，使用RMI来进行程序远程启动停止的控制。21.JNIJava Native Interface，可以允许Java中调用本地接口方法，一般用于C/C++代码的调用。需要注意的是在java中加载so/dll文件的路径问题，本身调用接口并不复杂，但是经常在是否加载了所需的本地接口库中花费较多时间。以上也只是简单介绍了下我对于这些

宏观上：1.技术广度方面至少要精通多门开源技术吧，研究过strutsspring等的源码。2.项目经验方面从头到尾跟过几个大项目，头是指需求阶段，包括需求调研。尾是指上线交付之后，包括维护阶段。3.架构经验方面有过分布式系统的架构和开发经验。对于跨系统的结构优化，数据存储的性能指标等有丰富经验。什么缓存啊、数据库的垂直切分什么的，业务的抽象和水平拆分啊，这些应该都轻车熟路吧。4.行业领域方面最起码得精通一到两门业务吧，所谓精通，就是比如做金融证券业务的，至少等当半个经融分析师。做电力业务的，至少等当半个电力工程师。5.个人修为有自己一些独到的见解，不会人云亦云啦。微观上：1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该十分了解UML，尤其是class，object，interaction以及statediagrams。2.你需要学习JAVA语言的基础知识以及它的核心类库(collections，serialization，streams，networking， multithreading，reflection，event，handling，NIO，localization，以及其他)。3.你应该了解JVM，classloaders，classreflect，以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。4.如果你将要写客户端程序，你需要学习WEB的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING，AWT， SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。5.你需要学习java数据库技术，如JDBCAPI并且会使用至少一种persistence/ORM构架，例如Hibernate，JDO， CocoBase，TopLink，InsideLiberator(国产JDO红工厂软件)或者iBatis。6.你还应该了解对象关系的阻抗失配的含义，以及它是如何影响业务对象的与关系型数据库的交互，和它的运行结果，还需要掌握不同的数据库产品运用，比如:oracle，mysql，mssqlserver。7.你需要学习JAVA的沙盒安全模式(classloaders，bytecodeverification，managers，policyandpermissions，codesigning， digitalsignatures，cryptography，certification，Kerberos，以及其他)还有不同的安全/认证 API，例如JAAS(JavaAuthenticationandAuthorizationService)，JCE (JavaCryptographyExtension)，JSSE(JavaSecureSocketExtension)，以及JGSS (JavaGeneralSecurityService)。8.你需要学习Servlets，JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。9.你需要熟悉主流的网页框架，例如JSF，Struts，Tapestry，Cocoon，WebWork，以及他们下面的涉及模式，如MVC/MODEL2。10.你需要学习如何使用及管理WEB服务器，例如tomcat，resin，Jrun，并且知道如何在其基础上扩展和维护WEB程序。11.你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。12.你需要掌握各种流行中间件技术标准和与java结合实现，比如Tuxedo、CROBA，当然也包括javaEE本身。13.你需要学习最少一种的XMLAPI，例如JAXP(JavaAPIforXMLProcessing)，JDOM(JavaforXMLDocumentObjectModel)，DOM4J，或JAXR(JavaAPIforXMLRegistries)。14.你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC)，SAAJ (SOAPwithAttachmentsAPIforJava)，JAXB(JavaArchitectureforXMLBinding)，JAXM(JavaAPIforXMLMessaging)， JAXR(JavaAPIforXMLRegistries)，或者JWSDP(JavaWebServicesDeveloperPack)。15.你需要学习一门轻量级应用程序框架，例如Spring，PicoContainer，Avalon，以及它们的IoC/DI风格(setter，constructor，interfaceinjection)。16.你需要熟悉不同的J2EE技术，例如JNDI(JavaNamingandDirectoryInterface)，JMS (JavaMessageService)，JTA/JTS(JavaTransactionAPI/JavaTransactionService)，JMX (JavaManagementeXtensions)，以及JavaMail。17.你需要学习企业级JavaBeans(EJB)以及它们的不同组件模式：Stateless/StatefulSessionBeans，EntityBeans(包含Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL)，或者 Message-DrivenBeans(MDB)。18.你需要学习如何管理与配置一个J2EE应用程序服务器，如WebLogic，JBoss等，并且利用它的附加服务，例如簇类，连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩写为AOP)，以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。20.你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing)，Quartz (scheduling)，JGroups(networkgroupcommunication)，JCache(distributedcaching)， Lucene(full-textsearch)，JakartaCommons等等。21.如果你将要对接或者正和旧的系统或者本地平台，你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。 22.你需要熟悉JINI技术以及与它相关的分布式系统，比如掌握CROBA。23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs)，例如Portlets(168)，JOLAP(69)，DataMiningAPI(73)，等等。24.你应该熟练掌握一种JAVAIDE例如sunOne，netBeans，IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了：)25.JAVA(精确的说是有些配置)是冗长的，它需要很多的人工代码(例如EJB)，所以你需要熟悉代码生成工具，例如XDoclet。26.你需要熟悉一种单元测试体系(JNunit)，并且学习不同的生成、部署工具(Ant，Maven)。27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。28.你需要能够深入了解加熟练操作和配置不同的操作系统，比如GNU/linux，sunsolaris，macOS等，做为跨平台软件的开发者。29.你还需要紧跟java发展的步伐，比如现在可以深入的学习javaME，以及各种java新规范，技术的运用，如新起的web富客户端技术。30.你必需要对opensource有所了解，因为至少java的很多技术直接是靠开源来驱动发展的，如java3D技术。Java学习交流QQ群：589809992  禁止闲聊，非喜勿进！宏观上：1.技术广度方面至少要精通多门开源技术吧，研究过strutsspring等的源码。2.项目经验方面从头到尾跟过几个大项目，头是指需求阶段，包括需求调研。尾是指上线交付之后，包括维护阶段。3.架构经验方面有过分布式系统的架构和开发经验。对于跨系统的结构优化，数据存储的性能指标等有丰富经验。什么缓存啊、数据库的垂直切分什么的，业务的抽象和水平拆分啊，这些应该都轻车熟路吧。4.行业领域方面最起码得精通一到两门业务吧，所谓精通，就是比如做金融证券业务的，至少等当半个经融分析师。做电力业务的，至少等当半个电力工程师。5.个人修为有自己一些独到的见解，不会人云亦云啦。微观上：1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该十分了解UML，尤其是class，object，interaction以及statediagrams。2.你需要学习JAVA语言的基础知识以及它的核心类库(collections，serialization，streams，networking， multithreading，reflection，event，handling，NIO，localization，以及其他)。3.你应该了解JVM，classloaders，classreflect，以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。4.如果你将要写客户端程序，你需要学习WEB的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING，AWT， SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。5.你需要学习java数据库技术，如JDBCAPI并且会使用至少一种persistence/ORM构架，例如Hibernate，JDO， CocoBase，TopLink，InsideLiberator(国产JDO红工厂软件)或者iBatis。6.你还应该了解对象关系的阻抗失配的含义，以及它是如何影响业务对象的与关系型数据库的交互，和它的运行结果，还需要掌握不同的数据库产品运用，比如:oracle，mysql，mssqlserver。7.你需要学习JAVA的沙盒安全模式(classloaders，bytecodeverification，managers，policyandpermissions，codesigning， digitalsignatures，cryptography，certification，Kerberos，以及其他)还有不同的安全/认证 API，例如JAAS(JavaAuthenticationandAuthorizationService)，JCE (JavaCryptographyExtension)，JSSE(JavaSecureSocketExtension)，以及JGSS (JavaGeneralSecurityService)。8.你需要学习Servlets，JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。9.你需要熟悉主流的网页框架，例如JSF，Struts，Tapestry，Cocoon，WebWork，以及他们下面的涉及模式，如MVC/MODEL2。10.你需要学习如何使用及管理WEB服务器，例如tomcat，resin，Jrun，并且知道如何在其基础上扩展和维护WEB程序。11.你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。12.你需要掌握各种流行中间件技术标准和与java结合实现，比如

这是我自己早前听课时整理的java基础全套知识，使用于初学者，也可以适用于中级的程序员，我做成了chm文档的类型，你们可以下载 笔记是比较系统全面，可以抵得上市场上90%的学习资料。讨厌那些随便乱写的资料还有拿出来卖钱的人！在这里我免费的分享出来供大家使用！在这个平台真的可以学习到不少的东西！有很多的人都在无私的奉献着他们的智慧与知识。希望对于学习者有所帮助！ 如果你觉得好的话，就在评论出给予回应,谢谢。这是我劳动成果！希望给予鼓励！点击下载之前的链接有人说失效了！现在我又重新更新了！这次打不开的就直接来我的QQ群吧：589809992