GitHub Viewer
关注公众号『**Java专栏**』,发送『面试』 获取该项目完整PDF
---
- [基础篇](#基础篇)
- [1、 Java语言有哪些特点](#1-java语言有哪些特点)
- [2、面向对象和面向过程的区别](#2面向对象和面向过程的区别)
- [3 、八种基本数据类型的大小，以及他们的封装类](#3-八种基本数据类型的大小以及他们的封装类)
- [4、标识符的命名规则。](#4标识符的命名规则)
- [5、instanceof 关键字的作用](#5instanceof-关键字的作用)
- [6、Java自动装箱与拆箱](#6java自动装箱与拆箱)
- [7、 重载和重写的区别](#7-重载和重写的区别)
- [8、 equals与==的区别](#8-equals与的区别)
- [9、 Hashcode的作用](#9-hashcode的作用)
- [10、String、String StringBuffer 和 StringBuilder 的区别是什么?](#10stringstring-stringbuffer-和-stringbuilder-的区别是什么)
- [11、ArrayList和linkedList的区别](#11arraylist和linkedlist的区别)
- [12、 HashMap和HashTable的区别](#12-hashmap和hashtable的区别)
- [13、 Collection包结构，与Collections的区别](#13-collection包结构与collections的区别)
- [14、 Java的四种引用，强弱软虚](#14-java的四种引用强弱软虚)
- [15、 泛型常用特点](#15-泛型常用特点)
- [16、Java创建对象有几种方式？](#16java创建对象有几种方式)
- [17、有没有可能两个不相等的对象有相同的hashcode](#17有没有可能两个不相等的对象有相同的hashcode)
- [18、深拷贝和浅拷贝的区别是什么?](#18深拷贝和浅拷贝的区别是什么)
- [19、final有哪些用法?](#19final有哪些用法)
- [20、static都有哪些用法?](#20static都有哪些用法)
- [21、3*0.1`==`0.3返回值是什么](#2130103返回值是什么)
- [22、a=a+b与a+=b有什么区别吗?](#22aab与ab有什么区别吗)
- [23、try catch finally，try里有return，finally还执行么？](#23try-catch-finallytry里有returnfinally还执行么)
- [24、 Excption与Error包结构](#24-excption与error包结构)
- [25、OOM你遇到过哪些情况，SOF你遇到过哪些情况](#25oom你遇到过哪些情况sof你遇到过哪些情况)
- [26、 简述线程、程序、进程的基本概念。以及他们之间关系是什么?](#26-简述线程程序进程的基本概念以及他们之间关系是什么)
- [27、线程有哪些基本状态?](#27线程有哪些基本状态)
- [28、Java 序列化中如果有些字段不想进行序列化，怎么办？](#28java-序列化中如果有些字段不想进行序列化怎么办)
- [29、Java 中 IO 流](#29java-中-io-流)
- [30、 Java IO与 NIO的区别](#30-java-io与-nio的区别)
- [31、java反射的作用于原理](#31java反射的作用于原理)
- [32、说说List,Set,Map三者的区别？](#32说说listsetmap三者的区别)
- [JVM篇](#jvm篇)
- [1、知识点汇总](#1知识点汇总)
- [2、知识点详解：](#2知识点详解)
- [3、类加载与卸载](#3类加载与卸载)
- [4、简述一下JVM的内存模型](#4简述一下jvm的内存模型)
- [线程私有区](#线程私有区)
- [线程共享区](#线程共享区)
- [5、堆和栈的区别](#5堆和栈的区别)
- [6、什么时候会触发FullGC](#6什么时候会触发fullgc)
- [7、什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？](#7什么是java虚拟机为什么java被称作是平台无关的编程语言)
- [8、Java内存结构](#8java内存结构)
- [9、对象分配规则](#9对象分配规则)
- [10、描述一下JVM加载class文件的原理机制？](#10描述一下jvm加载class文件的原理机制)
- [11、Java对象创建过程](#11java对象创建过程)
- [12、类的生命周期](#12类的生命周期)
- [13、简述Java的对象结构](#13简述java的对象结构)
- [14、如何判断对象可以被回收？](#14如何判断对象可以被回收)
- [15、JVM的永久代中会发生垃圾回收么？](#15jvm的永久代中会发生垃圾回收么)
- [16、垃圾收集算法](#16垃圾收集算法)
- [17、调优命令有哪些？](#17调优命令有哪些)
- [18、调优工具](#18调优工具)
- [19、Minor GC与Full GC分别在什么时候发生？](#19minor-gc与full-gc分别在什么时候发生)
- [20、你知道哪些JVM性能调优](#20你知道哪些jvm性能调优)
- [21、JVM内存分哪几个区，每个区的作用是什么?](#21jvm内存分哪几个区每个区的作用是什么)
- [22、简述Java垃圾回收机制?](#22简述java垃圾回收机制)
- [23、什么是类加载器，类加载器有哪些?](#23什么是类加载器类加载器有哪些)
- [24、你有没有遇到过OutOfMemory问题？你是怎么来处理这个问题的？处理 过程中有哪些收获？](#24你有没有遇到过outofmemory问题你是怎么来处理这个问题的处理-过程中有哪些收获)
- [25、JDK 1.8之后Perm Space有哪些变动? MetaSpace⼤⼩默认是⽆限的么? 还是你们会通过什么⽅式来指定⼤⼩?](#25jdk-18之后perm-space有哪些变动-metaspace⼤⼩默认是⽆限的么-还是你们会通过什么⽅式来指定⼤⼩)
- [26、跟JVM内存相关的几个核心参数图解](#26跟jvm内存相关的几个核心参数图解)
- [27、如何启动系统的时候设置JVM的启动参数](#27如何启动系统的时候设置jvm的启动参数)
- [多线程&并发篇](#多线程并发篇)
- [1、Java中实现多线程有几种方法](#1java中实现多线程有几种方法)
- [2、如何停止一个正在运行的线程](#2如何停止一个正在运行的线程)
- [3、notify()和notifyAll()有什么区别？](#3notify和notifyall有什么区别)
- [4、sleep()和wait() 有什么区别？](#4sleep和wait-有什么区别)
- [5、volatile 是什么?可以保证有序性吗?](#5volatile-是什么可以保证有序性吗)
- [6、Thread 类中的start() 和 run() 方法有什么区别？](#6thread-类中的start-和-run-方法有什么区别)
- [7、为什么wait, notify 和 notifyAll这些方法不在thread类里面？](#7为什么wait-notify-和-notifyall这些方法不在thread类里面)
- [8、为什么wait和notify方法要在同步块中调用？](#8为什么wait和notify方法要在同步块中调用)
- [9、Java中interrupted 和 isInterruptedd方法的区别？](#9java中interrupted-和-isinterruptedd方法的区别)
- [10、Java中synchronized 和 ReentrantLock 有什么不同？](#10java中synchronized-和-reentrantlock-有什么不同)
- [11、有三个线程T1,T2,T3,如何保证顺序执行？](#11有三个线程t1t2t3如何保证顺序执行)
- [**12、SynchronizedMap和ConcurrentHashMap有什么区别？**](#12synchronizedmap和concurrenthashmap有什么区别)
- [13、什么是线程安全](#13什么是线程安全)
- [14、Thread类中的yield方法有什么作用？](#14thread类中的yield方法有什么作用)
- [15、Java线程池中submit() 和 execute()方法有什么区别？](#15java线程池中submit-和-execute方法有什么区别)
- [16、说一说自己对于 synchronized 关键字的了解](#16说一说自己对于-synchronized-关键字的了解)
- [17、说说自己是怎么使用 synchronized 关键字，在项目中用到了吗synchronized关键字最主要的三种使用方式：](#17说说自己是怎么使用-synchronized-关键字在项目中用到了吗synchronized关键字最主要的三种使用方式)
- [18、什么是线程安全？Vector是一个线程安全类吗？](#18什么是线程安全vector是一个线程安全类吗)
- [19、 **volatile关键字的作用？**](#19-volatile关键字的作用)
- [20、常用的线程池有哪些？](#20常用的线程池有哪些)
- [21、简述一下你对线程池的理解](#21简述一下你对线程池的理解)
- [22、Java程序是如何执行的](#22java程序是如何执行的)
- [23、说一说自己对于 synchronized 关键字的了解](#23说一说自己对于-synchronized-关键字的了解)
- [24、说说自己是怎么使用 synchronized 关键字，在项目中用到了吗](#24说说自己是怎么使用-synchronized-关键字在项目中用到了吗)
- [25、 讲一下 synchronized 关键字的底层原理](#25-讲一下-synchronized-关键字的底层原理)
- [26、 为什么要用线程池？](#26-为什么要用线程池)
- [27、 实现Runnable接口和Callable接口的区别](#27-实现runnable接口和callable接口的区别)
- [28、 执行execute()方法和submit()方法的区别是什么呢？](#28-执行execute方法和submit方法的区别是什么呢)
- [29、 如何创建线程池](#29-如何创建线程池)
- [Spring篇](#spring篇)
- [1、 Spring的IOC和AOP机制？](#1-spring的ioc和aop机制)
- [2、 Spring中Autowired和Resource关键字的区别？](#2-spring中autowired和resource关键字的区别)
- [3、依赖注入的方式有几种，各是什么?](#3依赖注入的方式有几种各是什么)
- [4、讲一下什么是Spring](#4讲一下什么是spring)
- [5、Spring MVC流程](#5spring-mvc流程)
- [6、SpringMVC怎么样设定重定向和转发的？](#6springmvc怎么样设定重定向和转发的)
- [7、 **SpringMVC常用的注解有哪些？**](#7--springmvc常用的注解有哪些)
- [8、 **Spring的AOP理解：**](#8-spring的aop理解)
- [9、Spring的IOC理解](#9spring的ioc理解)
- [10、解释一下spring bean的生命周期](#10解释一下spring-bean的生命周期)
- [11、 **解释Spring支持的几种bean的作用域。**](#11-解释spring支持的几种bean的作用域)
- [12、 **Spring基于xml注入bean的几种方式：**](#12-spring基于xml注入bean的几种方式)
- [13、Spring框架中都用到了哪些设计模式？](#13spring框架中都用到了哪些设计模式)
- [MyBatis篇](#mybatis篇)
- [1、什么是MyBatis](#1什么是mybatis)
- [2、MyBatis的优点和缺点](#2mybatis的优点和缺点)
- [3、#{}和${}的区别是什么？](#3和的区别是什么)
- [4、当实体类中的属性名和表中的字段名不一样 ，怎么办 ？](#4当实体类中的属性名和表中的字段名不一样-怎么办-)
- [5、Mybatis是如何进行分页的？分页插件的原理是什么？](#5mybatis是如何进行分页的分页插件的原理是什么)
- [6、Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？](#6mybatis是如何将sql执行结果封装为目标对象并返回的都有哪些映射形式)
- [7、 如何执行批量插入？](#7-如何执行批量插入)
- [8、Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？](#8xml映射文件中除了常见的selectinsertupdaedelete标签之外还有哪些标签)
- [9、MyBatis实现一对一有几种方式?具体怎么操作的？](#9mybatis实现一对一有几种方式具体怎么操作的)
- [10、Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？](#10mybatis是否支持延迟加载如果支持它的实现原理是什么)
- [11、Mybatis的一级、二级缓存:](#11mybatis的一级二级缓存)
- [SpringBoot篇](#springboot篇)
- [1、什么是SpringBoot？为什么要用SpringBoot](#1什么是springboot为什么要用springboot)
- [2、Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？](#2spring-boot-的核心注解是哪个它主要由哪几个注解组成的)
- [3、运行Spring Boot有哪几种方式？](#3运行spring-boot有哪几种方式)
- [4、如何理解 Spring Boot 中的 Starters？](#4如何理解-spring-boot-中的-starters)
- [5、 如何在Spring Boot启动的时候运行一些特定的代码？](#5-如何在spring-boot启动的时候运行一些特定的代码)
- [6、 **Spring Boot 需要独立的容器运行吗？**](#6-spring-boot-需要独立的容器运行吗)
- [7、 **Spring Boot中的监视器是什么？**](#7-spring-boot中的监视器是什么)
- [8、 **如何使用Spring Boot实现异常处理？**](#8-如何使用spring-boot实现异常处理)
- [9、 **你如何理解 Spring Boot 中的 Starters？**](#9-你如何理解-spring-boot-中的-starters)
- [10、 **springboot常用的starter有哪些**](#10-springboot常用的starter有哪些)
- [11、 **SpringBoot 实现热部署有哪几种方式？**](#11-springboot-实现热部署有哪几种方式)
- [12、 **如何理解 Spring Boot 配置加载顺序？**](#12-如何理解-spring-boot-配置加载顺序)
- [13、 **Spring Boot 的核心配置文件有哪几个？它们的区别是什么？**](#13-spring-boot-的核心配置文件有哪几个它们的区别是什么)
- [14、如何集成 Spring Boot 和 ActiveMQ？](#14如何集成-spring-boot-和-activemq)
- [15、如何重新加载Spring Boot上的更改，而无需重新启动服务器？](#15如何重新加载spring-boot上的更改而无需重新启动服务器)
- [16、 Spring Boot、Spring MVC 和 Spring 有什么区别？](#16-spring-bootspring-mvc-和-spring-有什么区别)
- [17、 **能否举一个例子来解释更多 Staters 的内容？**](#17-能否举一个例子来解释更多-staters-的内容)
- [18、 **Spring Boot 还提供了其它的哪些 Starter Project Options？**](#18-spring-boot-还提供了其它的哪些-starter-project-options)
- [MySQL篇](#mysql篇)
- [1、数据库的三范式是什么](#1数据库的三范式是什么)
- [2、数据库引擎有哪些](#2数据库引擎有哪些)
- [3、InnoDB与MyISAM的区别](#3innodb与myisam的区别)
- [4、数据库的事务](#4数据库的事务)
- [5、索引问题](#5索引问题)
- [6、SQL优化](#6sql优化)
- [7、简单说一说drop、delete与truncate的区别](#7简单说一说dropdelete与truncate的区别)
- [8、什么是视图](#8什么是视图)
- [9、 什么是内联接、左外联接、右外联接？](#9-什么是内联接左外联接右外联接)
- [10、并发事务带来哪些问题?](#10并发事务带来哪些问题)
- [11、事务隔离级别有哪些?MySQL的默认隔离级别是?](#11事务隔离级别有哪些mysql的默认隔离级别是)
- [12、大表如何优化？](#12大表如何优化)
- [1. 限定数据的范围](#1-限定数据的范围)
- [2. 读/写分离](#2-读写分离)
- [3. 垂直分区](#3-垂直分区)
- [4. 水平分区](#4-水平分区)
- [13、分库分表之后,id 主键如何处理？](#13分库分表之后id-主键如何处理)
- [14、mysql有关权限的表都有哪几个](#14mysql有关权限的表都有哪几个)
- [15、mysql有哪些数据类型](#15mysql有哪些数据类型)
- [16、创建索引的三种方式，删除索引](#16创建索引的三种方式删除索引)
- [Redis篇](#redis篇)
- [1、Redis持久化机制](#1redis持久化机制)
- [2、缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级等问题](#2缓存雪崩缓存穿透缓存预热缓存更新缓存降级等问题)
- [3、热点数据和冷数据是什么](#3热点数据和冷数据是什么)
- [4、Memcache与Redis的区别都有哪些？](#4memcache与redis的区别都有哪些)
- [5、单线程的redis为什么这么快](#5单线程的redis为什么这么快)
- [6、redis的数据类型，以及每种数据类型的使用场景](#6redis的数据类型以及每种数据类型的使用场景)
- [7、redis的过期策略以及内存淘汰机制](#7redis的过期策略以及内存淘汰机制)
- [8、Redis 为什么是单线程的](#8redis-为什么是单线程的)
- [9、Redis 常见性能问题和解决方案？](#9redis-常见性能问题和解决方案)
- [10、为什么Redis的操作是原子性的，怎么保证原子性的？](#10为什么redis的操作是原子性的怎么保证原子性的)
- [11、Redis事务](#11redis事务)
- [SpringCloud篇](#springcloud篇)
- [1、什么是SpringCloud](#1什么是springcloud)
- [2、什么是微服务](#2什么是微服务)
- [3、SpringCloud有什么优势](#3springcloud有什么优势)
- [4、 **什么是服务熔断？什么是服务降级？**](#4-什么是服务熔断什么是服务降级)
- [5、 **Eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？**](#5-eureka和zookeeper都可以提供服务注册与发现的功能请说说两个的区别)
- [6、SpringBoot和SpringCloud的区别？](#6springboot和springcloud的区别)
- [7、负载平衡的意义什么？](#7负载平衡的意义什么)
- [8、什么是Hystrix？它如何实现容错？](#8什么是hystrix它如何实现容错)
- [9、什么是Hystrix断路器？我们需要它吗？](#9什么是hystrix断路器我们需要它吗)
- [10、说说 RPC 的实现原理](#10说说-rpc-的实现原理)
- [Nginx篇](#nginx篇)
- [1、简述一下什么是Nginx，它有什么优势和功能？](#1简述一下什么是nginx它有什么优势和功能)
- [2、Nginx是如何处理一个HTTP请求的呢？](#2nginx是如何处理一个http请求的呢)
- [3、列举一些Nginx的特性](#3列举一些nginx的特性)
- [4、请列举Nginx和Apache 之间的不同点](#4请列举nginx和apache-之间的不同点)
- [5、在Nginx中，如何使用未定义的服务器名称来阻止处理请求？](#5在nginx中如何使用未定义的服务器名称来阻止处理请求)
- [6、请解释Nginx服务器上的Master和Worker进程分别是什么?](#6请解释nginx服务器上的master和worker进程分别是什么)
- [7、请解释代理中的正向代理和反向代理](#7请解释代理中的正向代理和反向代理)
- [8、解释Nginx用途](#8解释nginx用途)
- [zookeeper篇](#zookeeper篇)
- [1\. ZooKeeper 是什么？](#1\-zookeeper-是什么)
- [2\. ZooKeeper 提供了什么？](#2\-zookeeper-提供了什么)
- [3.Zookeeper 文件系统](#3zookeeper-文件系统)
- [4\. ZAB 协议？](#4\-zab-协议)
- [5\. 四种类型的数据节点 Znode](#5\-四种类型的数据节点-znode)
- [6\. Zookeeper Watcher 机制 -- 数据变更通知](#6\-zookeeper-watcher-机制----数据变更通知)
- [7\. 客户端注册 Watcher 实现](#7\-客户端注册-watcher-实现)
- [8\. 服务端处理 Watcher 实现](#8\-服务端处理-watcher-实现)
- [9\. 客户端回调 Watcher](#9\-客户端回调-watcher)
- [10\. ACL 权限控制机制](#10\-acl-权限控制机制)
- [11\. Chroot 特性](#11\-chroot-特性)
- [12\. 会话管理](#12\-会话管理)
- [13\. 服务器角色](#13\-服务器角色)
- [14\. Zookeeper 下 Server 工作状态](#14\-zookeeper-下-server-工作状态)
- [15\. 数据同步](#15\-数据同步)
- [16\. zookeeper 是如何保证事务的顺序一致性的？](#16\-zookeeper-是如何保证事务的顺序一致性的)
- [17\. 分布式集群中为什么会有 Master？](#17\-分布式集群中为什么会有-master)
- [18\. zk 节点宕机如何处理？](#18\-zk-节点宕机如何处理)
- [19\. zookeeper 负载均衡和 nginx 负载均衡区别](#19\-zookeeper-负载均衡和-nginx-负载均衡区别)
- [20\. Zookeeper 有哪几种几种部署模式？](#20\-zookeeper-有哪几种几种部署模式)
- [21\. 集群最少要几台机器，集群规则是怎样的?](#21\-集群最少要几台机器集群规则是怎样的)
- [22\. 集群支持动态添加机器吗？](#22\-集群支持动态添加机器吗)
- [23\. Zookeeper 对节点的 watch 监听通知是永久的吗？为什么不是永久的?](#23\-zookeeper-对节点的-watch-监听通知是永久的吗为什么不是永久的)
- [24\. Zookeeper 的 java 客户端都有哪些？](#24\-zookeeper-的-java-客户端都有哪些)
- [25\. chubby 是什么，和 zookeeper 比你怎么看？](#25\-chubby-是什么和-zookeeper-比你怎么看)
- [26\. 说几个 zookeeper 常用的命令。](#26\-说几个-zookeeper-常用的命令)
- [27\. ZAB 和 Paxos 算法的联系与区别？](#27\-zab-和-paxos-算法的联系与区别)
- [28\. Zookeeper 的典型应用场景](#28\-zookeeper-的典型应用场景)
- [kafka篇](#kafka篇)
- [1、如何获取 topic 主题的列表](#1如何获取-topic-主题的列表)
- [2、生产者和消费者的命令行是什么？](#2生产者和消费者的命令行是什么)
- [3、consumer 是推还是拉？](#3consumer-是推还是拉)
- [4、讲讲 kafka 维护消费状态跟踪的方法](#4讲讲-kafka-维护消费状态跟踪的方法)
- [5、讲一下主从同步](#5讲一下主从同步)
- [6、为什么需要消息系统，mysql 不能满足需求吗？](#6为什么需要消息系统mysql-不能满足需求吗)
- [7、Zookeeper 对于 Kafka 的作用是什么？](#7zookeeper-对于-kafka-的作用是什么)
- [9、Kafka 判断一个节点是否还活着有那两个条件？](#9kafka-判断一个节点是否还活着有那两个条件)
- [10、Kafka 与传统 MQ 消息系统之间有三个关键区别](#10kafka-与传统-mq-消息系统之间有三个关键区别)
- [11、讲一讲 kafka 的 ack 的三种机制](#11讲一讲-kafka-的-ack-的三种机制)
- [12、消费者如何不自动提交偏移量，由应用提交？](#12消费者如何不自动提交偏移量由应用提交)
- [13、消费者故障，出现活锁问题如何解决？](#13消费者故障出现活锁问题如何解决)
- [14、如何控制消费的位置](#14如何控制消费的位置)
- [15、kafka 分布式（不是单机）的情况下，如何保证消息的顺序消费?](#15kafka-分布式不是单机的情况下如何保证消息的顺序消费)
- [16、kafka 的高可用机制是什么？](#16kafka-的高可用机制是什么)
- [17、kafka 如何减少数据丢失](#17kafka-如何减少数据丢失)
- [18、kafka 如何不消费重复数据？比如扣款，我们不能重复的扣。](#18kafka-如何不消费重复数据比如扣款我们不能重复的扣)
- [MQ篇](#mq篇)
- [1、为什么使用MQ](#1为什么使用mq)
- [2、MQ优缺点](#2mq优缺点)
- [3、Kafka、ActiveMQ、RabbitMQ、RocketMQ 都有什么区别？](#3kafkaactivemqrabbitmqrocketmq-都有什么区别)
- [4、如何保证高可用的？](#4如何保证高可用的)
- [5、如何保证消息的可靠传输？如果消息丢了怎么办](#5如何保证消息的可靠传输如果消息丢了怎么办)
- [6、如何保证消息的顺序性](#6如何保证消息的顺序性)
- [7、 如何解决消息队列的延时以及过期失效问题？消息队列满了以后该怎么处理？有几百万消息持续积压几小时，说说怎么解决？](#7-如何解决消息队列的延时以及过期失效问题消息队列满了以后该怎么处理有几百万消息持续积压几小时说说怎么解决)
- [8、设计MQ的思路](#8设计mq的思路)
- [Elasticsearch篇](#elasticsearch篇)
- [1、elasticsearch 了解多少，说说你们公司 es 的集群架构，索引数据大小，分片有多少，以及一些调优手段 。](#1elasticsearch-了解多少说说你们公司-es-的集群架构索引数据大小分片有多少以及一些调优手段-)
- [1.1、设计阶段调优](#11设计阶段调优)
- [1.2、写入调优](#12写入调优)
- [1.3、查询调优](#13查询调优)
- [1.4、其他调优](#14其他调优)
- [2、elasticsearch 的倒排索引是什么](#2elasticsearch-的倒排索引是什么)
- [3、elasticsearch 索引数据多了怎么办，如何调优，部署](#3elasticsearch-索引数据多了怎么办如何调优部署)
- [3.1 动态索引层面](#31-动态索引层面)
- [3.2 存储层面](#32-存储层面)
- [3.3 部署层面](#33-部署层面)
- [4、elasticsearch 是如何实现 master 选举的](#4elasticsearch-是如何实现-master-选举的)
- [5、详细描述一下 Elasticsearch 索引文档的过程](#5详细描述一下-elasticsearch-索引文档的过程)
- [6、详细描述一下 Elasticsearch 搜索的过程？](#6详细描述一下-elasticsearch-搜索的过程)
- [7、Elasticsearch 在部署时，对 Linux 的设置有哪些优化方法](#7elasticsearch-在部署时对-linux-的设置有哪些优化方法)
- [8、lucence 内部结构是什么？](#8lucence-内部结构是什么)
- [9、Elasticsearch 是如何实现 Master 选举的？](#9elasticsearch-是如何实现-master-选举的)
- [10、Elasticsearch 中的节点（比如共 20 个），其中的 10 个](#10elasticsearch-中的节点比如共-20-个其中的-10-个)
- [11、客户端在和集群连接时，如何选择特定的节点执行请求的？](#11客户端在和集群连接时如何选择特定的节点执行请求的)
- [12、详细描述一下 Elasticsearch 索引文档的过程。](#12详细描述一下-elasticsearch-索引文档的过程)
- [13、详细描述一下 Elasticsearch 更新和删除文档的过程。](#13详细描述一下-elasticsearch-更新和删除文档的过程)
- [14、详细描述一下 Elasticsearch 搜索的过程。](#14详细描述一下-elasticsearch-搜索的过程)
- [15、在 Elasticsearch 中，是怎么根据一个词找到对应的倒排索引的？](#15在-elasticsearch-中是怎么根据一个词找到对应的倒排索引的)
- [16、Elasticsearch 在部署时，对 Linux 的设置有哪些优化方法？](#16elasticsearch-在部署时对-linux-的设置有哪些优化方法)
- [17、对于 GC 方面，在使用 Elasticsearch 时要注意什么？](#17对于-gc-方面在使用-elasticsearch-时要注意什么)
- [18、Elasticsearch 对于大数据量（上亿量级）的聚合如何实现？](#18elasticsearch-对于大数据量上亿量级的聚合如何实现)
- [19、在并发情况下，Elasticsearch 如果保证读写一致？](#19在并发情况下elasticsearch-如果保证读写一致)
- [20、如何监控 Elasticsearch 集群状态？](#20如何监控-elasticsearch-集群状态)
- [21、介绍下你们电商搜索的整体技术架构。](#21介绍下你们电商搜索的整体技术架构)
- [22、介绍一下你们的个性化搜索方案？](#22介绍一下你们的个性化搜索方案)
- [23、是否了解字典树？](#23是否了解字典树)
- [24、拼写纠错是如何实现的？](#24拼写纠错是如何实现的)
- [Linux篇](#linux篇)
- [1、绝对路径用什么符号表示？当前目录、上层目录用什么表示？主目录用什么表示? 切换目录用什么命令？](#1绝对路径用什么符号表示当前目录上层目录用什么表示主目录用什么表示-切换目录用什么命令)
- [2、怎么查看当前进程？怎么执行退出？怎么查看当前路径？](#2怎么查看当前进程怎么执行退出怎么查看当前路径)
- [3、怎么清屏？怎么退出当前命令？怎么执行睡眠？怎么查看当前用户 id？查看指定帮助用什么命令？](#3怎么清屏怎么退出当前命令怎么执行睡眠怎么查看当前用户-id查看指定帮助用什么命令)
- [4、Ls 命令执行什么功能？ 可以带哪些参数，有什么区别？](#4ls-命令执行什么功能-可以带哪些参数有什么区别)
- [5、建立软链接(快捷方式)，以及硬链接的命令。](#5建立软链接快捷方式以及硬链接的命令)
- [6、目录创建用什么命令？创建文件用什么命令？复制文件用什么命令？](#6目录创建用什么命令创建文件用什么命令复制文件用什么命令)
- [7、查看文件内容有哪些命令可以使用？](#7查看文件内容有哪些命令可以使用)
- [8、随意写文件命令？怎么向屏幕输出带空格的字符串，比如”hello world”?](#8随意写文件命令怎么向屏幕输出带空格的字符串比如hello-world)
- [9、终端是哪个文件夹下的哪个文件？黑洞文件是哪个文件夹下的哪个命令？](#9终端是哪个文件夹下的哪个文件黑洞文件是哪个文件夹下的哪个命令)
- [10、移动文件用哪个命令？改名用哪个命令？](#10移动文件用哪个命令改名用哪个命令)
- [11、复制文件用哪个命令？如果需要连同文件夹一块复制呢？如果需要有提示功能呢？](#11复制文件用哪个命令如果需要连同文件夹一块复制呢如果需要有提示功能呢)
- [12、删除文件用哪个命令？如果需要连目录及目录下文件一块删除呢？删除空文件夹用什么命令？](#12删除文件用哪个命令如果需要连目录及目录下文件一块删除呢删除空文件夹用什么命令)
- [13、Linux 下命令有哪几种可使用的通配符？分别代表什么含义?](#13linux-下命令有哪几种可使用的通配符分别代表什么含义)
- [14、用什么命令对一个文件的内容进行统计？(行号、单词数、字节数)](#14用什么命令对一个文件的内容进行统计行号单词数字节数)
- [15、Grep 命令有什么用？ 如何忽略大小写？ 如何查找不含该串的行?](#15grep-命令有什么用-如何忽略大小写-如何查找不含该串的行)
- [16、Linux 中进程有哪几种状态？在 ps 显示出来的信息中，分别用什么符号表示的？](#16linux-中进程有哪几种状态在-ps-显示出来的信息中分别用什么符号表示的)
- [17、怎么使一个命令在后台运行?](#17怎么使一个命令在后台运行)
- [18、利用 ps 怎么显示所有的进程? 怎么利用 ps 查看指定进程的信息？](#18利用-ps-怎么显示所有的进程-怎么利用-ps-查看指定进程的信息)
- [19、哪个命令专门用来查看后台任务?](#19哪个命令专门用来查看后台任务)
- [20、把后台任务调到前台执行使用什么命令?把停下的后台任务在后台执行起来用什么命令?](#20把后台任务调到前台执行使用什么命令把停下的后台任务在后台执行起来用什么命令)
- [21、终止进程用什么命令? 带什么参数?](#21终止进程用什么命令-带什么参数)
- [22、怎么查看系统支持的所有信号？](#22怎么查看系统支持的所有信号)
- [23、搜索文件用什么命令? 格式是怎么样的?](#23搜索文件用什么命令-格式是怎么样的)
- [24、查看当前谁在使用该主机用什么命令? 查找自己所在的终端信息用什么命令?](#24查看当前谁在使用该主机用什么命令-查找自己所在的终端信息用什么命令)
- [25、使用什么命令查看用过的命令列表?](#25使用什么命令查看用过的命令列表)
- [26、使用什么命令查看磁盘使用空间？ 空闲空间呢?](#26使用什么命令查看磁盘使用空间-空闲空间呢)
- [27、使用什么命令查看网络是否连通?](#27使用什么命令查看网络是否连通)
- [28、使用什么命令查看 ip 地址及接口信息？](#28使用什么命令查看-ip-地址及接口信息)
- [29、查看各类环境变量用什么命令?](#29查看各类环境变量用什么命令)
- [30、通过什么命令指定命令提示符?](#30通过什么命令指定命令提示符)
- [31、查找命令的可执行文件是去哪查找的? 怎么对其进行设置及添加?](#31查找命令的可执行文件是去哪查找的-怎么对其进行设置及添加)
- [32、通过什么命令查找执行命令?](#32通过什么命令查找执行命令)
- [33、怎么对命令进行取别名？](#33怎么对命令进行取别名)
- [34、du 和 df 的定义，以及区别？](#34du-和-df-的定义以及区别)
- [35、awk 详解。](#35awk-详解)
- [36、当你需要给命令绑定一个宏或者按键的时候，应该怎么做呢？](#36当你需要给命令绑定一个宏或者按键的时候应该怎么做呢)
- [37、如果一个 linux 新手想要知道当前系统支持的所有命令的列表，他需要怎么做？](#37如果一个-linux-新手想要知道当前系统支持的所有命令的列表他需要怎么做)
- [38、如果你的助手想要打印出当前的目录栈，你会建议他怎么做？](#38如果你的助手想要打印出当前的目录栈你会建议他怎么做)
- [39、你的系统目前有许多正在运行的任务，在不重启机器的条件下，有什么方法可以把所有正在运行的进程移除呢？](#39你的系统目前有许多正在运行的任务在不重启机器的条件下有什么方法可以把所有正在运行的进程移除呢)
- [40、bash shell 中的 hash 命令有什么作用？](#40bash-shell-中的-hash-命令有什么作用)
- [41、哪一个 bash 内置命令能够进行数学运算。](#41哪一个-bash-内置命令能够进行数学运算)
- [42、怎样一页一页地查看一个大文件的内容呢？](#42怎样一页一页地查看一个大文件的内容呢)
- [43、数据字典属于哪一个用户的？](#43数据字典属于哪一个用户的)
- [44、怎样查看一个 linux 命令的概要与用法？假设你在/bin 目录中偶然看到一个你从没见过的的命令，怎样才能知道它的作用和用法呢？](#44怎样查看一个-linux-命令的概要与用法假设你在bin-目录中偶然看到一个你从没见过的的命令怎样才能知道它的作用和用法呢)
- [45、使用哪一个命令可以查看自己文件系统的磁盘空间配额呢？](#45使用哪一个命令可以查看自己文件系统的磁盘空间配额呢)
- [46、列举几个常用的Linux命令](#46列举几个常用的linux命令)
- [47、你平时是怎么查看日志的？](#47你平时是怎么查看日志的)
- [数据结构与算法篇](#数据结构与算法篇)
- [1、常用的数据结构](#1常用的数据结构)
- [1. 数组](#1-数组)
- [2. 栈](#2-栈)
- [3. 队列](#3-队列)
- [4. 链表](#4-链表)
- [5. 图](#5-图)
- [6. 树](#6-树)
- [7. 前缀树](#7-前缀树)
- [8. 哈希表](#8-哈希表)
- [2、 数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组（请以代码实现）](#2-数据里有123456789请随机打乱顺序生成一个新的数组请以代码实现)
- [3、 写出代码判断一个整数是不是2的阶次方（请代码实现，谢绝调用API方法）](#3-写出代码判断一个整数是不是2的阶次方请代码实现谢绝调用api方法)
- [4、 假设今日是2015年3月1日，星期日，请算出13个月零6天后是星期几，距离现在多少天（请用代码实现，谢绝调用API方法）](#4-假设今日是2015年3月1日星期日请算出13个月零6天后是星期几距离现在多少天请用代码实现谢绝调用api方法)
- [5、 有两个篮子，分别为A 和 B，篮子A里装有鸡蛋，篮子B里装有苹果，请用面向对象的思想实现两个篮子里的物品交换（请用代码实现）](#5-有两个篮子分别为a-和-b篮子a里装有鸡蛋篮子b里装有苹果请用面向对象的思想实现两个篮子里的物品交换请用代码实现)
- [6、更多算法练习](#6更多算法练习)
- [简历篇](#简历篇)
- [为什么说简历很重要？](#为什么说简历很重要)
- [先从面试来说](#先从面试来说)
- [再从面试说起](#再从面试说起)
- [必知必会的几点](#必知必会的几点)
- [必须了解的两大法则](#必须了解的两大法则)
- [项目经历怎么写](#项目经历怎么写)
- [专业技能怎么写](#专业技能怎么写)
- [排版注意事项](#排版注意事项)
- [其他一些小tips](#其他一些小tips)
## 基础篇
### 1、 Java语言有哪些特点
1、简单易学、有丰富的类库
2、面向对象（Java最重要的特性，让程序耦合度更低，内聚性更高）
3、与平台无关性（JVM是Java跨平台使用的根本）
4、可靠安全
5、支持多线程
### 2、面向对象和面向过程的区别
**面向过程**：是分析解决问题的步骤，然后用函数把这些步骤一步一步地实现，然后在使用的时候一一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发
**面向对象**：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有**封装、继承、多态**的特性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要低。
### 3 、八种基本数据类型的大小，以及他们的封装类
| 基本类型 | 大小（字节） | 默认值 | 封装类 |
| -------- | ------------ | ------------ | --------- |
| byte | 1 | (byte)0 | Byte |
| short | 2 | (short)0 | Short |
| int | 4 | 0 | Integer |
| long | 8 | 0L | Long |
| float | 4 | 0.0f | Float |
| double | 8 | 0.0d | Double |
| boolean | - | false | Boolean |
| char | 2 | \u0000(null) | Character |
注：
1.int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个对象，再任何引用使用前，必须为其指定一个对象，否则会报错。
2.基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。
虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。使用int的原因是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。
### 4、标识符的命名规则。
**标识符的含义：**
是指在程序中，我们自己定义的内容，譬如，类的名字，方法名称以及变量名称等等，都是标识符。
**命名规则：（硬性要求）**
标识符可以包含英文字母，0-9的数字，$以及_
标识符不能以数字开头
标识符不是关键字
**命名规范：（非硬性要求）**
类名规范：首字符大写，后面每个单词首字母大写（大驼峰式）。
变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）。
方法名规范：同变量名。
### 5、instanceof 关键字的作用
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
```java
boolean result = obj instanceof Class
```
其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。
```java
int i = 0;
System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型
System.out.println(i instanceof Object);//编译不通过
```
```java
Integer integer = new Integer(1);
System.out.println(integer instanceof Integer);//true
```
```java
//false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果 obj 为 null，那么将返回 false。
System.out.println(null instanceof Object);
```
### 6、Java自动装箱与拆箱
**装箱就是自动将基本数据类型转换为包装器类型（int-->Integer）；调用方法：Integer的valueOf(int) 方法**
**拆箱就是自动将包装器类型转换为基本数据类型（Integer-->int）。调用方法：Integer的intValue方法 **
在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行：
```java
Integer i = new Integer(10);
```
而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：
```java
Integer i = 10;
```
***面试题1： 以下代码会输出什么？***
```java
public class Main {
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1==i2);
System.out.println(i3==i4);
}
}
```
运行结果：
```
true
false
```
为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：
```java
public static Integer valueOf(int i) {
if(i >= -128 && i 显示的字节数
-n 显示行数
-q, --quiet, --silent 从不输出给出文件名的首部
-s, --sleep-interval=S 与-f合用,表示在每次反复的间隔休眠S秒
例如：
```
tail -n 10 test.log 查询日志尾部最后10行的日志;
tail -n +10 test.log 查询10行之后的所有日志;
tail -fn 10 test.log 循环实时查看最后1000行记录(最常用的)
```
一般还会配合着grep搜索用，例如 :
```
tail -fn 1000 test.log | grep '关键字'
```
如果一次性查询的数据量太大,可以进行翻页查看，例如:
```
tail -n 4700 aa.log |more -1000 可以进行多屏显示(ctrl + f 或者 空格键可以快捷键)
```
**2、head**
跟tail是相反的head是看前多少行日志
```
head -n 10 test.log 查询日志文件中的头10行日志;
head -n -10 test.log 查询日志文件除了最后10行的其他所有日志;
```
head其他参数参考tail
**3、cat**
cat 是由第一行到最后一行连续显示在屏幕上
一次显示整个文件 :
```
$ cat filename
```
从键盘创建一个文件 :
```
$cat > filename
```
将几个文件合并为一个文件：
```
$cat file1 file2 > file 只能创建新文件,不能编辑已有文件
```
将一个日志文件的内容追加到另外一个 :
```
$cat -n textfile1 > textfile2
```
清空一个日志文件:
```
$cat : >textfile2
```
注意：> 意思是创建，>>是追加。千万不要弄混了。
cat其他参数参考tail
**4、more**
more命令是一个基于vi编辑器文本过滤器，它以全屏幕的方式按页显示文本文件的内容，支持vi中的关键字定位操作。more名单中内置了若干快捷键，常用的有H（获得帮助信息），Enter（向下翻滚一行），空格（向下滚动一屏），Q（退出命令）。more命令从前向后读取文件，因此在启动时就加载整个文件。
该命令一次显示一屏文本，满屏后停下来，并且在屏幕的底部出现一个提示信息，给出至今己显示的该文件的百分比：–More–（XX%）
- more的语法：more 文件名
- Enter 向下n行，需要定义，默认为1行
- Ctrl f 向下滚动一屏
- 空格键 向下滚动一屏
- Ctrl b 返回上一屏
- = 输出当前行的行号
- :f 输出文件名和当前行的行号
- v 调用vi编辑器
- !命令 调用Shell，并执行命令
- q退出more
**5、sed**
这个命令可以查找日志文件特定的一段 , 根据时间的一个范围查询，可以按照行号和时间范围查询
按照行号
```
sed -n '5,10p' filename 这样你就可以只查看文件的第5行到第10行。
```
按照时间段
```
sed -n '/2014-12-17 16:17:20/,/2014-12-17 16:17:36/p' test.log
```
**6、less**
less命令在查询日志时，一般流程是这样的
```
less log.log
shift + G 命令到文件尾部 然后输入 ？加上你要搜索的关键字例如 ？1213
按 n 向上查找关键字
shift+n 反向查找关键字
less与more类似，使用less可以随意浏览文件，而more仅能向前移动，不能向后移动，而且 less 在查看之前不会加载整个文件。
less log2013.log 查看文件
ps -ef | less ps查看进程信息并通过less分页显示
history | less 查看命令历史使用记录并通过less分页显示
less log2013.log log2014.log 浏览多个文件
```
常用命令参数：
```
less与more类似，使用less可以随意浏览文件，而more仅能向前移动，不能向后移动，而且 less 在查看之前不会加载整个文件。
less log2013.log 查看文件
ps -ef | less ps查看进程信息并通过less分页显示
history | less 查看命令历史使用记录并通过less分页显示
less log2013.log log2014.log 浏览多个文件
常用命令参数：
-b 设置缓冲区的大小
-g 只标志最后搜索的关键词
-i 忽略搜索时的大小写
-m 显示类似more命令的百分比
-N 显示每行的行号
-o 将less 输出的内容在指定文件中保存起来
-Q 不使用警告音
-s 显示连续空行为一行
/字符串：向下搜索"字符串"的功能
?字符串：向上搜索"字符串"的功能
n：重复前一个搜索（与 / 或 ? 有关）
N：反向重复前一个搜索（与 / 或 ? 有关）
b 向后翻一页
h 显示帮助界面
q 退出less 命令
```
一般本人查日志配合应用的其他命令
```
history // 所有的历史记录
history | grep XXX // 历史记录中包含某些指令的记录
history | more // 分页查看记录
history -c // 清空所有的历史记录
!! 重复执行上一个命令
查询出来记录后选中 : !323
```
## 数据结构与算法篇
### 1、常用的数据结构
> 原文：[The top data structures you should know for your next coding interview](https://medium.freecodecamp.org/the-top-data-structures-you-should-know-for-your-next-coding-interview-36af0831f5e3)
>
> 译者：[Fundebug](https://www.fundebug.com/)
我们首先列出最常用的数据结构
- 数组
- 堆栈
- 队列
- 链表
- 树
- 图
- 字典树
- 哈希表
##### 1. 数组
**数组(Array)**大概是最简单，也是最常用的数据结构了。其他数据结构，比如栈和队列都是由数组衍生出来的。
下图展示了 1 个数组，它有 4 个元素：
每一个数组元素的位置由数字编号，称为下标或者索引(index)。大多数编程语言的数组第一个元素的下标是 0。
根据维度区分，有 2 种不同的数组：
- 一维数组(如上图所示)
- 多维数组(数组的元素为数组)
**数组的基本操作**
- Insert - 在某个索引处插入元素
- Get - 读取某个索引处的元素
- Delete - 删除某个索引处的元素
- Size - 获取数组的长度
**常见数组代码面试题**
- [查找数组中第二小的元素](https://www.geeksforgeeks.org/to-find-smallest-and-second-smallest-element-in-an-array/)：https://www.geeksforgeeks.org/to-find-smallest-and-second-smallest-element-in-an-array/
- [查找第一个没有重复的数组元素](https://www.geeksforgeeks.org/non-repeating-element/)： https://www.geeksforgeeks.org/non-repeating-element/
- [合并 2 个排序好的数组](https://www.geeksforgeeks.org/merge-two-sorted-arrays/)：https://www.geeksforgeeks.org/merge-two-sorted-arrays/
- [重新排列数组中的正数和负数](https://www.geeksforgeeks.org/rearrange-positive-and-negative-numbers-publish/): https://www.geeksforgeeks.org/rearrange-positive-and-negative-numbers-publish/
##### 2. 栈
撤回，即 Ctrl+Z，是我们最常见的操作之一，大多数应用都会支持这个功能。你知道它是怎么实现的吗？答案是这样的：把之前的应用状态(限制个数)保存到内存中，最近的状态放到第一个。这时，我们需要**栈(stack)**来实现这个功能。
栈中的元素采用 LIFO (Last In First Out)，即**后进先出**。
下图的栈有 3 个元素，3 在最上面，因此它会被第一个移除：
**栈的基本操作**
- Push — 在栈的最上方插入元素
- Pop — 返回栈最上方的元素，并将其删除
- isEmpty — 查询栈是否为空
- Top — 返回栈最上方的元素，并不删除
**常见的栈代码面试题**
- [使用栈计算后缀表达式](https://www.geeksforgeeks.org/stack-set-4-evaluation-postfix-expression/)：https://www.geeksforgeeks.org/stack-set-4-evaluation-postfix-expression/
- [使用栈为栈中的元素排序](https://www.geeksforgeeks.org/sort-stack-using-temporary-stack/)：https://www.geeksforgeeks.org/sort-stack-using-temporary-stack/
- [检查字符串中的括号是否匹配正确](https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/)：https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/
##### 3. 队列
**队列(Queue)**与栈类似，都是采用线性结构存储数据。它们的区别在于，栈采用 LIFO 方式，而队列采用先进先出，即**FIFO(First in First Out)**。
下图展示了一个队列，1 是最上面的元素，它会被第一个移除：
**队列的基本操作**
- Enqueue — 在队列末尾插入元素
- Dequeue — 将队列第一个元素删除
- isEmpty — 查询队列是否为空
- Top — 返回队列的第一个元素
**常见的队列代码面试题**
- [使用队列实现栈](https://www.geeksforgeeks.org/implement-stack-using-queue/)：https://www.geeksforgeeks.org/implement-stack-using-queue/
- [倒转队列的前 K 个元素](https://www.geeksforgeeks.org/reversing-first-k-elements-queue/)：https://www.geeksforgeeks.org/reversing-first-k-elements-queue/
- [使用队列将 1 到 n 转换为二进制](https://www.geeksforgeeks.org/interesting-method-generate-binary-numbers-1-n/): https://www.geeksforgeeks.org/interesting-method-generate-binary-numbers-1-n/
##### 4. 链表
**链表(Linked List)**也是线性结构，它与数组看起来非常像，但是它们的内存分配方式、内部结构和插入删除操作方式都不一样。
链表是一系列节点组成的链，每一个节点保存了数据以及指向下一个节点的指针。链表头指针指向第一个节点，如果链表为空，则头指针为空或者为 null。
链表可以用来实现文件系统、哈希表和邻接表。
下图展示了一个链表，它有 3 个节点：
链表分为 2 种：
- 单向链表
- 双向链表
**链表的基本操作**
- InsertAtEnd — 在链表结尾插入元素
- InsertAtHead — 在链表开头插入元素
- Delete — 删除链表的指定元素
- DeleteAtHead — 删除链表第一个元素
- Search — 在链表中查询指定元素
- isEmpty — 查询链表是否为空
**常见的队列代码面试题**
- [倒转 1 个链表](https://www.geeksforgeeks.org/reverse-a-linked-list/)：https://www.geeksforgeeks.org/reverse-a-linked-list/
- [检查链表中是否存在循环](https://www.geeksforgeeks.org/detect-loop-in-a-linked-list/)：https://www.geeksforgeeks.org/detect-loop-in-a-linked-list/
- [返回链表倒数第 N 个元素](https://www.geeksforgeeks.org/nth-node-from-the-end-of-a-linked-list/)：https://www.geeksforgeeks.org/nth-node-from-the-end-of-a-linked-list/
- [移除链表中的重复元素](https://www.geeksforgeeks.org/remove-duplicates-from-an-unsorted-linked-list/)：https://www.geeksforgeeks.org/remove-duplicates-from-an-unsorted-linked-list/
##### 5. 图
**图(graph)**由多个**节点(vertex)**构成，节点之间阔以互相连接组成一个网络。(x, y)表示一条**边(edge)**，它表示节点 x 与 y 相连。边可能会有**权值(weight/cost)**。
**图分为两种:**
- 无向图
- 有向图
**在编程语言中，图有可能有以下两种形式表示：**
- 邻接矩阵(Adjacency Matrix)
- 邻接表(Adjacency List)
**遍历图有两周算法**
- 广度优先搜索(Breadth First Search)
- 深度优先搜索(Depth First Search)
**常见的图代码面试题**
- [实现广度优先搜索](https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/)： https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/
- [实现深度优先搜索](https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/)： https://www.geeksforgeeks.org/depth-first-search-or-dfs-for-a-graph/
- [检查图是否为树](https://www.geeksforgeeks.org/check-given-graph-tree/)： https://www.geeksforgeeks.org/check-given-graph-tree/
- [统计图中边的个数](https://www.geeksforgeeks.org/count-number-edges-undirected-graph/)：https://www.geeksforgeeks.org/count-number-edges-undirected-graph/
- [使用 Dijkstra 算法查找两个节点之间的最短距离](https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/)： https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/
##### 6. 树
**树(Tree)**是一个分层的数据结构，由节点和连接节点的边组成。树是一种特殊的图，它与图最大的区别是没有循环。
树被广泛应用在人工智能和一些复杂算法中，用来提供高效的存储结构。
下图是一个简单的树以及与树相关的术语：
**树有很多分类：**
- N 叉树(N-ary Tree)
- 平衡树(Balanced Tree)
- 二叉树(Binary Tree)
- 二叉查找树(Binary Search Tree)
- 平衡二叉树(AVL Tree)
- 红黑树(Red Black Tree)
- 2-3 树(2–3 Tree)
其中，二叉树和二叉查找树是最常用的树。
**常见的树代码面试题**
- [计算树的高度](https://www.geeksforgeeks.org/write-a-c-program-to-find-the-maximum-depth-or-height-of-a-tree/)：https://www.geeksforgeeks.org/write-a-c-program-to-find-the-maximum-depth-or-height-of-a-tree/
- [查找二叉平衡树中第 K 大的元素](https://www.geeksforgeeks.org/kth-largest-element-in-bst-when-modification-to-bst-is-not-allowed/)：https://www.geeksforgeeks.org/kth-largest-element-in-bst-when-modification-to-bst-is-not-allowed/
- [查找树中与根节点距离为 k 的节点](https://www.geeksforgeeks.org/print-nodes-at-k-distance-from-root/)：https://www.geeksforgeeks.org/print-nodes-at-k-distance-from-root/
- [查找二叉树中某个节点所有祖先节点](https://www.geeksforgeeks.org/print-ancestors-of-a-given-node-in-binary-tree/)：https://www.geeksforgeeks.org/print-ancestors-of-a-given-node-in-binary-tree/
##### 7. 前缀树
**前缀树(Prefix Trees 或者 Trie)**与树类似，用于处理字符串相关的问题时非常高效。它可以实现快速检索，常用于字典中的单词查询，搜索引擎的自动补全甚至 IP 路由。
下图展示了“top”, “thus”和“their”三个单词在前缀树中如何存储的：
单词是按照字母从上往下存储，“p”, “s”和“r”节点分别表示“top”, “thus”和“their”的单词结尾。
**常见的树代码面试题**
- [统计前缀树表示的单词个数](https://www.geeksforgeeks.org/counting-number-words-trie/)：https://www.geeksforgeeks.org/counting-number-words-trie/
- [使用前缀树为字符串数组排序](https://www.geeksforgeeks.org/sorting-array-strings-words-using-trie/)： https://www.geeksforgeeks.org/sorting-array-strings-words-using-trie/
##### 8. 哈希表
**哈希(Hash)**将某个对象变换为唯一标识符，该标识符通常用一个短的随机字母和数字组成的字符串来代表。哈希可以用来实现各种数据结构，其中最常用的就是**哈希表(hash table)**。
哈希表通常由数组实现。
哈希表的性能取决于 3 个指标：
- 哈希函数
- 哈希表的大小
- 哈希冲突处理方式
下图展示了有数组实现的哈希表，数组的下标即为哈希值，由哈希函数计算，作为哈希表的**键(key)**，而数组中保存的数据即为**值(value)**：
**常见的哈希表代码面试题**
- [查找数组中对称的组合](https://www.geeksforgeseks.org/given-an-array-of-pairs-find-all-symmetric-pairs-in-it/)： https://www.geeksforgeseks.org/given-an-array-of-pairs-find-all-symmetric-pairs-in-it/
- [确认某个数组的元素是否为另一个数组元素的子集](https://www.geeksforgeeks.org/find-whether-an-array-is-subset-of-another-array-set-1/)： https://www.geeksforgeeks.org/find-whether-an-array-is-subset-of-another-array-set-1/
- [确认给定的数组是否互斥](https://www.geeksforgeeks.org/check-two-given-sets-disjoint/)： https://www.geeksforgeeks.org/check-two-given-sets-disjoint/
### 2、 数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组（请以代码实现）
```java
import java.util.Arrays;
//打乱数组
public class Demo1 {
//随机打乱
public static int[] srand(int[] a) {
int[] b = new int[a.length];
for(int i = 0; i < a.length;i++) {
//随机获取下标
int tmp = (int)(Math.random()*(a.length - i)); //随机数:[ 0 ，a.length - i )
b[i] = a[tmp];
//将此时a[tmp]的下标移动到靠后的位置
int change = a[a.length - i - 1];
a[a.length - i - 1] = a[tmp];
a[tmp] = change;
}
return b;
}
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8,9};
System.out.println(Arrays.toString(srand(a)));
}
}
```
### 3、 写出代码判断一个整数是不是2的阶次方（请代码实现，谢绝调用API方法）
```java
import java.util.Scanner;
//判断整数是不是2的阶次方
public class Demo2 {
public static boolean check(int sum) {
boolean flag = true; //判断标志
while(sum > 1) {
if (sum % 2 == 0) {
sum = sum/2;
} else {
flag = false;
break;
}
}
return flag;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数:");
int sum = scanner.nextInt();
System.out.println(sum + " 是不是2的阶次方：" + check(sum));
}
}
```
### 4、 假设今日是2015年3月1日，星期日，请算出13个月零6天后是星期几，距离现在多少天（请用代码实现，谢绝调用API方法）
```java
import java.util.Scanner;
//算出星期几
public class Demo4 {
public static String[] week = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
public static int i = 0;
public static int[] monthday1 = {0,31,28,31,30,31,30,31,31,30,31,30,31};
public static int[] monthday2 = {0,31,29,31,30,31,30,31,31,30,31,30,31};
//查看距离当前天数的差值
public static String distance(int year,int month,int day,int newMonth,int newDay) {
int sum = 0; //设定初始距离天数
if (month + newMonth >= 12) {
if (((year + 1) % 4 == 0 && (year + 1) % 100 != 0)||(year + 1) % 400 == 0) {
sum += 366 + newDay;
for(int i = 0;i < newMonth - 12;i++) {
sum += monthday1[month + i];
}
} else {
sum += 365 + newDay;
for(int i = 0;i < newMonth - 12;i++) {
sum += monthday1[month + i];
}
}
} else {
for(int i = 0;i < newMonth;i++) {
sum += monthday1[month + i];
}
sum += newDay;
}
return week[sum%7];
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入当前年份");
int year = scanner.nextInt();
System.out.println("请输入当前月份");
int month = scanner.nextInt();
System.out.println("请输入当前天数");
int day = scanner.nextInt();
System.out.println("请输入当前是星期几：以数字表示，如：星期天 为 0");
int index = scanner.nextInt();
System.out.println("今天是：" + year + "-" + month + "-" + day + " " + week[index]);
System.err.println("请输入相隔月份");
int newMonth = scanner.nextInt();
System.out.println("请输入剩余天数");
int newDay = scanner.nextInt();
System.out.println("经过" + newMonth + "月" + newDay + "天后，是" + distance(year,month,day,newMonth,newDay));
}
}
```
### 5、 有两个篮子，分别为A 和 B，篮子A里装有鸡蛋，篮子B里装有苹果，请用面向对象的思想实现两个篮子里的物品交换（请用代码实现）
```java
//面向对象思想实现篮子物品交换
public class Demo5 {
public static void main(String[] args) {
//创建篮子
Basket A = new Basket("A");
Basket B = new Basket("B");
//装载物品
A.load("鸡蛋");
B.load("苹果");
//交换物品
A.change(B);
A.show();
B.show();
}
}
class Basket{
public String name; //篮子名称
private Goods goods; //篮子中所装物品
public Basket(String name) {
// TODO Auto-generated constructor stub
this.name = name;
System.out.println(name + "篮子被创建");
}
//装物品函数
public void load(String name) {
goods = new Goods(name);
System.out.println(this.name + "装载了" + name + "物品");
}
public void change(Basket B) {
System.out.println(this.name + " 和 " + B.name + "中的物品发生了交换");
String tmp = this.goods.getName();
this.goods.setName(B.goods.getName());
B.goods.setName(tmp);
}
public void show() {
System.out.println(this.name + "中有" + goods.getName() + "物品");
}
}
class Goods{
private String name; //物品名称
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Goods(String name) {
// TODO Auto-generated constructor stub
this.name = name;
}
}
```
### 6、更多算法练习
**更多算法练习题，请访问 https://leetcode-cn.com/problemset/algorithms/**
## 简历篇
> 原文： https://www.cnblogs.com/QQ12538552/p/12332620.html
本篇文章除了教大家用Markdown如何写一份程序员专属的简历，后面还会给大家推荐一些不错的用来写Markdown简历的软件或者网站，以及如何优雅的将Markdown格式转变为PDF格式或者其他格式。
推荐大家使用Markdown语法写简历，然后再将Markdown格式转换为PDF格式后进行简历投递。
如果你对Markdown语法不太了解的话，可以花半个小时简单看一下Markdown语法说明: [http://www.markdown.cn](http://www.markdown.cn/) 。
### 为什么说简历很重要？
一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。为什么说简历很重要呢?
### 先从面试来说
假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。
所以，简历就像是我们的一个门面一样，它在很大程度上决定了你能否进入到下一轮的面试中。
### 再从面试说起
我发现大家比较喜欢看面经 ，这点无可厚非，但是大部分面经都没告诉你很多问题都是在特定条件下才问的。举个简单的例子：一般情况下你的简历上注明你会的东西才会被问到（Java、数据结构、网络、算法这些基础是每个人必问的），比如写了你会 redis,那面试官就很大概率会问你 redis 的一些问题。比如：redis的常见数据类型及应用场景、redis是单线程为什么还这么快、 redis 和 memcached 的区别、redis 内存淘汰机制等等。
所以，首先，你要明确的一点是：你不会的东西就不要写在简历上。另外，你要考虑你该如何才能让你的亮点在简历中凸显出来，比如：你在某某项目做了什么事情解决了什么问题（只要有项目就一定有要解决的问题）、你的某一个项目里使用了什么技术后整体性能和并发量提升了很多等等。
面试和工作是两回事，聪明的人会把面试官往自己擅长的领域领，其他人则被面试官牵着鼻子走。虽说面试和工作是两回事，但是你要想要获得自己满意的 offer ，你自身的实力必须要强。
### 必知必会的几点
大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。
大部分应届生找工作的硬伤是没有工作经验或实习经历，所以如果你是应届生就不要错过秋招和春招。一旦错过，你后面就极大可能会面临社招，这个时候没有工作经验的你可能就会面临各种碰壁，导致找不到一个好的工作
写在简历上的东西一定要慎重，这是面试官大量提问的地方；
将自己的项目经历完美的展示出来非常重要。
### 必须了解的两大法则
**STAR法则（Situation Task Action Result）**
- **Situation：** 事情是在什么情况下发生；
- **Task:：** 你是如何明确你的任务的；
- **Action：** 针对这样的情况分析，你采用了什么行动方式；
- **Result：** 结果怎样，在这样的情况下你学习到了什么。
简而言之，STAR法则，就是一种讲述自己故事的方式，或者说，是一个清晰、条理的作文模板。不管是什么，合理熟练运用此法则，可以轻松的对面试官描述事物的逻辑方式，表现出自己分析阐述问题的清晰性、条理性和逻辑性。
**FAB 法则（Feature Advantage Benefit）**
- **Feature：** 是什么；
- **Advantage：** 比别人好在哪些地方；
- **Benefit：** 如果雇佣你，招聘方会得到什么好处。
简单来说，这个法则主要是让你的面试官知道你的优势、招了你之后对公司有什么帮助。
### 项目经历怎么写
简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写：
1. 对项目整体设计的一个感受
2. 在这个项目中你负责了什么、做了什么、担任了什么角色
3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
### 专业技能怎么写
先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写(下面这部分内容摘自我的简历，大家可以根据自己的情况做一些修改和完善)：
- 计算机网络、数据结构、算法、操作系统等课内基础知识：掌握
- Java 基础知识：掌握
- JVM 虚拟机（Java内存区域、虚拟机垃圾算法、虚拟垃圾收集器、JVM内存管理）：掌握
- 高并发、高可用、高性能系统开发：掌握
- Struts2、Spring、Hibernate、Ajax、Mybatis、JQuery ：掌握
- SSH 整合、SSM 整合、 SOA 架构：掌握
- Dubbo： 掌握
- Zookeeper: 掌握
- 常见消息队列: 掌握
- Linux：掌握
- MySQL常见优化手段：掌握
- Spring Boot +Spring Cloud +Docker:了解
- Hadoop 生态相关技术中的 HDFS、Storm、MapReduce、Hive、Hbase ：了解
- Python 基础、一些常见第三方库比如OpenCV、wxpy、wordcloud、matplotlib：熟悉
### 排版注意事项
1. 尽量简洁，不要太花里胡哨；
2. 一些技术名词不要弄错了大小写比如MySQL不要写成mysql，Java不要写成java。这个在我看来还是比较忌讳的，所以一定要注意这个细节；
3. 中文和数字英文之间加上空格的话看起来会舒服一点；
### 其他一些小tips
1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。
2. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
3. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
4. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
5. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
6. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
7. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。