面试

一、 应用1.1 简略应用public class LockTest { // 新建锁 Lock lock = new ReentrantLock(); public static void main(String[] args) { // 测试 LockTest test = new LockTest(); test.te(); } public void te(){ try { // 获取锁 lock.lock(); System.out.println("获取到锁执行代码！"); } catch (Exception e) { e.printStackTrace(); } finally { // 肯定留神 在finally中开释锁 lock.unlock(); } }}1.2 tryLockLock比synchronized还是多一些性能的，比方能够设置规定工夫内获取不到锁就返回，不始终阻塞。 一个不合时宜的例子就是： synchronize就是一个舔狗，始终舔 直到天荒地老 lock 的 tryLock 就像是一个渣男，微微尝试一下，不适合放松下一个 public class LockTest02 { // 新建锁 Lock lock = new ReentrantLock(); public static void main(String[] args) { // 测试 LockTest02 test = new LockTest02(); new Thread(()->test.te()).start(); // test::teTryLock lambda写法 new Thread(test::teTryLock).start(); } private void teTryLock() { boolean res = false; try { // 尝试获取 5秒钟获取不到就完结 res = lock.tryLock(5,TimeUnit.SECONDS); if (res) { System.out.println("teTryLock获取到锁了，执行获取到锁的代码"); } else{ System.out.println("teTryLock没有获取到锁 执行没有获取到锁的代码"); } } catch (Exception e) { e.printStackTrace(); } finally { // 如果获取到锁了 再开释 if (res) { lock.unlock(); } } } public void te(){ try { // 获取锁 lock.lock(); System.out.println("te获取到锁执行代码！"); Thread.sleep(10000); } catch (Exception e) { e.printStackTrace(); } finally { // 肯定留神 在finally中开释锁 lock.unlock(); System.out.println("te开释锁！"); } }}输入后果：te获取到锁执行代码！teTryLock没有获取到锁 执行没有获取到锁的代码 te开释锁！1.3 lockInterruptiblysynchronized 如果开始期待是不能完结的 ...

一、 线程切换 线程的切换受操作系统的调度管制 简略流程是这样的： 操作系统让cpu执行线程1线程1执行到指令003的时候 操作系统让cpu执行线程2cpu会将线程1的执行半成品放到缓存中cpu接着执行线程2cpu执行线程2的004指令的时候 操作系统又让cpu执行线程1cpu从缓存拿出线程1的残次品接着执行cpu就是一个无脑的计算中心 它不论调度 只管计算（像极了咱们程序员）而操作系统 是负责调度的 （像极了咱们的领导）在这里应该能发现一个点那就是：线程的切换是须要消耗操作系统资源的 （领导使唤你干活儿 必定要节约领导工夫和精力）二、 单核cpu设置多线程 是否有意义一个cpu在一个时间段只能跑一个线程，我单个cpu设置多个线程有意义吗 ？ 当然有意义了，你只有一个脑子（CPU），你除了想你女朋友（如果你有），你还会想的姑娘吗~~（会的） 为什么呢，因为有时候你女朋友不肯定在耗费你的脑子 线程也是如此，比方一个线程01须要进行数据库数据加载，这时候它是不耗费cpu的，他是在耗费网络IO,CPU多值钱呀，必定不能闲暇，所以在线程01加载数据库数据的时候，就能够让CPU进行线程02的计算操作 CPU密集型： CPU密集型也叫计算密集型，简略说就是大部分时候CPU应用在100% ，而读写磁盘/内存工夫很短 比方大量数据计算的，进行数据分析的 ，也可能是CPU性能极差的而磁盘/内存性能很好的状况 IO密集型： IO密集型跟CPU密集型相同，大部分工夫CPU使用率很小，而读写磁盘/内存占用很大工夫 比方读数据库比拟多的，网络申请比拟多的，也可能是磁盘/内存品质差的的状况 三、 线程数越大越好吗当然不是了，线程数太大了，CPU就不干活了，只用来切换线程了 就比方程序员，一天内负责两个我的项目的开发 ，上午在公司9楼项目组，下午在公司6楼项目组， 这个还能够承受，如果开发100个呢 ？ 9点在1楼，刚坐下就要去2楼，2楼刚坐下又要去三楼，这一天工夫都用在换楼层了 写个小例子感受一下： public class NumTest { // 一有1亿条数据的数组 public static double[] arr = new double[100000000]; public static void main(String[] args) throws InterruptedException { // 初始化 Random r = new Random(); for (int i = 0; i < arr.length; i++) { arr[i] =r.nextInt(10); } // 单线程计算 getSum01(); // 2线程计算 getSum02(); // 多个线程计算 getSum03(); } // 单线程计算sum private static void getSum01() { long start = System.currentTimeMillis(); double sum = 0; // 遍历求和 for (int i = 0; i <arr.length ; i++) { sum = sum+arr[i]; } long end = System.currentTimeMillis(); // 输入日志 System.out.println("一个线程计算 耗时:"+(end-start) + "毫秒，" +" 计算结果:"+sum); } /** * 2个线程计算sum */ static double sum01,sum02; private static void getSum02() throws InterruptedException { // 第一个线程 计算0到一半 Thread thread01 = new Thread(() -> { for (int i = 0; i < arr.length / 2; i++) { sum01 = sum01 + arr[i]; } }); // 第二个线程 计算一半到length Thread thread02 = new Thread(() -> { for (int i = arr.length / 2; i < arr.length; i++) { sum02 = sum02 + arr[i]; } }); long start = System.currentTimeMillis(); thread01.start(); thread02.start(); // join 到主线程 阻塞 thread01.join(); thread02.join(); // 执行完之后 求一下两个线程别离求和的和 double sum =sum01+sum02; long end = System.currentTimeMillis(); // 打印日志 System.out.println("2个线程计算 耗时:"+(end-start) + "毫秒，" +" 计算结果:"+sum); } /** * 多个线程计算 * @throws InterruptedException */ private static void getSum03() throws InterruptedException { // 10个线程 可自行调节 int ThreadNum = 1000; // 创立ThreadNum个长度的long数组 存储各个线程的求和后果 double[] sums = new double[ThreadNum]; // 存储多个线程 Thread[] threads = new Thread[ThreadNum]; // 每个线程计算的数字个数 final int segCount = arr.length/ThreadNum; CountDownLatch cdl = new CountDownLatch(ThreadNum); // 创立多个线程 for (int i = 0; i < ThreadNum; i++) { int m = i; Thread thread = new Thread(() -> { // 每个线程执计算逻辑 for (int j = segCount*m; j <segCount*(m+1) && j < arr.length; j++) { sums[m]+=arr[j]; } cdl.countDown(); }); threads[i] = thread; } long start = System.currentTimeMillis(); // 全副启动 for (int i = 0; i < threads.length; i++) { threads[i].start(); } cdl.await(); // 最初求和 double sum = 0; for (int i = 0; i < sums.length; i++) { sum+=sums[i]; } long end = System.currentTimeMillis(); // 打印日志 System.out.println("多个线程计算 耗时:"+(end-start) + "毫秒，" +" 计算结果:"+sum); }}输入后果：一个线程计算 耗时:177毫秒， 计算结果:4.50063291E82个线程计算 耗时:99毫秒， 计算结果:4.50063291E8多个线程计算 耗时:162毫秒， 计算结果:4.50063291E8能够看进去 2个线程比一个执行快 然而1000个不肯定比2个执行快 因为1000个线程上下文切换就要破费很多资源 ...

用户线程&守护线程&线程组&线程优先级如果把公司比喻成过程， 那么你和我就是用户线程， 后勤部门就是守护线程（负责给你订水，清扫办公环境等）， 每个项目组就是一个线程组， 程序员等级就是优先级（高级程序员 总比高级程序员容易获取资源 概率大 但不是必定）。 一、 用户线程&守护线程public static void main(String[] args) { Thread t = new Thread(() -> { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); System.out.println("用户线程"); } catch (Exception e) { e.printStackTrace(); } } }); Thread tdeamon = new Thread(() -> { for (int i = 0; i < 100; i++) { try { Thread.sleep(1000); System.out.println("守护线程"); } catch (Exception e) { e.printStackTrace(); } } }); // 设置线程为守护线程 ！！必须在start之前设置 否则会报错 tdeamon.setDaemon(true); t.start(); tdeamon.start(); }能够复制执行一下看看，t完结之后，tdeamon尽管没运行够100次然而也就完结了 ...

一、 请解释一下对象的创立过程在前边 “话说 类加载过程”的文章中曾经介绍过了类加载过程 创建对象的时候会先去判断类是否曾经加载， 如果没有加载的话会先加载类， 如果曾经加载就会间接创建对象。 步骤如下： 1.class loading 2.class linking (vertification prepration resolution) 3.class initiaizing 4.申请对象内存 5.成员变量赋默认值 6.调用构造方法<init> 1. 成员变量赋初始值 2. 执行构造方法语句 （super后行） 二、 对象在内存中的布局1. 查看虚拟机设置java -XX:+PrintCommandLineFlags -version -XX:+UseCompressedClassPointer 开启Class Pointer指针大小是否压缩， 默认是8字节 开启压缩之后变为4字节 -XX:+UseCompressedOops 这个是指援用类型指针大小是否压缩，这个默认也是8字节 开启压缩之后变为4字节 2. 一般对象 1. 对象头 markword 8字节 2. classPointer 压缩后4字节 不压缩8字节 classpointer指向class对象 new T() 的话 classpointer就是指向T.class 这个对象 3. 实例数据 byte:1字节 short:2 字节 char:2字节 int:4字节 float:4字节 double:8字节 long:8字节 如果是援用类型压缩后4字节 不压缩8字节 4. padding 对齐 ，对象大小总是为8的倍数个字节 如果不够就对齐 ...

一、 如何保障不乱序，也就是保障有序性1、 硬件内存屏障 留神：这是inter X86 1.1 sfence store fence 在sfence指令后面的写操作必须在sfence指令后边的写操作前实现 如图：如果没有sfence ,是不能保障操作1在操作2执行前就执行完的，有了sfence能力保障操作1和操作2的程序 1.2 lfenceload fence 指令前的读操作必须在lfence指令后边的读操作执行前执行 如图： 如果没有lfence 不能保障读操作1 和 读操作2 的程序 ，有了lfence就能够保障了 1.3 mfencemix fence 是汇合了sfence和lfence的所有作用于一身,mfence前边的读写操作必须在mfence后边读写操作开始之前实现 如图：mfence能够保障 在执行读操作2和写操作2之前 必须执行完读操作1和写操作1 1.4 其余除了fence外，还有一些原子指令 ，比方 lock xxx 这些原子指令是一个Full Barrier,执行时会锁住内存子系统来保障执行程序 甚至跨多个cpu 2.、JVM级别标准 留神：jvm这只是jvm的标准，具体实现要看虚拟机怎么实现 2.1 LoadLoad 屏障保障读操作的程序，LoadLoad前边的读操作必须在LoadLoad后边的读操作前实现 如图： LoadLoad能保障 读操作2和者读操作3执行前 必须执行完读操作0 和读操作1 2.2 StoreStore 屏障比照LoadLoad 保障写操作有序 2.3 LoadStroe 屏障比照LoadLoad 保障读操作和写操作有序 2.4 StoreLoad 屏障比照 LoadLoad 保障写操作和读操作有序 3、volatile 实现细节3.1 字节码层面这里用到jclasslib 前边文章讲过怎么装置 ...

上一篇说了类加载器、双亲委派机制、自定义类加载器 一、 问题ask1. 自定义类加载器的上一层也就是父类加载器是谁System.out.println(new MyClassLoader().getParent());输入后果：sun.misc.Launcher$AppClassLoader@18b4aac22. 我没有指定parent呀 为什么不是null呢咱们自定义类加载器继承了ClassLoader,new MyClassLoader()的时候会先走类加载器的结构 // 无参结构 调用了2个参数的结构 protected ClassLoader() { this(checkCreateClassLoader(), getSystemClassLoader());}// 这里指定了parent parent从哪儿来 看getSystemClassLoader()private ClassLoader(Void unused, ClassLoader parent) { // 指定parent this.parent = parent; // 其余操作 if (ParallelLoaders.isRegistered(this.getClass())) { parallelLockMap = new ConcurrentHashMap<>(); package2certs = new ConcurrentHashMap<>(); domains = Collections.synchronizedSet(new HashSet<ProtectionDomain>()); assertionLock = new Object(); } else { // no finer-grained lock; lock on the classloader instance parallelLockMap = null; package2certs = new Hashtable<>(); domains = new HashSet<>(); assertionLock = this; }}@CallerSensitivepublic static ClassLoader getSystemClassLoader() { // 返回的scl 看scl怎么初始化的 initSystemClassLoader(); if (scl == null) { return null; } SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkClassLoaderPermission(scl, Reflection.getCallerClass()); } return scl;} private static synchronized void initSystemClassLoader() { if (!sclSet) { if (scl != null) throw new IllegalStateException("recursive invocation"); sun.misc.Launcher l = sun.misc.Launcher.getLauncher(); if (l != null) { Throwable oops = null; // 获取classLoader scl = l.getClassLoader(); try { scl = AccessController.doPrivileged( new SystemClassLoaderAction(scl)); } catch (PrivilegedActionException pae) { oops = pae.getCause(); if (oops instanceof InvocationTargetException) { oops = oops.getCause(); } } if (oops != null) { if (oops instanceof Error) { throw (Error) oops; } else { // wrap the exception throw new Error(oops); } } } sclSet = true; }}// 间接返回了loader loader 是怎么来的 public ClassLoader getClassLoader() { return this.loader;}// Launcher类初始化的时候 构造方法里初始化了load 默认是appclassloaderthis.loader = Launcher.AppClassLoader.getAppClassLoader(var1); 3. 间接获取零碎类加载器ClassLoader.getSystemClassLoader(); -> appClassLoader4. 能够本人指定parent// 写一个有参的结构 传入一个你想认的爹 而后调用super 把parent传进去就行了public MyClassLoader(ClassLoader parent) { super(parent);}5. 突破双亲委派？ 看一眼 不了解没关系 我也不了解 从别的中央抄过来的重写LoadClass办法 因为双亲委派是在loadClass里边的逻辑指定的什么时候突破 ？ ...

C++规范库的map和set有什么区别，如何实现的？map和set都是C++的关联容器，其底层实现都是红黑树。map和set区别在于： map中的元素是key-value（键-值）对：关键字起到索引的作用，值则示意与索引相关联的数据；set是关键字的简略汇合，set中的元素都只蕴含一个关键字。set的迭代器是const的，不容许批改元素的值；map容许批改value，但不容许批改key。其起因是map和set是依据关键字排序来保障其有序性的，如果容许批改关键字的话，那么首先须要删除该键，而后调节树均衡，再插入批改后的键值，再从新调节树均衡。这样会毁坏map和set的构造，导致迭代器生效。map反对下标操作，set不反对下标操作。map底层为什么要用红黑树实现？红黑树的特点：红黑树是二叉查找树，但在每个节点减少一个存储为示意节点的色彩，能够是红色或彩色，通过对任意一条从根到叶子的门路上各个节点着色形式的限度，红黑树确保没有一条门路会比其余门路长两倍。因而，它是一种弱均衡二叉树，绝对于严格的均衡二叉（AVL）树来说，它的旋转次数少，所以对于查找、插入、删除较多的状况下，通常应用红黑树。AVL是严格均衡的，频繁的插入和删除，会引起频繁的再均衡，导致效率升高；红黑树是弱均衡的，算是一种折中，插入最多旋转2次，删除最多旋转3次。所以红黑树在查找、插入、删除的复杂度都是O(logn)，且性能稳固，所以STL外面很多构造包含map底层都是应用的红黑树。简述weak_ptr的作用weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为没有重载operator*和->，所以它不能像一般指针那样应用。weak_ptr最大作用在于帮助shared_ptr工作，像旁观者那样观测资源的应用状况。weak_ptr能够从一个shared_ptr或者另一个weak_ptr对象结构，取得资源的观测权。但weak_ptr没有共享资源，它的结构不会引起shared_ptr援用计数的减少。应用weak_ptr的成员函数use_count()能够观测资源的援用计数，另一个成员函数expired()的性能等价于use_count()==0，示意被观测的资源曾经不存在。weak_ptr也能够应用成员函数lock()从被观测的shared_ptr取得一个可用的shared_ptr对象， 从而操作资源。但当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr。简略来说就是： 观测shared_ptr资源应用状况。解除shared_ptr循环援用问题.C/C++的参数入栈程序为什么是从右向左？从右向左压栈的程序是与C/C++反对可变参数无关的。C/C++要求在申明参数可变的函数时，须要有至多一个确定的参数。为什么呢？因为须要有一个参数为函数提供可变参数的类型（否则函数怎么晓得如何解析后续的可变参数？比方，可变参数列表中有两个参数，一个int型，一个byte型，函数在解析可变参数表时，怎么晓得这5字节的数据到底应该如何去解析）如果一个可变参数的参数类型当时确定的话，这个参数就没有存在的意义了。如果参数入栈程序是从左向右压栈，第一个参数（即形容可变参数表各变量类型的那个参数）将被放在栈底，因为可变参的函数第一步就须要解析可变参数表的各参数类型，即第一步就须要失去上述参数，因而，将它放在栈底是很不不便的。当然，从左向右压栈的话也能够实现可变参的性能，然而这样的话，该性能实现起来会简单些。个别程序的虚拟内存空间为什么是4g？因为寻址空间取决于cpu地址线条数，如32位机，寻址空间为2^32 = 4G，所以最大只反对4G的寻址空间，即便插了8G的内存条也只能应用4G内存。Duilib为什么绘图性能不好？（答案仅供参考）Duilib是DirectUI思维的一种实现。DirectUI艰深来说就是在窗口上指定一块区域（仅仅是一个区域，不是一个实体控件）通过各种音讯模仿一个控件的性能。齐全能够在一个对话框类的OnMouseMove、OnLButtonDown等函数中模仿一个按钮进去。然而模仿的控件一多就凌乱了，为了对立治理，逻辑上更清晰相似于实体控件。把每种控件封装成类解决各种音讯，并通过自定义的音讯散发机制把音讯散发到各个模仿控件里。这种模仿的形式绘制和音讯解决效率相比于实体控件要低。Duilib的图片绘制代码中也有影响性能的中央，所有的控件的图片绘制都是调用CControlUI的DrawImage函数，而此函数调用了CRenderEngine的DrawImageString函数。在绘制图片时，DrawImageString会解析图片字符串的属性，而后找到对片的HBITMAP资源，最初调用真正的绘图函数去绘制。问题就在于每绘制一个图片都会再次解析一次字符串，当界面比较复杂，而且图片字符串也比较复杂时，这个解析的过程就影响了程序效率。当然这能够通过缓存图片资源解析后果的形式来优化。什么是内存泄露？如何查看内存泄露？内存透露是指在程序中动静申请的内存或者资源在应用完后，没有开释。这样可能导致程序应用的内存一直增大，最终会因零碎内存不足，而导致程序解体或其余谬误。在Windows下能够通过工作管理器查看内存应用状况，能够简略剖析是否有内存透露。也有很多像VLD这样的内存透露检测工具。如果是应用VC库来写程序的话，在Debug版本中也能够应用VC的C运行库中提供的像_CrtCheckMemory、_CrtCheckMemory、_CrtMemCheckpoint、_CrtMemDifference、_CrtMemDumpAllObjectsSince等函数来检测和定位内存透露问题。C++程序解体的个别起因是什么？怎么定位解体问题？程序解体个别有3个起因： 操作了野指针内存拜访谬误（包含格式化数据类型谬误、索引越界等）堆栈溢出在Windows下咱们个别会在编译程序时保留其pdb文件，设置解体时生成dump文件。因而，能够通过VS或者Windbg联合pdb文件来剖析解体产生的dump。大部分时候，通过Windbg的“!analyze -v”命令咱们就能定位到解体问题的代码行。如果解体的代码行不是理论引起问题的中央，咱们也能够通过相干代码的上下文联合log以及解体前操作等景象来剖析解体起因。最初，还能够通过dump查看解体时其余的堆栈或者线程信息，做进一步剖析。

前言所谓金三银四，想要跳槽进大厂的敌人们这段时间应该也都在踊跃筹备了，MySQL作为最风行的关系型数据库管理系统之一，其重要性想必不须要我多说，在面试中也简直是必问的，而且大一点的公司的话都会问得挺深。 那么当初筹备得差不多或者压根还没筹备然而又想进大厂的敌人，能够一起来看看我给大家整顿的这些对于MySQL的经典面试题，你是否都能答得进去呢？ PS:完整版面试题PDF以及MySQL学习笔记 1、MySQL 中有哪几种锁？1、表级锁：开销小，加锁快；不会呈现死锁；锁定粒度大，产生锁抵触的概率最高，并发度最低。 2、行级锁：开销大，加锁慢；会呈现死锁；锁定粒度最小，产生锁抵触的概率最低，并发度也最高。 3、页面锁：开销和加锁工夫界于表锁和行锁之间；会呈现死锁；锁定粒度界于表锁和行锁之间，并发度个别。 2、MySQL 中有哪些不同的表格？共有 5 种类型的表格： 1、MyISAM 2、Heap 3、Merge 4、INNODB 5、ISAM 3、简述在 MySQL 数据库中 MyISAM 和 InnoDB 的区别 MyISAM： 不反对事务，然而每次查问都是原子的； 反对表级锁，即每次操作是对整个表加锁； 存储表的总行数； 一个 MYISAM 表有三个文件：索引文件、表构造文件、数据文件； 采纳菲汇集索引，索引文件的数据域存储指向数据文件的指针。辅索引与主索引基本一致，然而辅索引不必保障唯一性。 InnoDb： 反对 ACID 的事务，反对事务的四种隔离级别； 反对行级锁及外键束缚：因而能够反对写并发； 不存储总行数： 一个 InnoDb 引擎存储在一个文件空间（共享表空间，表大小不受操作系统管制，一个表可能散布在多个文件里），也有可能为多个（设置为独立表空，表大小受操作系统文件大小限度，个别为 2G），受操作系统文件大小的限度； 主键索引采纳汇集索引（索引的数据域存储数据文件自身），辅索引的数据域存储主键的值； 因而从辅索引查找数据，须要先通过辅索引找到主键值，再拜访辅索引； 最好应用自增主键，避免插入数据时，为维持 B+树结构，文件的大调整。 4、MySQL 中 InnoDB 反对的四种事务隔离级别名称，以及逐级之间的区别？SQL 规范定义的四个隔离级别为： 1、read uncommited ：读到未提交数据 2、read committed：脏读，不可反复读 3、repeatable read：可重读 4、serializable ：串行事物 5、CHAR 和 VARCHAR 的区别？1、CHAR 和 VARCHAR 类型在存储和检索方面有所不同 2、CHAR 列长度固定为创立表时申明的长度，长度值范畴是 1 到 255 当 CHAR值被存储时，它们被用空格填充到特定长度，检索 CHAR 值时需删除尾随空格。 ...

背景写这篇文章次要是记录一下本人面试被问到的这个问题： 求二叉树每层最大值 到 结构一颗二叉树去验证 到进一步优化循环层数 的解答过程。(面试常见套路，手写->优化/其余解法/工夫空间复杂度剖析) 工夫一久就会遗记怎么写，下次又得想半天，而面试必定不会让现场想半天的，所以须要熟记思路。 这个题目源于我写的字节跳动实习的面经 https://segmentfault.com/a/1190000038543869，将解答过程写进面经外面会比拟长，所以独自抽出来总结一下。 1. 求二叉树每层的最大节点这个办法比拟常见，记得数据结构书中二叉树层序遍历的代码示例就是这个办法，leetcode的题解也多是两层循环。 ps：如果一开始就写出一层循环那当然不会有后续让优化的问题了。但举荐写这种，后续大多会被问到怎么用一层实现(我小米和字节都被问到了)。这时再装作想一想而后写进去岂不是更显得本人应变能力强，有算法根底而不是背进去的？ var largestValues = function(root) { if(!root) return [] const res = []    // 最终输入的后果，寄存每层的最大值 let queue = [root]     // 根节点入队 while(queue.length) { let len = queue.length let tmp = []   // 寄存以后层的所有节点的值 while(len) {   // 此处的len记录的是以后层的节点数，为0代表遍历完以后层的节点，开始遍历下一层 let curr = queue.shift() if(curr.left) queue.push(curr.left) if(curr.right) queue.push(curr.right) tmp.push(curr.val) len-- } res.push(Math.max(...tmp)) } return res}2. 结构一颗二叉树,用于验证咱们写的求每层最大值的函数// 二叉树的节点的构造方法 function TreeNode(val, left, right) { this.val = val this.left = null this.right = null } // 接下来咱们构建一颗第一层为1，第二层为2，3，第三层为4，5，6的二叉树 let p1 = new TreeNode(1) let p2 = new TreeNode(2) let p3 = new TreeNode(3) let p4 = new TreeNode(4) let p5 = new TreeNode(5) let p6 = new TreeNode(6) // 将这些节点相互连接起来 p1.left = p2 p1.right = p3 p2.left = p4 p2.right = p5 p3.left = p6 // 验证 console.log(largestValues(p1)); // 输入 [1, 3, 6]3. 循环层数优化：将刚刚写的求二叉树每层最大值的办法中的两层循环改为一层思路：在后面的办法中，咱们内层循环的作用是记录以后层的节点数,让咱们晓得什么时候本层节点遍历完。既然少了一层循环，那咱们就只能用额定空间去记录下一层节点了 ...

老规矩，先赞在珍藏，不做白嫖党。内存区域划分JVM的内存区域如何划分？并解释每个给区域的作用。 程序计数器（公有）：简略了解成行号。字节码解释器工作的时候就是通过程序计数器来寻取下一条字节码指令的。虚拟机栈（公有）：形容Java办法执行的内存模型，每个办法执行的时候都会创立一个栈帧，用于存储局部变量表、操作数栈、动静链接、办法进口等。虚拟机栈是形容办法的模型，所以为了不便记忆，想一下办法都有什么货色。 public int Hello(int x){ int a=1,b=1; # a b x 都放在局部变量表 int c=a+b; # + 操作栈 getHello(); # 被调用的指标办法在编译期无奈被确定下来， #只能从运行时常量池中将符号援用转换成间接援用，这个过程就是动静链接。 return c; # 这个返回就是办法的进口。 }本地办法栈（公有）：虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 办法的，而本地办法栈是为虚拟机调用 Native 办法服务的。堆（共享）：Java 虚拟机中内存最大的一块，是被所有线程共享的，简直所有的对象实例都在这里分配内存。办法区（共享）：用于存储已被虚拟机加载的类信息、常量、动态变量、即时编译后的代码（JIT生成的符号援用就是放在运行时常量池）等数据。JVM堆内存的外部如何划分？   堆分为年老代和老年代，年老代又分为Eden区和Survivor区, Survivor分为From 和To区域其中默认比例为 老年代：年老代=2:1；eden:from:to=8:1:1 办法区、永恒代、元空间区别是什么？  办法区是JVM内存标准，永恒代是这种标准的JVM实现。元空间则是在1.8之后取代了永恒代的一种实现。并且只有 HotSpot 才有 永恒代。 为什么用元空间替换成永恒代？  因为永恒带有MAX下限，容易遇到内存溢出问题。最典型的场景就是，在 jsp 页面比拟多的状况，容易呈现永恒代内存溢出。所以1.8之后应用元空间代替永恒代，元空间应用的是本地内存，只有本地内存足够大就能够解决oom问题。 深拷贝和浅拷贝的区别是什么？   浅拷贝：减少了一个指针指向已存在的内存地址  深拷贝：减少了一个指针并且申请了一个新的内存，使这个减少的指针指向这个新的内存 类加载机制一个Java类是如何运行起来的？  首先通过打包工具将java类编译成.class文件。而后JVM通过类加载器将.class文件加载到内存，最初JVM就会基于本人的字节码执行引擎，来执行加载到内存里的咱们写好的那些类了。 说说JVM类的加载过程  加载-链接-初始化  链接包含：验证->筹备->解析 能具体解释一下每一步都是做什么的？加载：将class文件加载到内存。验证：依据相干标准去验证你的.class文件是否合规。筹备：给对应的类、变量分配内存空间，赋初始值。解析：符号援用变为间接援用。（具体何为符号援用，上一篇内存换分中动静链接处有说。）初始化：真正执行类中定义的java程序代码。包含逻辑解决赋值等操作。 什么时候才会初始化一个类？执行须要援用类或者接口的java虚拟机指令（new,getstatic, putstatic, invokestatic）的时候调用类库中的某些反射办法的时候。初始化子类发现父类没初始化时候，会先初始化父类。蕴含“main()”办法的主类，是立马初始化的。 Java中类加载器有几种？启动类加载器Bootstrap ClassLoader：次要负载加载Java目录下的外围类的。在jdk装置目录下有一个lib目录，这下边的就是 java最外围的类库。启动类加载器就是加载这下边的类。扩大类加载器Extension ClassLoader：他和启动类加载器相似，只不过他加载lib/ext目录下的类。利用类加载器Application ClassLoader：次要是更具你的需要去加载你本人的类自定义类加载器：这个没啥说的，就是你自定义的类加载器。 为什么还须要自定义类加载器呢？ 大家晓得java代码很容易被反编译，如果你须要把本人的代码加密避免反编译，这个时候就用到了自定类加载器了。 说说什么是双亲委派加载机制？   打比方咱们Hello.class这个类，他在被加载到内存的时候就会先问他爸爸-扩大类加载器，而后扩大类加载器再问本人老爸-启动类加载器，而后启动类加载器就开始在lib下找Hello.class，没找到，通知扩大类加载器，你本人玩去，我这没有。扩大类一看老爸没有那我就本人来吧，找了半天他也没有，而后就通知利用类加载器说我和你爷爷帮不了你了，你还得靠本人去找。这个过程就是双亲委派。 双亲委派的作用是什么？安全性：避免外围类被篡改。比方你自定义一个java.lang.String类，他在加载的时候发现父类加载器曾经加载了，就不会在进行加载这个类。防止反复加载：父加载器曾经加载过的类，子加载器就不会再进行加载了，无效的避免了反复加载问题。 ...

给定一个整数数组和一个整数值k, 找出k个子数组(可能重叠), 它们具备k个最大和。 例子： Input : arr = {4, -8, 9, -4, 1, -8, -1, 6}, k = 4Output : 9 6 6 5Input : arr = {-2, -3, 4, -1, -2, 1, 5, -3}, k= 3Output : 7 6 5应用Kadane的算法咱们能够找到一个数组的最大间断子数组总和。然而在这种状况下Kadane的算法不起作用。正如咱们在数组中命中正数时一样, 将max_ending_here变量设置为零, 因而咱们错过了第二个最大值的可能性。 这是咱们提出的一种算法宋恩培和高冈忠雄计算最大子阵列和问题在O(n)工夫中, k个最大子数组和问题在O(k * n)工夫中。 首先, 咱们应用这种办法钻研仅最大子数组和的问题： 先决条件： 前缀和数组O(n)中应用前缀和的最大子数组和k个最大子数组的办法： 1. Calculate the prefix sum of the input array.2. Take cand, maxi and mini as arrays of size k. 3. Initialize mini[0] = 0 for the same reason as previous.4. for each value of the prefix_sum[i] do (i). update cand[j] value by prefix_sum[i] - mini[j] (ii). maxi will be the maximum k elements of maxi and cand (iii). if prefix_sum is less than all values of mini, then include it in mini and remove the maximum element from mini // After the ith iteration mini holds k minimum prefix sum upto // index i and maxi holds k maximum overlapping sub-array sums // upto index i.5. return maxi在整个计算方法中, 咱们将maxi放弃不变, 而mini则放弃不变。 ...

前言本文次要讲 三种常量池， 类文件中常量池，运行时常量池，字符串常量池  各自寄存的中央，以及对代码的影响 类文件中常量池（The Constant Pool）通过javac编译后的class文件 记录了这个类的所有信息，其中一个局部被成为常量池，外面寄存编译器生成的 字面量(Literal)和符号援用(Symbolic References) 字面量：1.文本字符串 2.8中根本类型的值 3.final 常量等 符号援用:1.类和接口的全限定名 2.字段的名称和形容 3.办法的名称和形容   运行时常量池 （The Run-Time Constant Pool）常量池是在 class文件中的，当该类被加载，常量池信息就会放入运行时常亮池，并把外面的符号援用改为真是地址，运行时常量池是在办法区(1.8之后追随办法区一起挪动到元空间), 能够在JVM运行期间动静向常量池写入数据 运行时常量的包装类8种根本数据类型都有本人的包装类，在包装类对象创立的瞎话就会耗费资源，因而  java 对 其中5种（Byte，Short，Integer，Long，Character，Boolean）包装类实现了常量池技术,默认创立了数值(-128 ,127)的相应类型的缓存数据，然而超出了此范畴仍然会去创立新的对象。两种浮点数类型的包装类 (Float,Double) 并没有实现常量池技术 咱们晓得,Integer是int的包装类,而包装类是对象,创建对象就须要耗费资源.java中的根本类型的包装类根本都实现了常量池技术. 代码演示: //只拿Integer 举例 Integer a = 10; //此处有一步装箱操作 Integer valueOf Integer b = 10; System.out.println(a == b);//实现了常量池技术，所以此处相等 Integer c = 200; Integer d = 200; System.out.println(c == d); Integer e = new Integer(10); System.out.println(a == e);// new 了新对象 与a 所在的常量池 地址不一样 Integer f = new Integer(10); f = f+0; // 关键在于此处进行了运算，固 f 在此处进行了主动拆箱操作，拆箱后 是int 数值 System.out.println(a == f);看下valueOf 源码，默认大小范畴内的值 被放入到了IntegerCache中，否则new 新对象 ...

为什么须要学MySQL？咱们每天都在拜访各种⽹站、APP，如微信、QQ、抖⾳、今⽇头条、腾讯新闻等，这些 货色上⾯都存在⼤量的信息，这些信息都须要有地⽅存储，存储在哪呢？数据库。 所以如果咱们须要开发⼀个⽹站、app，数据库咱们必须把握的技术，常⽤的数据库有 mysql、oracle、sqlserver、db2等。 上⾯介绍的⼏个数据库，oracle性能排名第⼀，服务也是相当到位的，然而免费也是⾮常 ⾼的，⾦融公司对数据库稳定性要求⽐较⾼，⼀般会抉择oracle。 mysql是收费的，其余⼏个⽬前临时免费的，mysql在互联⽹公司使⽤率也是排名第⼀， 材料也⾮常欠缺，社区也⾮常沉闷，所以咱们次要学习mysql。 篇幅所限，本文只详写了MySQL索引，须要的同学可自行支付完整版MySQL学习笔记 一、什么是索引？索引就好比字典的目录一样 咱们通常都会先去目录查找要害偏旁或者字母再去查找 要比间接翻查字典查问要快很多 二、为什么要有索引？然而咱们在应用mysql数据库的时候也像字典一样有索引的状况上来查问，必定速度要快很多 2.1问题： 1.mysql数据存储在什么中央?磁盘 2.查问数据慢，个别卡在哪？IO 3.去磁盘读取数据，是用多少读取多少吗？磁盘预读 局部性原理：数据和程序都有汇集成群的偏向，同时之前被拜访过的数据很可能再次被查问，空间局部性，工夫局部性 磁盘预读：内存和磁盘产生数据交互的时候，个别状况下有一个最小的逻辑单元，页。 页个别由操作系统感觉大小，4k或8k，而咱们在进行数据交互的时候，能够取页的整数倍来读取。 关注公众号：北游学Java 即可获取一份578页PDF文档的MySQL学习笔记 innodb存储引擎每次读取数据，读取16k 4.索引存储在哪？磁盘，查问数据的时候会优先将索引加载到内存中 5.索引在存储的时候，须要什么信息？须要存储存储什么字段值？key:理论数据行中存储的值 文件地址 offset：偏移量 6.这种格局的数据要应用什么样的数据结构来进行存储？key-values 哈希表，树(二叉树、红黑树、AVL树、B树、B+树) 7.mysql索引零碎中不是依照刚刚说的格局存储的，为什么？OLAP:联机剖析解决----对海量历史数据进行剖析，产生决策性的策略----数据仓库—Hive OLTP:联机事务处理----要求很短时效内返回对应的后果----数据库—关系型数据库(mysql、oracle) 三、mysql的索引数据结构3.1哈希表: HashMap数组加链表的构造，不适宜作为索引的起因： 1.哈希抵触会造成数据散列不平均，会产生大量的线性查问，比拟浪费时间 2.不反对范畴查问，当进行范畴查问的时候，必须挨个遍历 3.对于内存空间的要求比拟高 长处： 如果是等值查问，十分快 在mysql中有没有hash索引? 1.memory存储引擎应用的是hash索引 2.innodb反对自适应hash create table test(id int primary key,name varchar(30))engine='innodb/memory/myisam'-- 5.1之后默认innodb3.2树：树这种数据结构有很多，咱们常见的有： 二叉树、BST、AVL、红黑树、B树、B+树 ①二叉树：无序插入 这就是咱们的树的结构图，然而二叉树的数据插入是无序的，也就是说当须要查找的时候，还是得一个一个挨着去遍历查找 ②BST(二叉搜寻树)： 插入的数据有序，左子树必须小于根节点，右子树必须大于根节点--------应用二分查找来提高效率 这样的话如果要查问数据，能够通过二分查找，疾速放大范畴，缩小了工夫复杂度 **然而如果插入的程序是升序或者降序的话，树的形态会变成如下： 此时二叉搜寻树就会进化成链表，工夫复杂度又会变成O(n) ③AVL：均衡二叉树 为了解决上述问题，通过左旋转或右旋转让树均衡 最短子树跟最长子树高度只差不能超过1 由图咱们能够看到，当程序插入的时候，会主动的进行旋转，以达到均衡 然而会通过插入性能的损失来补救查问性能的晋升 当咱们插入的数据很多时候，而查问很少的时候，因为插入数据会旋转同样会耗费很多工夫 ④红黑树(解决了读写申请一样多) 同样是通过左右旋让树平衡起来，还要变色的行为 最长子树只有不超过最短子树的两倍即可 ...

我于11月底通过转介申请了为期6个月的实习。我认为如果你通过转介提出申请, 则只需1-2天即可从HR处取得回复, 然而2-3天后, 当没有人分割我时, 我认为我不会再收到他们的回音。然而两周后, 我收到了无关在线编码回合的邮件。 第一轮：在线编码有2个编码问题和28个MCQ。 中断到后缀的转换非常简单的字符串操作问题我可能解决两个问题。 两天后, 他们通知了我无关现场面试的信息, 我不得不去亚马逊班加罗尔办公室。 面试那天, 我去了办公室。还有大概70-80个学生。 第二轮：技术面试这是60分钟的工夫, 并询问了2个编码问题。我齐全解决了一部分问题。我的面试官很酷而且很友善。只管他没有笑很多, 但他让我感到咱们在探讨这个问题。他从常见的对于你问题开始, 而后间接跳到编码问题。 Q1。你在高空楼梯上, 必须要达到"第N个"楼梯。在任何楼梯上, 你最多只能执行" K"步。查找能够达到第N个楼梯的总数。 int countWays(int N, int K) 他向我解释了这个问题, 而后通过一个样本测试用例对其进行了解释。而后请我先解释一下这种办法, 如果他对这种办法感到称心, 那么只有我能力编写代码。他通知我, 他还将在笔记本电脑上记下来。 首先, 我给了他递归暴力解决方案(因为这就是CTCI所说的)。而后他让我优化它。而后, 我给了他工夫复杂度为O(N * K)和空间复杂度为O(N)的DP办法。而后他要求我进一步优化它。我应用了另一个变量来存储最初K个楼梯的总和, 并为第i个楼梯减少其值, 为第(i-k)个楼梯缩小其值。当初我的工夫复杂度为O(N), 空间复杂度为O(N)。我认为当初能够编码了, 然而他再次要求我优化空间。而后我给了他O(K)空间队列解决方案。当初他对这种办法感到称心, 并要求我对其进行编码。他再次向我解释了编写代码时的冀望。 (可读, 模块化, 缩进, 有意义的变量名)。而后我编写了代码, 他查看了一下并感到称心。 Q2。带有替换的最小字符串– https://leetcode.com/problems... 我很难提出强力解决方案, 我通知他。而后他给了我一些提醒, 在他的帮忙下, 我想出了一个强力解决方案。之后, 咱们进行了一些探讨, 即蛮力解决方案是否将始终提供正确的解决方案。在那之后, 他让我优化它, 我正在尝试, 然而他通知我工夫到了, 如果我有任何问题。我只是问过他实习生的角色以及哪个团队正在招聘实习生。 15分钟后, 他们通知我我要进行下一轮较量。 第二轮：技术面试同样是60分钟, 询问了3个编码问题。首先, 他请我做一个简短的介绍。而后他问我无关我的实习和我的项目的状况。而后他通知了我他对本轮较量的冀望。他通知我, 他会依据工夫询问2-3个问题, 我须要先向他解释逻辑, 而后再进行编码。另外, 请遵循良好的编码习惯。他通知我说, 我将不能笼罩编写代码, 并且他将在计算机上编写确切的代码(不确定他是否的确做到了, 然而他正在笔记本电脑上打字)。 ...

前言阿里提前批面了很多部门，除了淘系一面其余都过了，最终点了国际化中台的内推，在着急等hr面中，分享面经，心愿能帮到大家，都能拿到称心的offer~ 3.3阿里CBU一面我的项目30分钟（流程+我的项目难点+部署） JVM类加载过程 次要类加载器有什么 双亲委派模型的益处 双亲委派模型怎么突破 什么软件/利用突破了双亲委派模型 罕用设计模式介绍（代理模式、包装模式、工厂模式、适配器模式、责任链模式......） 包装模式在JDK中哪里利用了、责任链模式在哪里利用 工厂模式在Spring源码中哪里有利用 多线程在我的项目中的利用 定义线程池的办法 Callable和Runnable的区别 FutureTask介绍 BeanFactory和ApplicationContext区别 Bean的生命周期 Java中实现Map接口的有什么 遍历HashMap的几种办法 Java8中JVM运行时数据结构变动是什么（元空间取代了办法区） 为什么用元空间取代办法区 业界大数据新技术，比方Hadoop理解吗？ Java中的包装类有什么用（Integer Long Double），为什么须要包装类 TCP的粘包？粘包怎么解决？UDP会粘包吗？ TCP面向什么传输，UDP面向什么传输？ RPC理解吗？ 线程的申明周期？ 迪杰斯特拉最短门路算法？ 抉择排序是稳固的吗，工夫复杂度？ 快排稳固吗，工夫复杂度，什么时候性能最差？ MYSQL的索引为什么应用B+树的数据结构？ 前端Vue.js Ant Design理解吗？ Servlet是线程平安的吗？为什么线程不平安？ Linux的命令理解吗，Top命令是什么？ 实验室我的项目有人领导吗？ Redis怎么实现分布式锁 介绍Redis的缓存穿透和缓存雪崩 怎么解决缓存穿透和缓存雪崩 类加载外面Class类和Object类的加载程序 3.4蚂蚁金融外围一面我的项目25分钟 热点数据怎么解决 分布式事务 JVM运行时数据结构介绍 os的程序计数器和线程的程序计数器有什么区别 垃圾收集器CMS介绍 标记-整顿 的整顿阶段会STW吗 MYSQL数据库聚簇索引 非聚簇索引 索引笼罩 UUID作为主键对于索引写的影响 DB和缓存一致性怎么放弃（双写统一） 分布式数据库，怎么保障转账一致性 另外我这里为大家筹备了一线大厂面试材料和我原创的超硬核PDF技术文档，以及我为大家精心筹备的多套大厂面试题（不断更新中），心愿大家都能找到心仪的工作！如果有须要的敌人关注公众号：前程有光，回复材料自行下载！3.4阿里ICBU一面我的项目中Redis的利用 介绍Redis根本数据类型及利用场景 介绍Sping框架IOC和AOP 介绍redis缓存雪崩及解决方案 介绍MyBatis框架（dao接口没有实现类、xml解析过程、提早加载） 代码题：求给定字符串的最长不反复子串 代码题：给定String数组，求能拼接成的最大的数，以String类型返回 3.4阿里ICBU二面我的项目难点 Map类型及介绍（HahMap、Hashtable、CurrentHashMap、LinkedHashMap） HashMap线程不平安，环形链，CPU占用率过高 CPU占用率过高怎么排查 常见索引类型（唯一性索引、一般索引、联结索引） 索引笼罩 ...

几年前，SDE（软件开发工程师）求职的场景是这样的： 只有把简历贴到几个求职板块上，就能够坐等HR们被动致电分割你了；又或者，你只有广投简历给业内各大企业，就能够等着接踵而至地去加入面试了。现如今： 就算把本人的简历上传到七家求职网站、并且申请了100家看上去合乎本人资质的职位，也有十分大的可能性等不到音讯。有数据表明，海投简历的回复率大略在1%左右。 候选人：“我投出去的简历为什么没有胜利？为什么简历收回去就没有回音了？ 为什么我的简历退出JD中的要害技能，但还是没有面试机会？ IT公司都是怎么做简历筛选的？是否有规范？HR是怎么筛选简历的？ 你须要怎么写简历，能力取得面试？你可能从网上，敌人，老师那听过不少对于写简历的技巧。 要晓得为什么本人的简历没有胜利进入面试阶段，首先要明确以下几个问题： 你制作简历，是为了找份好的工作。而不是为了制作一份好简历，明确不？掂量简历是否优良的唯一标准——取得面试机会。如果你的简历无奈帮你取得面试机会 ，那么就算是你把身家性命交代的清清楚楚，也徒劳无益！简历筛选的实质是竞争。竞争不像你在答题考试，只有答案对了都有分!投了简历没有面试，只有两个起因：1、HR基本就没看到。2、招聘方看到了你的简历，然而看不上眼。招聘方看不上眼大部分起因是你的能力不合乎企业的要求，那么你的简历HR看不到是什么起因呢？ 起因在于，人力资源行业正在改革：往智能化、自动化、数据化的方向倒退。 大概90%的大型公司都在用ATS软件。因为ATS零碎的存在，HR很可能基本没有看到过你的申请或简历。她所看到的，可能只是经机器筛选后，被认为合乎特定职位要求的那些简历。 ATS全称Applicant Tracking System,是一种候选人跟踪软件，是公司用来治理招聘的工具。这个零碎其实是用来帮忙人力进行第一道过滤。那些没通过规范的简历，会被间接丢到回收站去。总之，ATS可能扫描并解析简历，而后把重要的信息提取进去，依据关键字对简历进行打分。最终，ATS会基于你的简历及你所申请的职位给出一个百分制的分数。 据数据显示，ATS依据企业的招聘需要初步筛选掉75%的简历。而后HR在剩下的25%的简历里，再次筛选淘汰后，举荐给招聘经理。招聘经理进行第三次筛选，依据简历品质安顿面试。 HR：“收到的简历为什么不是很匹配？”有至多75%的简历会被筛掉，这对于HR来说，其实也是一种无奈之举。 为什么说是一种无奈之举呢？ 企业采纳ATS的首要目标，就是通过零碎工具来刷掉不靠谱的垃圾简历，进步HR的筛选效率。然而零碎毕竟是一个凉飕飕的程序，它不会去做思考，只会依照原先预设的规范去做筛选。 ATS的这种逻辑算法的长处是能刷掉不靠谱的垃圾简历，但也有弊病（bug）。 例如：对领有雷同技能的简历，如何进行排名呢？蕴含很多关键字并不示意简历的品质。 案例一：企业A在某次春招流动中收到20份对于Java工程师的简历，其中简历都蕴含了雷同关键字技能。你能说呈现10次Java关键字的程序员简历就比呈现2次的简历优良吗？很显著，你不能。因为呈现10次Java关键词的程序员在短短四年内换了10次工作。而且在工作岗位须要组合简单技能时，这类通过扫描关键字的算法就不太无效。 案例二： 简历A：项目经理，治理过3个大型Java开发我的项目，跟踪开发进度，治理程序员团队。简历B：软件工程师，从事大型Java我的项目开发，与项目经理沟通开发进度。如果你要找Java程序员，基于关键字匹配算法，简历A如同更匹配。因为呈现了Java，开发，程序员等相干关键字。然而依据文字的语意，很显著简历B才是Java程序员的简历。那么如何防止这样的事件产生，即保障企业无效的筛选不合格简历，也不错过适合的人才呢？ 对于企业来说，最怕的就是招错人，不仅对于应聘者和企业来说是工夫、精力的损失，最重大的问题是，因为招错人，企业错过了风口，错过了机会。 企业和候选人如何高效匹配？与ATS通过简历关键词、限定条件来筛选候选人不同的是，ShowMeBug 在线口试是通过代码测验人才，用考查真正代码实力的口试题来做技术评估，后果更牢靠。这样也能将人才筛选规范合理化。 企业端：企业能够通过 ShowMeBug 的在线口试来解决这一问题，企业首先通过 ShowMeBug 凋谢的接口与公司的ATS进行对接。零碎在收到候选人的简历时，HR依据应聘岗位制订口试试题，并通过相干联系方式把试题链接发送给候选人进行作答。零碎在候选人提交答卷后零碎实现一键主动评卷（无需技术面试官干涉，HR也能轻松搞定），并输入相干口试报告和评分。HR依据候选人口试问题与技术面试官确认后再确定是否安顿面试。其中技术面试官还能够通过字节级回放技术来回顾整个候选人的作答过程，确保不错过任何细节。 候选人端：能够随时随地在本人相熟的环境下发展口试答题，期间无其余人员进行烦扰ShowMeBug 采纳在线实时协同的编程IDE，LSP云端服务提供的代码补全和Emacs/Vim快捷键。让候选人编程像在本地一样天然。 前一阵子，硅谷“钢铁侠”马斯克在为特斯拉招募人工智能团队成员时，示意：即便你没有大学学位，也不会阻止你为特斯拉工作。马斯克招人不在乎学历，但有一点是不能退让的：所有候选人必须通过外围编码测试。其实这就是精准招聘技术人员的外围：编码测试。这也是 ShowMeBug 推崇的“优良的技术人员就应该把工夫花在技术打磨上，让每一个优良企业通过 ShowMeBug 发现他们”。 ShowMeBug 两大性能：在线面试和在线口试，都是为了让企业可能在线上高效疾速地对候选人的技术实力进行评估。ShowMeBug 的外围底层是优良的在线IDE，直观弱小的多人在线代码交换环境， 0% 代码抵触率，提早 50ms 以下，同时反对在线运行代码。 这不仅能让技术面试官用起来不便，让候选人在面试过程中编程也像在本地一样天然，再也不必放心候选人不喜爱代码面试和在线口试了。 开箱即用：https://www.showmebug.com/

写在后面又到了一年一度的金三银四跳槽黄金季，很多小伙伴都在蠢蠢欲动，向跳槽到本人心仪的大厂，然而，进大厂不是那么容易的。为了帮忙小伙伴们可能顺利的通过面试，冰河特整顿了这部收费开源的面试圣经——《我要进大厂系列之面试圣经（第1版）》，心愿这部电子书可能为你带来实质性的帮忙。如果你能从这部电子书中学到常识，请关注【冰河技术】微信公众号，第一工夫浏览技术干货，咱们一起进阶，一起牛逼！ 进大厂的外围技能咱们先来看看进大厂须要哪些外围技能，以便小伙伴们有针对性的进行筹备。 一.常见模式与工具学习Java技术体系，设计模式，风行的框架与组件—— 常见的设计模式，编码必备， Spring5，做利用必不可少的最新框架，MyBatis，玩数据库必不可少的组件...... 二.工程化与工具工欲善其事必先利其器，不论是小白，还是资深开发，玩Java技术体系，抉择好的工具，晋升开发效率和团队合作效率，是必不可少的： 三.分布式架构高并发，高可用，海量数据，没有分布式的架构常识必定是玩不转的： 四.微服务架构业务越来越简单，服务分层，微服务架构是架构降级的必由之路，Java技术体系，和微服务相干的技术有哪些呢？ 五.性能优化任何脱离细节的ppt架构师都是耍流氓，向上能指挥若定，向下能解决一线性能问题，Java技术体系，须要理解： 六.底层常识从架构设计，到应用层调优，再深刻理解底层原理，扎实的Java基本功能力让本人变为扫地神僧： 七.我的项目实战无需赘述，如果没有实战经验，如何成为一名架构师？ 如何支付PDF说了这么多，这里才是重点，如何支付《我要进大厂系列之面试圣经（第1版）》这部电子书呢？其实很简略。 关注【冰河技术】微信公众号，回复【我要进大厂】即可获取下载链接地址。 最初，祝各位小伙伴可能早日进入本人心仪的大厂。 好了，明天就到这儿吧，我是冰河，大家有啥问题能够在下方留言，也能够加我微信：sun_shine_lyz，我拉你进群，一起交换技术，一起进阶，一起牛逼~~

前言所谓金三银四，想要跳槽进大厂的敌人们这段时间应该也都在踊跃筹备了，MySQL作为最风行的关系型数据库管理系统之一，其重要性想必不须要我多说，在面试中也简直是必问的，而且不出预料的话都会问得挺深。那么当初筹备得差不多或者压根还没筹备然而又想进大厂的敌人，能够一起来看看我给大家整顿的这些对于MySQL的经典面试题，你是否都能答得进去呢？ MySQL 1、MySQL 中有哪几种锁？1、表级锁：开销小，加锁快；不会呈现死锁；锁定粒度大，产生锁抵触的概率最高，并发度最低。 2、行级锁：开销大，加锁慢；会呈现死锁；锁定粒度最小，产生锁抵触的概率最低，并发度也最高。 3、页面锁：开销和加锁工夫界于表锁和行锁之间；会呈现死锁；锁定粒度界于表锁和行锁之间，并发度个别。 2、MySQL 中有哪些不同的表格？共有 5 种类型的表格： 1、MyISAM 2、Heap 3、Merge 4、INNODB 5、ISAM 3、简述在 MySQL 数据库中 MyISAM 和 InnoDB 的区别 表格比照 MyISAM： 不反对事务，然而每次查问都是原子的； 反对表级锁，即每次操作是对整个表加锁； 存储表的总行数； 一个 MYISAM 表有三个文件：索引文件、表构造文件、数据文件； 采纳菲汇集索引，索引文件的数据域存储指向数据文件的指针。辅索引与主索引基本一致，然而辅索引不必保障唯一性。 InnoDb： 反对 ACID 的事务，反对事务的四种隔离级别； 反对行级锁及外键束缚：因而能够反对写并发； 不存储总行数： 一个 InnoDb 引擎存储在一个文件空间（共享表空间，表大小不受操作系统管制，一个表可能散布在多个文件里），也有可能为多个（设置为独立表空，表大小受操作系统文件大小限度，个别为 2G），受操作系统文件大小的限度； 主键索引采纳汇集索引（索引的数据域存储数据文件自身），辅索引的数据域存储主键的值； 因而从辅索引查找数据，须要先通过辅索引找到主键值，再拜访辅索引； 最好应用自增主键，避免插入数据时，为维持 B+树结构，文件的大调整。 4、MySQL 中 InnoDB 反对的四种事务隔离级别名称，以及逐级之间的区别？SQL 规范定义的四个隔离级别为： 1、read uncommited ：读到未提交数据 2、read committed：脏读，不可反复读 3、repeatable read：可重读 4、serializable ：串行事物 5、CHAR 和 VARCHAR 的区别？1、CHAR 和 VARCHAR 类型在存储和检索方面有所不同 2、CHAR 列长度固定为创立表时申明的长度，长度值范畴是 1 到 255 当 CHAR值被存储时，它们被用空格填充到特定长度，检索 CHAR 值时需删除尾随空格。 ...

Aaron 是一家互联网公司的高级研发工程师，正在目不转睛的写着代码，“到底用代理模式还是装璜器模式？”，刚思考到紧要处，HR Amy 跑过来，“Aaron，快点，有一个面试，我看简历挺优良，你去面一下吧”。Aaron 十分不开心，就要找到解决方案的时候却被打断了，任谁也不会开心，却又无奈去筹备面试。 到了会议室，与候选人聊了几句，就发现这个人怎么这么水？简历上明明写着的精通 JAVA，却连根本的 StringBuilder 都不理解。Aaron 接着又问了几个根底问题，不到5分钟，就把候选人打发回去了。Aaron 嘀咕到：“这么水的人让我面试，真是浪费时间”。回到座位上后，小明从新梳理问题终于在临上班前才找到原来的思路，“嗯，又是一个加班的夜晚”，Aaron 坐在座位上嘀咕道。 这个场景是不是每天都产生在咱们身边，作为技术负责人的你，是否发现其中存在着大量的但又荫蔽的节约： HR筛选的简历往往有一半以上是只有面试5分钟就会被刷掉的技术面试官的工夫老本很高，轻易打断他们的工作过程会造成微小的节约面试官往往对面试过程筹备有余，问题没有针对性，这时候，极易招错人或漏掉适合人才一旦解决以上问题，技术团队的面试效率能够失去大大提高，同时招人品质也会回升，更优良的人才退出，技术团队能够运行的更高效。 解决方案李亚飞是一位十年研发教训的资深工程师，同时是一名技术型间断创业者，屡次的联结创始人&CTO的工作经验，多年技术面试的经验让他深深领会到上述问题对技术团队造成的微小节约。为了解决这个问题，李亚飞在2019年率领团队专门打造了一个「可记录、可剖析、可复盘的技术评估神器」——ShowMeBug。 ShowMeBug 是一款数字化驱动的交互式代码交换的技术面试工具，让用户体验硅谷风行的像真正工作中一样的代码面试，通过在线口试场景和在线面试场景两大法宝让企业结构化、规模化、自动化、智能化的进行技术招聘从而节约大量的面试工夫。 那么，ShowMeBug 如何帮忙技术面试官来解决上述问题呢？ 简历不准首先，针对HR给的简历不准的问题，咱们能够引入 ShowMeBug 的在线口试功来解决。通过一套在线口试题来初步考查候选人的技术实力，口试通过之后再进行面试。 在线口试能帮忙企业用最小老本地初步筛选出人才，不必面试官在线盯着，不必候选人来公司，同时纸张和会议室也省了，一个链接全搞定。 同时，HR在筛选简历的时候放宽学历和工作年限的要求，用考查真正代码实力的口试题来做技术评估，后果更牢靠。 而且，ShowMeBug 有私有题库能够抉择，你也能够抉择团队成员创立团队私有化题库。 一提到在线口试，很多人最关怀的就是防舞弊问题。目前市面上的在线口试工具，如金数据、腾讯问卷等都没有防舞弊性能，针对该问题 ShowMeBug 给出正当的解决方案： 启用摄像头摄录，确保候选人在线记录切屏次数和代码复制等操作，并输入报告和评分笔面试一体化，面试官可针对口试过程中的代码逻辑和候选人进行回顾沟通此外，在线口试的选择题和带测试用例的编程题，支持系统一键评卷，不须要技术参加，HR也能自主评卷。 为了面试，工作被打断口试之后，再来面试。传统的线下面试，非常容易打断工程师的日常工作，对于企业来说是一笔巨大损失。如果用微信、腾讯会议、zoom等软件或者电话来做近程在线面试，又没法深刻交换。 ShowMeBug 在线面试场景中提供一个可运行代码的靠近实在工作场景的编程环境，面试过程中单方面板实时同步，沟通起来无障碍。再加上音视频沟通、在线代码运行和共享屏幕，满足多个场景的沟通需要。 企业面试过程中可能因为面试官工夫抵触或者长期有重要事件解决，导致须要对候选人就同一个问题进行屡次阐明（多轮面试）。 ShowMeBug 的在线面试会全过程记录，预先面试官能够分明回顾每个候选人的面试状况，进行面试复盘并打分。而后比照各个候选人的面试状况，做出最合适的抉择。 所以 ShowMeBug 在线面试性能，既能够防止平时工作被打搅，灵便安顿面试工夫；又能够深刻沟通编程问题；同时还具备字节级回放技术，真正做到面试有记录，后果可溯源。 怕招错人对于企业来说，最怕的就是招错人，不仅对于应聘者和企业来说是工夫、精力的损失，最重大的问题是，因为招错人，企业错过了风口，错过了机会。 那么如何精准辨认你想要的人呢？ 前一阵子，硅谷“钢铁侠”马斯克在为特斯拉招募人工智能团队成员时，示意：即便你没有大学学位，也不会阻止你为特斯拉工作。马斯克招人不在乎学历，但有一点是不能退让的：所有候选人必须通过外围编码测试。 其实这就是精准招聘技术人员的外围：编码测试。 ShowMeBug 两大性能：在线面试和在线口试，都是为了让企业可能在线上高效疾速地对候选人的技术实力进行评估。ShowMeBug 的外围底层是优良的在线IDE，直观弱小的多人在线代码交换环境， 0% 代码抵触率，提早 50ms 以下，同时反对在线运行代码。 这不仅能让技术面试官用起来不便，让候选人在面试过程中编程也像在本地一样天然，再也不必放心候选人不喜爱代码面试和在线口试了。 将来「ShowMeBug」上线于2019年8月，致力于提供新型技术面试平台和技术人才评估零碎，为企业和技术人才双端解决招聘痛点。迄今为止，「ShowMeBug」帮忙6000+企业实现了150000+场笔面试，也实现了奇绩创坛、盈动资本、变量资本和真格基金的投资。 为了更好地帮企业招聘技术人才，咱们接下来马上要上线口试题库、架构绘图性能，当前你能够不必出题，通过公共题库筛选候选人；能够采纳架构绘图，来与资深技术牛人交换思维。 春招福利为了企业能在此次春招中，招揽更多优良的技术牛人，确保在将来企业倒退中有足够的人才储备，ShowMeBug 特地推出秋季招聘大礼包微信号：showmebug咨询电话：18529073187 增加微信后回复春招，支付专属福利。 ShowMeBug 祝你人才济济，良将如云！ 开箱即用：https://www.showmebug.com/

前言本文将从以下几方面论述 Javascript 中 this 的指向问题。 规范函数中，this的援用值是什么箭头函数中，this的援用值是什么应用new关键字创建对象时，this的援用值是什么闭包中应用this时，this的援用值什么规范函数中，this 的援用值是什么规范函数中，this援用的是把函数当成办法调用的上下文对象在规范函数中this的值是会依据办法被调用的状况扭转所援用的值 window.identity = "The Window"let object = { identity: 'My Object', getIdentityFunc() { console.log(this.identity) }}object.getIdentityFunc() // My Objectconst getIdentityFunc = object.getIdentityFuncgetIdentityFunc() // The Window箭头函数中，this 的援用值是什么在箭头函数中，this援用的是定义箭头函数的上下文由此能够看出箭头函数中的this援用值是固定的 window.identity = "The Window"let object = { identity: 'My Object', testIdentity: this.identity, getIdentityFunc:() => { console.log(this.identity) }}console.log(object.testIdentity) // The Windowobject.getIdentityFunc() // The Window面试的时候我就遇到了这个问题，过后我心想 “在箭头函数中，this援用的是定义箭头函数的上下文对象”大家如果认真比拟这两句话能够发现我心里想的多了两个字(或者说我就是囫囵的看了一遍书，基本没有好好的去了解、去验证)，这两个字不多不少让我把this的援用值认为成object这个对象了，所以我认为最初的后果应该是My Object。 那么咱们当初来具体的看看这个定义箭头函数的上下文是什么呢？在我看来，咱们能够把this值看成上下文 那定义箭头函数的上下文其实就是object的this值呗；那咱们要晓得的其实就是object的this的identity属性是什么呗? 在上方代码的倒数第二行就是为了阐明这个问题，因为属性testIdentity的值是The Window咱们能得出object的this援用值其实是window； 因为函数getIdentityFunc中的this援用值其实是object的this，也就是window。所以函数getIdentityFunc中的this.identity是The Window。 既然箭头函数中的 this 是固定的，那么相似 call 的函数能扭转 this 的援用值吗在JS中咱们能够应用call、apply、bind办法扭转this指向，既然箭头函数的this值援用值是固定的，那咱们能应用这几个办法扭转这个援用值吗? ...

写在后面Javascript异步编程先后经验了四个阶段，别离是Callback阶段，Promise阶段，Generator阶段和Async/Await阶段。Callback很快就被发现存在回调天堂和控制权问题，Promise就是在这个工夫呈现，用以解决这些问题，Promise并非一个新事务，而是依照一个标准实现的类，这个标准有很多，如 Promise/A，Promise/B，Promise/D 以及 Promise/A 的升级版 Promise/A+，最终 ES6 中采纳了 Promise/A+ 标准。起初呈现的Generator函数以及Async函数也是以Promise为根底的进一步封装，可见Promise在异步编程中的重要性。 对于Promise的材料曾经很多，但每个人了解都不一样，不同的思路也会有不一样的播种。这篇文章会着重写一下Promise的实现以及笔者在日常应用过程中的一些心得体会。 实现Promise标准解读Promise/A+标准次要分为术语、要求和注意事项三个局部，咱们重点看一下第二局部也就是要求局部，以笔者的了解大略阐明一下，具体细节参照完整版Promise/A+规范。 1、Promise有三种状态pending，fulfilled和rejected。（为了一致性，此文章称fulfilled状态为resolved状态） 状态转换只能是pending到resolved或者pending到rejected；状态一旦转换实现，不能再次转换。2、Promise领有一个then办法，用以解决resolved或rejected状态下的值。 then办法接管两个参数onFulfilled和onRejected，这两个参数变量类型是函数，如果不是函数将会被疏忽，并且这两个参数都是可选的。then办法必须返回一个新的promise，记作promise2，这也就保障了then办法能够在同一个promise上屡次调用。（ps：标准只要求返回promise，并没有明确要求返回一个新的promise，这里为了跟ES6实现保持一致，咱们也返回一个新promise）onResolved/onRejected有返回值则把返回值定义为x，并执行[[Resolve]](promise2, x);onResolved/onRejected运行出错，则把promise2设置为rejected状态；onResolved/onRejected不是函数，则须要把promise1的状态传递上来。3、不同的promise实现能够的交互。 标准中称这一步操作为promise解决过程，函数标示为[[Resolve]](promise, x)，promise为要返回的新promise对象，x为onResolved/onRejected的返回值。如果x有then办法且看上去像一个promise，咱们就把x当成一个promise的对象，即thenable对象，这种状况下尝试让promise接管x的状态。如果x不是thenable对象，就用x的值来执行 promise。[[Resolve]](promise, x)函数具体运行规定： 如果 promise 和 x 指向同一对象，以 TypeError 为据因拒绝执行 promise;如果 x 为 Promise ，则使 promise 承受 x 的状态;如果 x 为对象或者函数，取x.then的值，如果取值时呈现谬误，则让promise进入rejected状态，如果then不是函数，阐明x不是thenable对象，间接以x的值resolve，如果then存在并且为函数，则把x作为then函数的作用域this调用，then办法接管两个参数，resolvePromise和rejectPromise，如果resolvePromise被执行，则以resolvePromise的参数value作为x持续调用[[Resolve]](promise, value)，直到x不是对象或者函数，如果rejectPromise被执行则让promise进入rejected状态；如果 x 不是对象或者函数，间接就用x的值来执行promise。代码实现标准解读第1条，代码实现： class Promise { // 定义Promise状态，初始值为pending status = 'pending'; // 状态转换时携带的值，因为在then办法中须要解决Promise胜利或失败时的值，所以须要一个全局变量存储这个值 data = ''; // Promise构造函数，传入参数为一个可执行的函数 constructor(executor) { // resolve函数负责把状态转换为resolved function resolve(value) { this.status = 'resolved'; this.data = value; } // reject函数负责把状态转换为rejected function reject(reason) { this.status = 'rejected'; this.data = reason; } // 间接执行executor函数，参数为处理函数resolve, reject。因为executor执行过程有可能会出错，谬误状况须要执行reject try { executor(resolve, reject); } catch(e) { reject(e) } }}标准解读第2条，代码实现： ...

什么是springbootSpring Boot 是 Spring 开源组织下的子项目，是 Spring 组件一站式解决方案，次要是简化了应用 Spring 的难度，简省了沉重的配置，提供了各种启动器，开发者能疾速上手。Spring Boot 并不是对 Spring 性能上的加强，而是提供了一种疾速应用 Spring 的形式。 springboot性能主动配置：springboot的主动配置是一个运行时（更精确的说是应用程序启动时）的过程，springboot主动实现Spring配置应该用哪个，不该用哪个。起步依赖：定义了对其余库的依赖传递，不会存在版本抵触问题辅助性能：提供了一些大型项目中常见的非功能性个性，如嵌入式服务器、平安、指标，衰弱检测、内部配置等。springboot的外围注解是哪个？它次要由哪几个注解组成的？启动类上的注解@SpringBootApplication，是外围注解，次要蕴含了以下3个注解：@SpringBootConfiguration：蕴含了@Configuration，实现配置文件的性能；@EnableAutoConfiguration：关上主动配置的性能；@ComponentScan：Spring组件扫描SpringBoot须要独立的容器运行吗？能够不须要，内置了Tomcat/Jetty等容器，默认Tomcat 运行SpringBoot有哪几种形式？打包用命令或放到容器中运行间接执行main办法运行用Maven插件运行Spring Boot 主动配置原理是什么？在springboot的启动类中应用了注解@SpringBootApplication注解，外面的@EnableAutoConfiguration注解是主动配置的外围，注解外部应用@Import(AutoConfigurationImportSelector.class)（class文件用来哪些加载配置类）注解来加载配置类，并不是所有的bean都会被加载，在配置类或bean中应用@Condition来加载满足条件的bean。@EnableAutoConfiguration 给容器导入META-INF/spring.factories 里定义的主动配置类，筛选无效的主动配置类。每一个主动配置类联合对应的 xxxProperties.java 读取配置文件进行主动配置性能SpringBoot主动配置-ConditionCondition是Spring4.0后引入的条件化配置接口，通过实现Condition接口能够实现有条件的加载相应的Bean@Conditional要配和Condition的实现类（ClassCondition）进行应用SpringBoot 提供的罕用条件注解：ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化BeanConditionalOnClass：判断环境中是否有对应字节码文件才初始化BeanConditionalOnMissingBean：判断环境中没有对应Bean才初始化BeanSpring Boot 能够兼容老 Spring 我的项目吗，如何做？能够，应用@ImportResource注解导入老Spring我的项目配置文件。在启动类上应用。SpringBoot配置-profileprofile是用来实现不同环境下，配置动静切换性能的profile配置形式多profile文件形式：提供多个配置文件，每个代表一种环境。application-dev.properties/yml 开发环境application-test.properties/yml 测试环境application-pro.properties/yml 生产环境 profile激活形式配置文件：spring.profiles.active=dev springboot监控 actuatorspring boot actuator 是 spring启动框架中的重要性能之一。spring boot自带监控性能，能够帮忙实现对程序外部运行状况监控，比方监控状态、Bean加载状况、配置属性、日志信息等。最初在文章的最初作者为大家整顿了很多材料！包含java外围知识点+全套架构师学习材料和视频+一线大厂面试宝典+面试简历模板+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书等等！欢送关注公众号：前程有光，支付！

举荐浏览地址掘金前言：大家好，我是林一一，这是一篇对于 this 指向的文章。this 是 JS 中一个特地重要的一个知识点，this 难吗？如同挺简略的。看完上面这一篇文章，还不会的话，你别来找我。手动狗头。思维导图 this 的指向执行函数前有 '.' 点操作符的话，函数体中的 this 就指向后面的对象，没有就指向 window，严格模式下指向 undefined。这句话特地的重要，请记住函数没有间接调用者 this 指向全局对象(浏览器中是window，node中是 global)。如匿名函数等构造函数的 this 指向实例自身。箭头函数自身没有this的，箭头函数的 this 指向最近的非箭头函数 this，找不到就指向 window，严格模式下指向 undefined。再来看一下这句话：执行函数前有 '.' 点操作符的话，函数体中的 this 就指向后面的对象，没有就指向 window一、一般函数 this 的热身题热身题 1var name = '林一一'function fn(){ var name = '林二二' return this.name}fn() // 林一一执行函数 fn()，后面没有 '.' 点操作符吧，那么这里的 this 就指向 window。输入的就是全局下的 name = '林一一'。再来看一下这句话：执行函数前有 '.' 点操作符的话，函数体中的 this 就指向后面的对象，没有就指向 window 热身题 2var name = '林二二'var obj = { name: '林一一', fn: function () { return this.name }}console.log(obj.fn()) // '林一一'var fo = obj.fnconsole.log(fo()) // '林二二' fo() ==> window.fo()obj.fn() 中函数 fn() 后面有 '.' 点操作符吧，那么这里的 this 就指向 obj 这个对象。再看执行函数 fo()，后面没有 '.' 点操作符吧，那么这里的 this 就指向 window。其实下面的函数 fo() ==> window.fo()，所以执行函数 fo() 后面也是能够看作是有 '.' 操作符的。再来看一下这句话：执行函数前有 '.' 点操作符的话，函数体中的 this 就指向后面的对象，没有就指向 window ...

我是在美国 TOP10 大学读的本科和研究生，CS业余。读研的时候幸运地意识了 Justin 导师，上了简历课，研究生毕业后顺利进了亚麻。 历时 2个多月的刷题和有数拒信后，我终于上岸了。都说当初 BQ 越来越重要了，夸大一点说，BQ 是王道。技术面试局部的一些瑕疵或者有余，能够被准备充分的 BQ 答复补救。 谷歌也从 20年开始改革面试，强制要求常加面一轮 BQ，可见大厂越来越看重 BQ 了，不过各位同学不要慌，看重 BQ 也意味着 BQ 将成为面试利器，此前就有人靠 BQ 胜利上岸。 在 Justin 老师的职业咨询课程中，我学到了如何扣题答复，从更深层次理解出题人的考查用意。 BQ 虽是开放性问题，但都有套路可循，明天就与大家分享一些对于BQ的教训吧。 我碰到两次面试，有一轮就是只问 BQ，间断 40分钟 BQ 快问快答，人都要疯掉了，说得口干舌燥。这里写一些常见的 BQ 吧，根本属于必考。 1、介绍一个你最喜爱的我的项目？介绍下简历？介绍下本人？ BQ 翻译：有没有看职位要求？说说职位要求要找什么人？你是这样的人么？介绍一个你最合乎这个职位要求的我的项目，最初强调你是 good fit。这才是答复这样一个 BQ 问题的 good solution 2、你最大的毛病/失败？ BQ 翻译：你一个无伤大雅的小毛病/失败是什么？你从以前的哪个我的项目晓得本人有这个毛病/失败？晓得当前学到了什么教训？在前面哪个我的项目中汲取了这个教训，做了什么，获得了什么后果？ 3、你最大的长处？ BQ 翻译：我晓得你很牛，你哪个特质最合乎这个职位的要求，并且在最初强调你的某某长处让你是一个 good fit for this position。 4、为什么选咱们公司？ BQ 翻译：公司的 mission 是什么？我的 career goal 和你们公司的 mission 完满符合；职位的要求是什么？我的背景和能力和这个职位的要求完满符合。最初强调你是 good fit。总之，面对这样一个 BQ 问题不要慌了阵脚，如实叙述即可。 ...

在 JavaScript 中，this 是函数调用上下文。正是因为 this 的行为很简单，所以在 JavaScript 面试中，总是会问到无关 this 的问题。 做好的筹备面试的办法是练习，所以本文针对 this 关键字整顿了 7 个乏味的面试。 留神：上面的 JavaScript 代码段以非严格模式运行。 1：变量与属性以下代码输入什么： const object = { message: 'Hello, World!', getMessage() { const message = 'Hello, Earth!'; return this.message; }};console.log(object.getMessage()); // => ?答案：输入： 'Hello, World!' object.getMessage() 是办法调用，这就是为什么办法中的 this 等于 object 的起因。 办法中还有一个变量申明 const message ='Hello，Earth!'，该变量不会影响 this.message 的值。 2：猫的名字以下代码输入什么： function Pet(name) { this.name = name; this.getName = () => this.name;}const cat = new Pet('Fluffy');console.log(cat.getName()); // => ?const { getName } = cat;console.log(getName()); // =>?答案：输入：'Fluffy' 和 'Fluffy' ...

前言本文次要比拟Vue2.0与Vue3.0双向绑定的原理，以及由二者不同的原理造成的一些差别，并对该差别产生的起因进行简略的剖析。 Vue2.0双向绑定的次要实现原理是Object.defineProperty()办法Vue3.0双向绑定的次要实现原理是ES6新增的Proxy()对象所以本文论述的双向绑定的原理的区别简略来说就是上述两种办法对于劫持对象属性的不同。然而为了具体说分明不同原理造成的差别，咱们必须从源码说起。Vue双向绑定利用的设计模式是公布-订阅模式，因为设计模式能更好的阐明不同类之间的用意，对于咱们了解源码有很大的帮忙(Ps:对于笔者是的) ，所以咱们将从这个设计模式说起。公布-订阅模式在很多文章中都被认为成观察者模式，包含在《Javascript设计模式与开发实际》一书中，作者示意 公布-订阅模式又叫观察者模式通过笔者考查二者在是实现上还是有些区别，然而能确定公布-订阅模式是观察者模式的一种变体。 Vue2.0双向绑定源码 观察者模式 VS 公布-订阅模式观察者模式它定义对象间的一种一对多的依赖关系，当一个对象的状态产生扭转时，所有依赖于它的对象都将失去告诉。 观察者模式中次要由两类对象组成，一种是发布者(主题)，一种是观察者。 发布者 -- 为观察者提供注册性能，在须要的时候给观察者发送音讯观察者 -- 实现上须要监听发布者的扭转具体实现咱们来看一下代码(TypeScript) class Observer { update() { // do something console.log("收到告诉") }}class Subject { observerLists: Observer[] = [] publish() { this.observerLists.forEach((observer) => { observer.update() }) } trigger(observer: Observer) { this.observerLists.push(observer) }}const observer = new Observer()const subject = new Subject()subject.trigger(observer)subject.publish() //收到告诉这就是最简略的观察者模式的实现形式，该模式次要含有两种类型的对象，而且这两种对象之间是“相互理解”的。 公布-订阅模式事实上，公布-订阅模式与观察者模式的用意是没有太大的区别的，都是为了监听一个对象的变动，并且在这个对象扭转的时候告诉另一个对象。然而当初两个对象之间是“相互理解”(耦合)的，那么为理解耦两种对象之间的关系，咱们能够来看一下公布-订阅模式有什么新的扭转呢？ 咱们再来看一下具体代码的实现(TypeScript) class Dep { observerLists: Observer[] = [] publish() { this.observerLists.forEach((observer) => { observer.update() }) } trigger(observer: Observer) { this.observerLists.push(observer) }}class Observer { update() { // do something console.log("收到告诉") }}class Subject { deps: Dep[] = [] change() { this.deps.forEach((dep) => dep.publish()) } depend(dep: Dep) { this.deps.push(dep) }}const observer = new Observer()const subject = new Subject()const dep = new Dep()subject.depend(dep) // 发布者关联音讯核心dep.trigger(observer) // 观察者关联音讯核心subject.change() // 收到告诉与观察者模式相比拟，该模式减少了音讯核心的对象来做音讯的调度工作。而咱们一会要看的Vue源码，就是通过这种形式实现的。 ...

开发一个利用并不是一件难事，然而对利用的整体架构有一个深刻的理解的确是一件了不起的事。个别，零碎设计面试题都会放在最初来考查 candidata 的更高 level 的程度。 零碎设计能够让面试官更充沛的理解 candidata 的全方面的程度。波及到操作系统、网络、模块化、设计模式、分布式等等系列的问题。面试官只有抓住一点感兴趣的点，就能够很快的理解 candidata 在这个畛域的理解和深度。 1、首先，零碎设计面试考你什么？ 答：考你对问题的剖析，trade off，考你对一项技术的理解水平。 2、怎么样答复才比拟好？ 答：最现实的状况是——根本题目给进去，你就可能晓得这个零碎的大略构造会是怎么样的，所有的考点散布在哪里。 3、如何去做能力达到答复得比拟好的状况？ 答：你得看过这些构造并且晓得它所有的 tradeoff，晓得它用到的所有技术等等，现场凭借教训想是只有大牛能力做的活。咱们个别人还是老老实实的学习现有的零碎吧。 4、如何晓得考点在哪里？ 答：想想如果你是面试官你会问什么？在看其他人设计的构造的时候带着问题去看，构想哪里你能够提出什么样的问题，这样缓缓的你就会有领会了。例如：零碎设计要用到 message queue，大半会提到 kafka。这个时候你得晓得面试官会问 kafka 什么？他八成会问到用 kafka 有什么问题。那么有什么问题呢？ kafka 只保障了 at least one time delivery。所以你最好给每个 message 加 sequence number 来避免 duplictes（是的我晓得 kafka 起初 promise 了 exact one time delivery 的 feature，不过没人用） 相似这样，你得在面试官问进去之前就晓得问题是啥。这是能够做的到的。只有你总是带着问题去看。 个别零碎设计面试题的解法分为四个步骤： Step1： 明确需要和标准。这个是最重要的，确保你的指标清晰明确，保障接下来的工作可能合成和施行，可能确保实现你的指标。 Step2： 描绘出高层次的设计。在这个阶段还不用去认真描述具体的施行细节。只须要将几个大的模块给确定好，布局出他们之间的交互就能够了。 Step3： 评估和计算。针对不同用户数量级别，不同性能需求的条件，来确定前面的机器硬件配置及数量等撑持条件。 其中，零碎设计有次要的三个话题：别离是 交互、存储和 CAP 平衡。 交互：即网络交互，是采纳牢靠但慢的 TCP，还是采纳不牢靠然而疾速的 UDP。HTTP 是在应用层，并且基于 TCP 协定。 存储：设计到关系型数据库，内存数据库和分布式数据库等等概念。很多问题也不只是只能依附某一个数据可来解决的。只有设计正当，能够满足条件就行。 ...

一、双亲委派模型咱们晓得类加载机制是将一个类从字节码文件转化为虚拟机能够间接应用类的过程，然而是谁来执行这个过程中的加载过程，它又是如何实现或者说保障了类加载的准确性和安全性呢？答案就是类加载器以及双亲委派机制。 双亲委派模型的工作机制是：当类加载器接管到类加载的申请时，它不会本人去尝试加载这个类，而是把这个申请委派给父加载器去实现，只有当父加载器反馈本人无奈实现这个加载申请时，子类加载器才会尝试本人去加载。 咱们能够从JDK源码中将它的工作机制一窥到底。 ClassLoader#loadClass(String,boolean) 这是在JDK1.8的java.lang.ClassLoader类中的源码，这个办法就是用于加载指定的类。 protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // First, check if the class has already been loaded // 首先，查看该类是否曾经被以后类加载器加载 Class<?> c = findLoadedClass(name); if (c == null) { long t0 = System.nanoTime(); try { if (parent != null) { c = parent.loadClass(name, false); } else { c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) { // ClassNotFoundException thrown if class not found // from the non-null parent class loader } if (c == null) { // If still not found, then invoke findClass in order // to find the class. //如果父类未实现加载，应用以后类加载器去加载该类 long t1 = System.nanoTime(); c = findClass(name); // this is the defining class loader; record the stats sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); sun.misc.PerfCounter.getFindClasses().increment(); } } if (resolve) { resolveClass(c); } return c; } }通过以上代码得出结论： ...

春招曾经开始了。 你是不是曾经开始筹备了呢？为了帮忙大家取得更好的 offer，lucifer 开拓了春招冲冲冲栏目。 明天咱们的猎物是钉钉和腾讯。来看看这两家的算法题难度几何吧！ <!-- more --> 视频地址：https://www.bilibili.com/vide... 钉钉比拟版本号（力扣题号 165.比拟版本号）一次遍历即可，惟一须要留神的是补全再比拟（逻辑补全即可，并不一定须要物理上真的去补全），工夫复杂度 $O(m + n)$，其中 m 和 n 别离为两个版本号的长度 随机字符串生成（随机生成一个长度为 8 的字符串，要求只能是小写字母和数字，字母和数字可反复，然而生成的随机字符串不能反复）随机生成一个长度为 8 的字符并将其存到哈希表中，下次生成后判断是否曾经在哈希表中了。如果存在，阐明之前生成过了，持续生成。留神这种算法存在始终回绝的可能，代码会有限循环。 日志上报（实现成果：没有数据不上报，有数据每 100ms 批量上报一次）保护一个窗口，当窗口内有数据才触发申请批量上传，一个窗口的长度为 100m（可能大于） 内的所有申请 腾讯字符串反转头尾双指针，一直替换两个指针的字符即可。 链表的倒数第 k 个数快慢双指针典型题目。 设计求一个数的 n 次开方典型的二分题目，不会的倡议看下我的二分讲义。我的刷题仓库或者公众号搜 二分 就行。 LRU 算法略微有点难度了，这个题很常见，难度不小，倡议刷。我之前写过题解了，间接甩给大家吧 146. LRU 缓存机制 我给了 JS, Go, PHP, Python3 四种语言，有你的菜么？手撕一下，就是一个小车给定坐标地位，和当后面朝方向（NSWE），再输出后退转向状况和前提高数，输入小车的坐标地位和面朝方向。没啥难度，间接模仿。 链表相加链表和数组实质没有不同，只是具体操作不一样。因而把握链表基本操作就行了。链表基本操作有哪些？须要留神什么？我的链表专题都给大家总结好了，倡议浏览。 leetcode 1567 乘积为负数的最长子数组长度。题目是：给你一个整数数组 nums ，请你求出乘积为负数的最长子数组的长度。一个数组的子数组是由原数组中零个或者更多个间断数字组成的数组。请你返回乘积为负数的最长子数组长度。 这道题是求间断的乘积为负数的最长子数组长度。这里须要一个小学常识，两个符号雷同的相乘为负数，两个符号不同的数相乘为正数（先不思考 0）。 于是间接应用一维 DP + 一层循环即可。 定义状态 positive[i] 为 nums[i] 结尾的乘积为负数的最长子数组长度，negative[i] 为 nums[i] 结尾的乘积为正数的最长子数组长度，于是答案就是 max(positive)。 接下来，遍历 nums，对 nums[i] 的不同取值分类探讨即可： ...

程序，过程，线程程序：为实现特定工作，应用某种语言编写的一组指令的汇合，是一段动态的代码。过程：程序的一次运行过程，或者是正在运行的一个程序。过程是资源分配的根本单位。线程：线程由过程进一步细化而来，是一个程序外部的一条执行门路。线程是调度和执行的单位，每个线程领有独立的运行栈和程序计数器，线程开销很小。Thread生命周期 Thread类中的罕用办法start()：启动以后线程；调用以后线程的run()。run()：通常须要重写Thread类中的此办法，将创立的线程要执行的操作申明在此办法中。currentThread()：静态方法，返回执行以后代码的线程。getName()：获取以后线程的名字。setName()：设置以后线程的名字。yield()：开释以后cpu的执行权。join()：在线程a中调用线程b的join()办法,此时线程a就进入阻塞状态，直到线程b齐全执行完当前，线程a才完结阻塞状态。sleep(long millitime)：让以后线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒工夫内，以后线程是阻塞状态。isAlive()：判断以后线程是否存活。getPriority()：获取线程的优先级。setPriority(int p)：设置线程的优先级。线程的优先级有以下三种，MAX_PRIORITY：10；MIN _PRIORITY：1；NORM_PRIORITY：5。创立多线程的形式继承Thread类步骤： 创立一个继承于Thread类的子类；重写Thread类中的run()办法，将次线程执行的操作申明在run()办法中。创立Thread类的子类对象。通过此对象调用start()。举例：三个窗口进行卖票（存在线程平安问题） class MThread extends Thread{ private static int tickets = 100; @Override public void run() { while(true){ if(tickets > 0){ System.out.println(getName() + "卖票，票号为：" + tickets--); }else{ break; } } }}public class ThreadTest { public static void main(String[] args) { MThread t1 = new MThread (); MThread t2 = new MThread (); MThread t3 = new MThread (); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); }}阐明：局限于类的单继承性。 ...

本篇文章次要在于探索 Promise 的实现原理，率领大家一步一步实现一个 Promise , 不对其用法做阐明，如果读者还对Promise的用法不理解，能够查看阮一峰老师的ES6 Promise教程。接下来，带你一步一步实现一个 Promise Promise 根本构造new Promise((resolve, reject) => { setTimeout(() => { resolve('FULFILLED') }, 1000)})构造函数Promise必须承受一个函数作为参数，咱们称该函数为handle，handle又蕴含resolve和reject两个参数，它们是两个函数。定义一个判断一个变量是否为函数的办法，前面会用到 // 判断变量否为functionconst isFunction = variable => typeof variable === 'function'首先，咱们定义一个名为 MyPromise 的 Class，它承受一个函数 handle 作为参数 class MyPromise { constructor (handle) { if (!isFunction(handle)) { throw new Error('MyPromise must accept a function as a parameter') } }}再往下看 Promise 状态和值Promise 对象存在以下三种状态： Pending(进行中)Fulfilled(已胜利)Rejected(已失败)状态只能由 Pending 变为 Fulfilled 或由 Pending 变为 Rejected ，且状态扭转之后不会在发生变化，会始终放弃这个状态。Promise的值是指状态扭转时传递给回调函数的值 上文中handle函数蕴含 resolve 和 reject 两个参数，它们是两个函数，能够用于扭转 Promise 的状态和传入 Promise 的值new Promise((resolve, reject) => { setTimeout(() => { resolve('FULFILLED') }, 1000)})这里 resolve 传入的 "FULFILLED" 就是 Promise 的值 ...

前言依赖注入DI（Dependency Injection）的三种注入办法应用介绍set办法构造方法注解法应用set办法注入如下图中UseService文件依赖Userdao对象，能够通过setUserDao11函数设置注入 配置文件应用property标签配置注入内容留神：配置文件中name参数的值取至set办法后跟的内容同时首字母小写例如：set办法名是setUserDao111,那么name的值就是userDao111。 应用有参构造函数注入 有参构造函数注入应用constructor-arg标签name是要注入的构造函数的参数名 如果注入的内容是援用类型，就应用‘ref=’给对象赋值，且对象的值必须是在配置文件中注册过的的对象id，如本文中的userServiceId和userDaoId，如果注入内容是一般数据类型，就应用‘value=’赋值，赋的值能够是任意值，无需提前注册。 应用注解应用注解办法时不须要在配置文件中增加各个要注入的内容，而是在配置文件中配置组件扫描即可,源文件也不在须要定义set办法，构造方法。 在配置文件中增加如下语句，即可让spring扫描com.syx.dao包下的所有注解，否则spring无奈辨认你注解的内容 <context:component-scan base-package="com.syx.dao"></context:component-scan>具体注解办法如下： // 应用Component增加id为userServiceId的注解相当于配置文件执行了// <bean id="userServiceId" class="com.syx.dao.service.UserService"/>@Component("userServiceId")public class UserService { // Autowired和Qualifier组合作用是依照名称进行注入，应用相当于 // <constructor-arg name="userdaoparam" ref="userDaoId"></constructor-arg> @Autowired @Qualifier("userDaoId") private UserDao userdaoparam; // Value是依照值进行注入，相当于 // <property name="test_a" value="13"></property> // 注解中的值能够是${...}表达式 @Value("13") private int test_a; public void test() { System.out.println("注入值是" + test_a); userdaoparam.test(); }}罕用配置文件注入标签应用示例 <bean id="userServiceId" class="com.syx.dao.service.UserService"> <property name="userDao11" ref="userDaoId"></property> <!-- test_a 是int类型数据注入值100 --> <property name="test_a" value="100"></property> <!-- strList是List<String>汇合，应用如下办法给汇合增加两个成员aaa和bbb --> <property name="strList"> <list> <value>aaa</value> <value>bbb</value> <!-- 如果汇合List存储的是援用类型数据 需改用ref标签赋值，如下 <ref bean="userDaoId"></ref> --> </list> </property> <!-- userMap是Map<String, String>类型数据 --> <property name="userMap"> <map> <entry key="adc" value="def"></entry> <!-- 如果Map的键值对均为援用类型，那么要应用如下标签进行注入 <entry key-ref="adc" value-ref="def"></entry> --> </map> </property> <!-- properties是一个Properties类型数据 --> <property name="properties"> <props> <prop key="adc">123456</prop > <prop key="adc">fkgj</prop > </props> </property> </bean>注解详解 ...

本文节选自《Java面试进阶指北 打造集体的技术竞争力》面试中常常喜爱问的一个问题，因为通过这个问题，面试官能够顺便理解一下你的操作系统的程度。 IO 模型这块的确挺难了解的，须要太多计算机底层常识。写这篇文章用了挺久，就十分心愿能把我所晓得的讲进去吧!心愿敌人们能有收货！为了写这篇文章，还翻看了一下《UNIX 网络编程》这本书，太难了，我滴乖乖！心痛~ 集体能力无限。如果文章有任何须要补充/欠缺/批改的中央，欢送在评论区指出，共同进步！ 前言I/O 始终是很多小伙伴难以了解的一个知识点，这篇文章我会将我所了解的 I/O 讲给你听，心愿能够对你有所帮忙。 I/O何为 I/O?I/O（Input/Outpu） 即输出／输入 。 咱们先从计算机构造的角度来解读一下 I/O。 依据冯.诺依曼结构，计算机构造分为 5 大部分：运算器、控制器、存储器、输出设施、输出设备。 输出设施（比方键盘）和输出设备（比方显示屏）都属于外部设备。网卡、硬盘这种既能够属于输出设施，也能够属于输出设备。 输出设施向计算机输出数据，输出设备接管计算机输入的数据。 从计算机构造的视角来看的话， I/O 形容了计算机系统与外部设备之间通信的过程。 咱们再先从应用程序的角度来解读一下 I/O。 依据大学里学到的操作系统相干的常识：为了保障操作系统的稳定性和安全性，一个过程的地址空间划分为 用户空间（User space） 和 内核空间（Kernel space ） 。 像咱们平时运行的应用程序都是运行在用户空间，只有内核空间能力进行零碎态级别的资源无关的操作，比方如文件治理、过程通信、内存治理等等。也就是说，咱们想要进行 IO 操作，肯定是要依赖内核空间的能力。 并且，用户空间的程序不能间接拜访内核空间。 当想要执行 IO 操作时，因为没有执行这些操作的权限，只能发动零碎调用申请操作系统帮忙实现。 因而，用户过程想要执行 IO 操作的话，必须通过 零碎调用 来间接拜访内核空间 咱们在平时开发过程中接触最多的就是 磁盘 IO（读写文件） 和 网络 IO（网络申请和相应）。 从应用程序的视角来看的话，咱们的应用程序对操作系统的内核发动 IO 调用（零碎调用），操作系统负责的内核执行具体的 IO 操作。也就是说，咱们的应用程序实际上只是发动了 IO 操作的调用而已，具体 IO 的执行是由操作系统的内核来实现的。 当应用程序发动 I/O 调用后，会经验两个步骤： 内核期待 I/O 设施筹备好数据内核将数据从内核空间拷贝到用户空间。有哪些常见的 IO 模型?UNIX 零碎下， IO 模型一共有 5 种： 同步阻塞 I/O、同步非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。 ...

举荐浏览：对于iOS面试题汇总(栏目继续更新) 最近大家都要筹备去面试或者曾经在面试的，这里我给大家筹备了挺多材料，能够私信我拿，看看理解下。底下就是我整理出来的一些面试题 iOS 类（class）和构造体（struct）有什么区别？Swift 中，类是援用类型，构造体是值类型。值类型在传递和赋值时将进行复制，而援用类型则只会应用援用对象的一个"指向"。所以他们两者之间的区别就是两个类型的区别。 举个简略的例子，代码如下 class Temperature { var value: Float = 37.0}class Person { var temp: Temperature? func sick() { temp?.value = 41.0 }}let A = Person()let B = Person()let temp = Temperature()A.temp = tempB.temp = temp有想要支付收费材料的能够进裙或者加好友支付，这里有一个iOS交换圈：891 488 181 能够来理解，分享BAT,阿里面试题、面试教训，探讨技术，裙里材料间接下载就行， 大家一起交流学习！有想要的面试材料或者其余材料也能够找我，欢送征询！须要的可自行下载A.sick() 下面这段代码，因为 Temperature 是 class ，为援用类型，故 A 的 temp 和 B 的 temp指向同一个对象。A 的 temp批改了，B 的 temp 也随之批改。这样 A 和 B 的 temp 的值都被改成了41.0。如果将 Temperature 改为 struct，为值类型，则 A 的 temp 批改不影响 B 的 temp。 ...

第一次电话面试依照程序打印 1 到 100 不少于一个线程 //全局变量 var lock = os_unfair_lock() DispatchQueue.global().async { self.action() } DispatchQueue.global().async { self.action() } //具体打印 func action(){ while true { os_unfair_lock_lock(&lock) if num >= 100{ os_unfair_lock_unlock(&lock) return } num += 1 print("\(num)----\(Thread.current)") os_unfair_lock_unlock(&lock) } }全局并发队列打印1 到 10000 最终后果会多于 10000 因为会同时拿到 num 值 进行加一MVVM view 和 viewmodel 和 model 的关系viewModel持有 model view 持有 viewModel 使 view 和 model 实现双向绑定不必 RAC 怎么实现 MVVM利用 KVO 实现双向绑定UIView.animate.during 监听 alpha 0 到 1的变动 let normalView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100)) normalView.backgroundColor = UIColor.red normalView.alpha = 0 view.addSubview(normalView) let timer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true) { (time) in let layer = normalView.layer.presentation() print(layer?.opacity) } RunLoop.current.add(timer, forMode: RunLoopMode.commonModes) UIView.animate(withDuration: 2) { normalView.alpha = 1 }setNeedlayout layouSubViews等这里有一个iOS交换圈：891 488 181 能够来理解，分享BAT,阿里面试题、面试教训，探讨技术，裙里材料间接下载就行， 大家一起交流学习！layouSubViews的调用机会 ...

前言好哥哥们，正如题目一样，安酱被虐了，虐的遍体鳞伤，归纳起来就是一个菜（真的菜）。 事件的通过真是一把辛酸泪啊。讲道理，再去之前我还是很有信念的（自信爆棚好吗）。随着面试的推动，我发现我扛不住了，数据库底层原理和网络相干我是真不会呀，不会就算了，面试官就挑着这些来问，都不按简历上的技术点来的。 面试公司的话据说由微博（不晓得是不是，反正就是某大厂）一个技术大佬带的一个团队组建的守业公司（当然还是在广州这边，有好哥哥想要挑战一下吗，评论区通知我）。进去还做了一份面试题，讲道理，题目间接对标字节好吗。好家伙一看一道硬币概率题、两道算法（记得有一个是原地算法）、还有一个Mysql的MVCC实现原理（如同还有一个是synchronized和volatile的原理）。就这 45 分钟做完。 认为这就完了吗？ 更虐我的还是面试官，我轻易说一个技术点根本都要打断我。就像本篇上面Http 与 Netty 数据传输的区别这个题目，就是从Feign 和Dubbo的区别引出来的。怎么说呢，就是死抠一个点，抠细节，这种模式是真的很难抗的住啊！！！ 题目的话记录了一些没有答复的比拟好的，安酱也说不上难与不难（图片都是搬的我丙哥的，最初面有链接）。 Mysql 索引底层数据结构是什么Mysql 索引采纳的数据结构是 B+ 树(如下图)，与B树 的次要区别在于B+ 树辨别了叶子节点和非叶子节点。只有叶子节点才会存储数据，非叶子节点只存储键值。 叶子节点之间应用双向指针连贯，最底层的叶子节点造成了一个双向有序链表。 Mysql 索引数据结构为什么抉择 B+ 树，而不抉择红黑树或者其余树这个的话讲一下应用B+ 树的有点就能够了，而后我又答复了个寂寞(问我过后那一刻有点懵，其实我是晓得的，然而我就不通知他)。 B+ 树是多路均衡二叉树，相较于红黑树、二叉树来说，整个树形构造高度会大幅缩小，这也意味着应用索引查找的次数会缩小，从而进步查问效率。B+ 数辨别了叶子节点和非叶子节点，只有在叶子节点才会真正的存储数据。因为Mysql的InnoDB存储引擎一次IO会读取的一页（默认一页 16K）的数据量。B树中叶子节点和非叶子节点都会存储实在数据，也就是说随着列数的增多，所占空间会变大,树相应就会变高，磁盘 IO 次数就会变大。应用B+ 能更好的反对范畴查找。这里次要说的是性能上，B树也能够反对范畴查找，然而须要在树往下或者往上查找。B+ 在叶子节点就曾经保护了一个双向有序链表，所以人造就适宜用来做范畴查找。Mysql 索引文件是怎么加载到内存中的这里在面试的时候我是没有了解面试官的意思的，当进去坐公交复盘的时候忽然就想起来了。面试官应该想晓得的是应用索引查找的过程，这个过程蕴含了加载页索引文件（是我太菜了）。 这里须要重点讲突出的是索引文件是按页加载的，比如说我要做一个惟一id等值查找，其大略过程如下: 如果咱们查问值等于 9 的数据。查问门路磁盘块1->磁盘块2->磁盘块6。 第一次磁盘 IO：将磁盘块1加载到内存中，在内存中从头遍历比拟，9 < 15，走左路，到磁盘寻址磁盘块2。 第二次磁盘 IO：将磁盘块2加载到内存中，在内存中从头遍历比拟，7 < 9 < 12，到磁盘中寻址定位到磁盘块6。 第三次磁盘 IO：将磁盘块6加载到内存中，在内存中从头遍历比拟，在第三个索引中找到 9，取出Data，如果Data存储的行记录，取出Data，查问完结。如果存储的是磁盘地址，还须要依据磁盘地址到磁盘中取出数据，查问终止。（这里须要辨别的是在InnoDB中Data存储的为行数据，而MyIsam中存储的是磁盘地址。） TCP 怎么确保传输可靠性面试官问我这个的时候，我的答案是我不会（是真的，我是真的不会）!!! 这篇的话就大略讲一下保障可靠性几点，不做深刻的剖析。我也不会呀，是时候要好好钻研一下网络相干的货色了。 TCP在建设连贯采纳三次握手和断开连接四次挥手的连贯管理机制（过后我只答复了这一个，而后面试官来了一句就因为这个就能确保传输的安全可靠吗。我是真想答复是的）。测验和。TCP测验和的计算与UDP一样，在计算时要加上12byte的伪首部，测验范畴包含TCP首部及数据局部，然而UDP的测验和字段为可选的，而TCP中是必须有的。计算方法为：在发送方将整个报文段分为多个16位的段，而后将所有段进行反码相加，将后果寄存在测验和字段中，接管方用雷同的办法进行计算，如最终后果为测验字段所有位是全 1 则正确（UDP 中为 0 是正确），否则存在谬误。序列号。TCP将每个字节的数据都进行了编号，这就是序列号。作用如下：3.1 保障可靠性（当接管到的数据总少了某个序号的数据时，能马上晓得）。3.2 保证数据的按序达到。3.1 提高效率，可实现屡次发送，一次确认。3.1 去除反复数据。确认应答机制（ACK）。TCP通过确认应答机制实现牢靠的数据传输。在TCP的首部中有一个标记位——ACK，此标记位示意确认号是否无效。接管方对于按序达到的数据会进行确认，当标记位ACK=1时确认首部的确认字段无效。进行确认时，确认字段值示意这个值之前的数据都曾经按序达到了。而发送方如果收到了已发送的数据的确认报文，则持续传输下一部分数据；而如果期待了肯定工夫还没有收到确认报文就会启动重传机制。超时重传机制。当报文收回后在肯定的工夫内未收到接管方的确认，发送方就会进行重传（通常是在收回报文段后设定一个闹钟，到点了还没有收到应答则进行重传）。流量管制。接收端解决数据的速度是无限的，如果发送方发送数据的速度过快，导致接收端的缓冲区满，而发送方持续发送，就会造成丢包，继而引起丢包重传等一系列连锁反应。拥塞管制。流量管制解决了两台主机之间因传送速率而可能引起的丢包问题，在一方面保障了 TCP 数据传送的可靠性。然而如果网络十分拥挤，此时再发送数据就会减轻网络累赘，那么发送的数据段很可能超过了最大生存工夫也没有达到接管方，就会产生丢包问题。为此TCP引入启动机制，先收回大量数据，就像探路一样，先摸清以后的网络拥挤状态后，再决定依照多大的速度传送数据。此处引入一个拥塞窗口。Http 与 Netty 数据传输的区别实际上这道题是问RPC带进去的。过后问了一个Dubbo 和 Feign有什么的区别？ 这时安酱就往陷阱外面跳了，因为Dubbo应用的是Netty 传输，而后通过反射调用本地办法，而Feign 是通过RestTemplate调用Http接口的形式。而后就正中面试官下怀，从而引出了这个一个问题，我又答复了个寂寞。 ...

vue罕用原理 源码vue3.0https缓存webpack原型、this、闭包、箭头函数、

最近入职新的公司，整体来说还是不错的。前一阵子看了很多对于vue的知识点，本人了解着整顿一下，再加深一下印象。也心愿能够帮忙到有须要的同学。了解谬误的中央，欢送斧正。 1、对于Vue是一套渐进式框架的了解答：Vue是渐进的，没有强主张，是个轻量视图。它只做了本人应该做的事，没有做多余的事。 2、vue.js的两个外围是什么？答：数据驱动和组件化。 3、vue中的模板编译原理答：模板指的就是template。如果咱们传了一个template，咱们会把template转换成一个render函数，而后通过render函数返回虚构DOM，再把虚构的DOM变成真正的DOM。 4、 响应式数据的原理答：响应式就是当数据变动的时候，能够让视图也同步更新。外围是Object.defineProperty，vue初始化的时候，Object.defineProperty顺次会给data的属性上减少get和set办法，并对依赖进行收集，如果数据发生变化，就会去告诉相干的依赖做出对应的更新。 5、vue生命周期钩子函数有哪些？(vue2.0) 答：① 创立期间的生命周期函数：beforeCreate()：此时，实例在内存中刚刚创立进去，data和methods没 有被初始化。created()：此时，实例曾经在内存中创立实现，data和methods曾经被初始化实现。模板还没有编译。beforeMount（）：此时，模板曾经编译胜利，还没有挂载到页面上。mounted()：此时，编译好的模板曾经挂载到了指定的地位下来。② 运行期间的生命周期函数：beforeUpdate()：此时，data数据产生扭转后，还没有从新渲染DOM树，data的数据是最新的，然而页面上展现的还是旧数据。updated()：此时，data中的数据和页面中的渲染是统一的。③ 销毁期间的生命周期函数：beforeDestroy()：此时，实例的办法、指令都还能够应用，实例销毁之前调用。destroyed()：此时，vue实例上的所有指令、绑定、监听都会被销毁，子实例也全副被销毁。 6、 vue的生命周期钩子是如何实现的？答：vue的生命周期钩子实际上就是一个回调函数。当咱们传入一个钩子函数时，vue外部会帮咱们调用，并将生命周期钩子转换成数组，调用的时候，就又会把数组遍历一遍，宝宝起名-相似一个公布订阅的模式。 7、vue 的双向绑定的原理是什么？答：vue数据双向绑定是通过数据劫持联合发布者-订阅者模式的形式来实现的。实现步骤：①.实现一个监听器Observer，用来劫持并监听所有属性，如果有变动的，就告诉订阅者。②.实现一个订阅者Watcher，能够收到属性的变动告诉并执行相应的函数，从而更新视图。③.实现一个解析器Compile，能够扫描和解析每个节点的相干指令，并依据初始化模板数据以及初始化相应的订阅器。 8、 vue为什么要操作虚构DOM?答：虚构DOM就是用一个对象，来形容实在DOM。一个实在的DOM下面有十分多的属性，操作起来十分不便，为了缩小DOM操作，咱们在更新的时候就把须要更新的DOM先记录下来，而后更新这些须要更新的DOM，最初再依据diff算法比对，更新DOM。（vue里的diff算法是平级比拟，不思考跨级比拟）虚构DOM不依赖实在的平台环境，能够实现跨平台。 9、v-if 和 v-show 有什么区别？答：这两个指令都是在判断DOM节点是否要显示。区别是：①.实现形式： v-if是依据前面数据的虚实值判断间接从Dom树上删除或重建元素节点。 v-show只是在批改元素的display的属性值，元素始终在Dom树上。②.编译过程：v-if切换有一个部分编译/卸载的过程，切换过程中适合地销毁和重建外部的事件监听和子组件； v-show只是简略的基于css切换；③.编译条件：v-if是惰性的，如果初始条件为假，则什么也不做；只有在条件第一次变为真时才开始部分编译； v-show是在任何条件下（首次条件是否为真）都被编译，而后被缓存，而且DOM元素始终被保留；④.性能耗费：v-if有更高的切换耗费，不适宜做频繁的切换； v-show有更高的初始渲染耗费，适宜做频繁的切换； 10、vue罕用的修饰符答：vue修饰符次要有：①事件修饰符.stop：和原生JavaScript中的event.stopPropagation()统一，阻止事件冒泡.prevent：和原生JavaScript中的event.preventDefault()统一，阻止默认事件.capture：与事件冒泡的方向相同，事件捕捉由外到内.self：只会触发本人范畴内的事件，不蕴含子元素.once：只会触发一次。②按键修饰符.delete（捕捉“删除”和”退格“键） 用法上和事件修饰符一样，挂载在v-on:前面： v-on:keyup.xxx=’yyy’ <input @keyup.delete=“onKey”/> ③零碎修饰符.ctrl .alt .shift .meta这些修饰符能够实现按下相应按键触发鼠标或键盘事件的监听器。 11、v-on能够监听多个办法吗？答：能够 点我 12、 vue.mixin的应用场景和原理是什么？答：vue.mixin能够减少公共办法，当组件初始化调用的时候，mergeOptions办法会进行合并，并针对不同的属性进行合并。vue.mixin也有很多毛病，比方依赖问题、命名问题、数据不能共享、数据起源等问题。 13、vue中 key 值的作用答： key的作用次要是为了高效的更新虚构DOM。在vue中，当应用雷同标签名元素的过渡切换时，也会应用到key属性，这样是为了让vue辨别它们，否则vue只会替换其外部属性而不会触发过渡成果。 14、Vue 组件中 data 为什么必须是函数？答：在 new Vue() 中，data 是能够作为一个对象进行操作的，然而在 component 中，data 只能以函数的模式存在，不能间接将对象赋值给它。 当data选项是一个函数的时候，每个实例能够保护一份被返回对象的独立的拷贝，这样各个实例中的data不会相互影响，是独立的。 15、v-for 与 v-if 的优先级答：v-for优先级高于v-if。 16、 nextTick的实现原理是什么？答：nextTick中的回调函数是在下一次DOM更新完结之后执行的，提早了回调，从而避免屡次更新。nextTick外面就是一个异步办法（promise）。 17、说出至多 4 种 vue 当中的指令和它的用法答：① v-if(判断是否暗藏)② v-for(遍历)③ v-bind(属性绑定)⑤ v-model(双向数据绑定) ...

举荐浏览地址： 掘金 大家好，我是林一一，这是一篇对于 JS 原型和原型链中的那些事，理解原型和原型链之前须要理解一些 JS 中的OOP，大家也能够间接跳到原型和原型链那里。让咱们开始浏览吧。????本文思维导图 面向对象编程 OOP (Object Oriented Programming)面向过程：__就是剖析出解决问题所须要的步骤，而后用函数把这些步骤一步一步实现，应用的时候一个一个顺次调用就能够了。__面向对象：__是把形成问题事务分解成各个对象，建设对象的目标不是为了实现一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。__面向过程长处：性能比面向对象高，因为类调用时须要实例化，开销比拟大，比拟耗费资源;比方单片机、嵌入式开发、 Linux/Unix等个别采纳 面向过程开发，性能是最重要的因素。 毛病：没有面向对象易保护、易复用、易扩大面向对象长处：易保护、易复用、易扩大，因为面向对象有封装、继承、多态性的个性，能够设计出低耦合的零碎，使零碎 更加灵便、更加易于保护 毛病：性能比面向过程低JS 中一切都是对象每一个数据类型底层的封装都是基于 Object 来创立的，援用类型 Function() 函数 Array() Date() Math()，String(), Number(), 等根本类型，nodeLIst 节点汇合，window 等都是基于构造函数 constructor 创立自定义类// 字面量模式function fn(){}var obj = {}// 构造函数模式var f = new fn() // ==> new fnconsole.log(f)var obj = new Object()console.log(obj)应用 new 关键字就是利用构造函数创立一个实例，实例就是一个类。另一个就是字面量模式Object 是一个工厂办法能依据传入的类型，转换成相应的原始包装类型var num = Object(12)console.log(num instanceof Number) // truevar str = Object('12')console.log(str instanceof String) // truevar boolean = Object(true)console.log(boolean instanceof Boolean) // true根本类型值创立形式的区别var a = 12console.log(typeof a) // 'number'a.toFixed(2) // "12.00"var b = new Number(12)console.log(typeof b) // 'object'b.toFixed(2) // "12.00"var c = new String('12')console.log(typeof c) // object须要留神的是根本类型 Symbol() 并反对 new 语法，浏览器不认为 Symbol 是一个构造函数，其余根本类型都能够认为是构造函数。 ...

一.Scanner对象之前咱们学的根本语法中咱们并没有实现程序和人的交互，然而Java给咱们提供了这样一个工具类，咱们能够获取用户的输出。java.util.Scanner是Java5的新特色，咱们能够通Scanner类来获取用户的输出。 根本语法： Scanner s=new Scanner(System.in);通过Scanner类的next（）与nextLine（）办法获取字符串，在读取前咱们个别须要应用hasNext（）与hasNextLine（）判断是否还有输出的数据。 package Demo01;import java.util.Scanner;public class D1 { public static void main(String[] args) { //创立一个扫描对象用于接管键盘数据 Scanner scanner=new Scanner(System.in); System.out.println("应用next的形式接管："); //判断用户有没有输出字符串 if (scanner.hasNext()){ //应用next办法接管 String st=scanner.next();//程序会期待用户输出结束 System.out.println("接管"+st); } //但凡IO流的类如果不敞开会始终占用资源，要养成好习惯用完就关掉 scanner.close(); }}拓展：package Demo01;import java.util.Scanner;public class D2 { public static void main(String[] args) { Scanner scanner=new Scanner(System.in); //从键盘接收数据 System.out.println("应用next的形式接管："); //判断是否还有输出 if (scanner.hasNextLine()){ String string=scanner.nextLine(); System.out.println("接管"+string); } scanner.close();//开释资源 }}Scanner对象比照以上两个代码得出：next（）；肯定要读取到无效字符才能够完结。对输出无效字符之前遇到的空白，next（）办法会主动将其去掉。只有输出无效字符后才将其前面输出的空白作为分隔符或者结束符。next（）不能失去带有空格的字符串。nextLine（）：一Enter为结束符，也就是说nextLine（）办法返回的是输出回车之前的所有字符。能够或得空格。Scanner进阶一个例子：package Demo01;import java.util.Scanner;public class D4 { public static void main(String[] args) { Scanner scanner=new Scanner(System.in); //从键盘获取数据 int i=0; float d=0.0f; System.out.println("请输出整数:"); if (scanner.hasNextInt()){ i=scanner.nextInt(); System.out.println("输入："+i); }else { System.out.println("不合乎"); } System.out.println("================="); System.out.println("请输出小数:"); if (scanner.hasNextFloat()){ d=scanner.nextFloat(); System.out.println("输入："+d); }else { System.out.println("不合乎"); } scanner.close();//开释内存 }}本人写的例子：package Demo01;import java.util.Scanner;public class D5 { public static void main(String[] args) { //我的项目要求：咱们能够输出多个数字，并求其总和和平均数，每输出一个数字用回车来确定，通过输出非法数字来完结并输入执行后果 int i = 0; double d = 0.00; int c = 0; int h = 0; System.out.println("请输出:"); Scanner scanner = new Scanner(System.in); while (true) { if (scanner.hasNextInt()) { i += i + d; i = scanner.nextInt(); System.out.println("输入:" + i); c++; } else if (scanner.hasNextFloat()) { d += d + i; d = scanner.nextDouble(); System.out.println("输入:" + d); h++; }else { System.out.println("输入:"+(d+i)); System.out.println((d+i) / (h + c)); scanner.close(); } } }}大神写的：package Demo01;import java.util.Scanner;public class D6 { public static void main(String[] args) { //我的项目要求：咱们能够输出多个数字，并求其总和和平均数，每输出一个数字用回车来确定，通过输出非法数字来完结并输入执行后果 Scanner scanner=new Scanner(System.in); double unm=0.0; int i=0; double i1=0; System.out.println("请输出:"); while (scanner.hasNextDouble()){ unm=scanner.nextDouble(); i1=i1+unm; i++; System.out.println("第"+i+"次输入。"); } System.out.println("平均数:"+(i1/i)+"和："+i1); scanner.close(); }}最初欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！ 这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。 ...

明天的知识点 (2021.03.11) —— 第695天 (我也要出题)[html] html中是如何调出QQ会话的？说说你的了解[css] 你有应用过padding-bottom属性吗？说说它的用处[js] 剖析这个2 + - + + + - + 3表达式返回的后果[软技能] 你感觉你明天的面试体现如何？《论语》，曾子曰：“吾日三省吾身”（我每天屡次检查本人）。前端面试每日3+1题，以面试题来驱动学习，每天提高一点！让致力成为一种习惯，让奋斗成为一种享受！置信 保持 的力量！！！欢送在 Issues 和敌人们一起探讨学习！ 我的项目地址：前端面试每日3+1【举荐】欢送跟 jsliang 一起折腾前端，零碎整顿前端常识，目前正在折腾 LeetCode，打算买通算法与数据结构的任督二脉。GitHub 地址 微信公众号欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个Star, 同时欢送微信扫码关注 前端剑解 公众号，并退出 “前端学习每日3+1” 微信群互相交换（点击公众号的菜单：交换）。 学习不打烊，充电加油只为遇到更好的本人，365天无节假日，每天早上5点纯手工公布面试题（死磕本人，愉悦大家）。心愿大家在这虚夸的前端圈里，放弃沉着，保持每天花20分钟来学习与思考。在这变幻无穷，类库层出不穷的前端，倡议大家不要等到找工作时，才狂刷题，提倡每日学习！（不忘初心，html、css、javascript才是基石！）欢送大家到Issues交换，激励PR，感激Star，大家有啥好的倡议能够加我微信一起交换探讨！心愿大家每日去学习与思考，这才达到来这里的目标！！！（不要为了谁而来，要为本人而来！）交换探讨欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个[Star]

明天携程一面，面试官长得挺帅的哈哈哈！ 而后面试官针对我简历中的我的项目问了很多问题！ 还有面试官很喜爱问Redis方面的问题！ 大家增强啦！ 上面是面试的题目！ 补充： 我说我研究生的课题外面有200w的静止传感器数据须要解决，所以本人写了个前后端拆散的分布式我的项目来解决，一方面是为了解决数据，另一方面是测验本人在B站学习的内容。接着我就体现一下本人，讲了这个是三表连贯，而后讲了我如何优化查问，从explain关键字的剖析到依据where 条件中的字段建设索引，让查问工夫胜利降到10s以内显然面试官对我将代码利用到我的项目中很感兴趣，还问我这个我的项目是本人独立实现的还是有团队？我说我静止迷信业余的，四周没有人懂编程，所以是本人一个人搞的。起初面试官还问我，那当数据量达到了千万级别，比方两千万，三千万怎么办，我说我没有实际操作过，然而看到博客说能够采取分库分表的形式。问到我mysql索引的数据结构的时候，我从从B+树和B树之间的比照，到聚簇索引和非聚簇索引的比照，到Innodb和MyISAM的比照，都讲了一圈面试官问我Java线程平安的类时，我从Collections.synchronizedList() 讲到 CopyOnWriteList，到ConcurrentModificationException起初不晓得怎么的一路讲到了AtomicInteger -> UnSafe.getAndInt() -> CAS的思维 -> CAS的毛病 -> ABA问题 -> 用AtomicStampedReference减少版本号进行解决对了面试官还问了我ConcurrentModificationException呈现的业务场景，我因为没有接触过理论业务，我就说了如果一个业务的数据用ArrayList存储的时候，多个用户并发批改的话会呈现这个异样总结： 我在面试外面也有一些问题答不进去，就比方我脑子其实不太好（就是数理逻辑方面转的很慢，然而艺术天才很高哈哈哈，以前学了好多年绘画和音乐），以前数学就学的不好，做算法数据结构的题目对我来说很艰难然而有一些知识性的货色，问到了，我懂，我就致力的讲得又多又深，把握住这个机会！致力的体现本人，这是很重要的！

Java面试总览在金三银四招聘节，简略说说面试的流程。我也做了一个打算，对于面试专题，应该写哪些知识点，以更好帮忙各位同学去温习。首先咱们依照面试的主流程走一下： 面试的次要流程： 自我介绍我的项目介绍技术环节发问环节最重要的2个环节，必定是我的项目介绍和技术环节，怎么说？接着看 我的项目介绍我的项目介绍：考查对业务的了解+表达能力如何 在介绍我的项目时，考查了你对业务的了解，需要是在什么背景下产生的，需要是什么，需要是为了解决什么问题，如何实现需求。咱们把一个需要当作一个点，一个我的项目当作一个线，一个零碎当做一个面。当初咱们每天在做的需要，就是一个性能点，比方业务的CRUD；性能点组合起来就能够形成一条业务线，比方美团外卖的订单模块。业务线组成起来就能够形成一个面，比方美团外卖。个别能够这么了解，P5的同学，每天的工作就是开发性能点，P6的工作就是负责一条业务线，比方：如何把业务线调配给P5的同学开发。而P7，则是架构了，负责整个零碎的架构工作了。 如果咱们想往上爬的话，就不能每天只晓得点，不晓得面。咱们得晓得每个需要背地真正的诉求、真正须要解决的问题。咱们得跳进去，思考一下，做这个性能时，是为了干嘛，得思考一下要解决这个问题，有哪些解决方案。举个例子：当初产品要求在客服零碎的搜寻栏，减少多一个查问条件。最直观的想法就是，进步客服人员的工作效率。再上一层思考的话，原本一个客服1天能解决100个订单，当初减少查问条件后，能让客服1天解决200个订单。公司原本须要一天解决1000个订单，须要10个客服，当初只须要5个客服即可。总的来说，就是为公司节约人力老本。 有的时候，产品经理提了一个需要P，想要解决问题A。比方，需要是要做一个问卷调查性能。如果技术人员不搞清楚考察什么，不问明确考察性能是否只能一次，就间接开干，哐哐哐，加班熬夜一顿干，做了一个问卷调查网站进去。然而，产品最初通知你，这个考察网站，次要用于考察北京的大爷大妈在疫情期间去哪里买菜的。并且只用一次。这个时候，我也不分明你是什么情绪。如果技术人员问分明需要P的真正诉求，就不会那么傻，做一个考察网站进去。咱们永远要明确：技术只是实现业务的一种形式。实现业务，有很多种形式。何况大爷大妈，不肯定都会上网。。。。这个考察北京大爷大妈买菜的状况，间接在小区门口让大爷大妈填一个问卷调查，送一份小礼物就好了。 你看，搞清楚需要的真正诉求是十分重要的。千万别手里拿了个锤子，看到什么都是钉子，也不要刀磨好了，就满世界找猪。 技术环节技术环节：技术广度和深度 这个，考来考去都是那些。无非就是从技术的广度和深度进行考查。我的项目中，以下这些技术，简直都会用到： 分布式，那就会用到RPC开发语言，Java框架，spring存储，Mysql缓存，redis音讯框架，MQ算法，这个本人刷题就好。针对上述技术栈，大头菜会大略出以下面试专题(最初附录) **上述的技术栈中，在广度上，你最起码都要用过，晓得如何应用。在深度上，你最起码要深到看过源码水平，晓得技术的实现原理。** 至于什么计算机网络，计算机组成原理，计算机操作系统这些常识，会考，但问得不多，也不会很深，起码在P6级别，都不会问得很深。计算机网络问来问去都是问TCP三级握手，四次挥手，有事没事问问Http的状态码。这不是温习的重点。或者说，这些书，当初看了，未必能看懂，看懂了后，没能在理论生产环境中应用，而后又忘了。。。 下面的知识点，其实相对来说比拟实践，因为能够在网上看看材料就能够了解明确。但有一些货色，必须要入手实际后，能力在面试上答复得进去。比方，CPU100%，内存溢出，磁盘爆满，IO阻塞。这些货色，如果不真正实战过，基本无从下手。 总结总的来说，对于我的项目的意识如何进步，我最近在看一些产品经理的材料，有须要的小伙伴，找我要。而后对于技术广度和深度的，大头菜会陆续更新文章(随时调整)，以配合各位的温习，但这仅仅适宜面试前温习温习，不适宜零碎学习，毕竟这是一篇文章，比拟碎片化。要零碎学习，还是看书比拟好。最初先恭祝各位小伙伴都能在金三银四拿到大Offer，也心愿我能不偷懒，能放弃日更。 附录MySQL 索引调优数据库整体构造主从复制、读写拆散Java 汇合和容器锁JVM 内存散布构造调优垃圾回收类加载机制Spring refresh()过程如何解决循环依赖？@Autowired等注解的含意和区别SpringBoot和Spring的区别Redis 五种数据结构缓存雪崩 缓存穿透 缓存并发分布式锁 分布式Session布隆过滤器事务哨兵模式、集群AOF和RDBMQ 如何保障音讯不被反复生产如何保障音讯的程序性如果让你写一个音讯队列，如何进行架构设计如何保障音讯队列的高可用如果有上百万音讯继续积压几小时，应如何解决RPC RPC的底层原理动静代理序列化和反序列化NIO通信，这时候又会扯到Netty服务注册核心，Zookeeper

前言一会儿就要办到职手续了，趁着这会儿没啥事，简略写一篇文章，分享一下本人的跳槽教训给大家，心愿能对大家有所帮忙。 个人经历我18年从华北电力大学毕业，毕业之后校招进入一家中小厂，这里就不提名字了。工作了两年多了，这两头负责过独自的我的项目，设计过有深度的技术计划，也干过无脑的CRUD。总的来说这段经验让我播种了很多，让我从一名糊涂无知的学生成长为一个能够扛起事的社会人。因为还没有正式到职，很多货色就不具体说了，简略总结几点这期间的播种：1.积攒很重要从入职的第一天起就应该养成一个积攒笔记的好习惯，比方技术文档、线上问题、技术计划、线上总结、技术分享等等。这些内容的积攒对于本人前面无论是进步工作效率（不走反复的路），还是降职、面试都特地重要。 2.思考很重要,多想想我还能做什么工作之后肯定要养成“实现工作后多想想我还能做点什么”的习惯。需要实现很简略，那就考虑一下能不能加一个降级逻辑让性能更强壮，或者考虑一下除了以后实现计划，业内还有哪些比拟成熟的实现计划，各自的优缺点各是什么等等，总之只有想做能做的事件很多很多。很多人都说本人始终在CRUD，然而到底是你只能CRUD，还是你抉择了CRUD呢，毕竟你做的更好也没有人会批评你。 3.把握住呈现“线上问题”的机会性能做了只是具备了我的项目教训，然而面试的时候真正“值钱”的其实是技术的难点与解决方案，而个别技术难点广泛随同着“线上问题”。所以，平时工作中积极主动点，呈现了线上问题不论是不是本人的都去查、去解决，预先围绕着“问题景象、问题剖析、问题影响、解决方案、问题扩大”等去总结、记录到本人的笔记总，后续都是本人最贵重的财产。 面试教训我是跨语言面的 Java 开发岗，前前后后面了很多一二线互联网公司，其中包含腾讯，阿里，字节、快手、美团、滴滴、微博等等，累计拿到了快手、微博、好将来等大小公司的offer，最初决定去快手了。 上面概括性介绍一下我的面试经验，心愿能对大家换工作的时候有所借鉴。 首先在思考好的确想要跳槽之后，能够从上面这几点着手筹备面试温习： 指标企业工夫节点简历制作面试温习简历内推进行面试拿到offer指标企业如果通过认真思考感觉本人的确想要面试换工作的话，那首先要思考的就是本人的指标企业是什么，是去大公司当螺丝钉、还是去一个中小公司当万金油。 也能够联合本人的畛域常识进行抉择，比方想做视频那就去抖音、快手、视频号，想做物流那就去顺丰、菜鸟、京东物流，想做娱乐内容那就去腾讯、字节、快手、微博，想做教育那就去猿辅导、作业帮、好将来。 工夫节点工夫节点问题，包含面试工夫点、到职工夫点等。 首先是面试工夫点，你抉择不同的工夫节点去面试，拿到offer的难易水平齐全不同。同一个岗位，不同工夫点面试，难度和要求是不一样的，因为这要看缺人的水平和岗位HC的数量。 个别两种状况下比拟容易通过面试拿到offer： 急着招人干活的时候年底坑比拟多的时候先来说说急着招人干活的状况，因为团队招人总是滞后于需要的，所以很多团队总是不定时的会呈现“人不够用”的状况，每当这个时候因为急着找人进来干活所以对应聘者的要求也就没那么高。 再就是年底的时候，因为每年年底各个团队都须要做来年的打算，所以这个时候广泛须要多招一些人进来做更多的事件。再就是年底的时候每个公司为了应答来年可能呈现的人员散失，都会战略性的储备一些人。 所以，综上如果有熟人分割你某个岗位急招人是比拟好的机会，此外就是年底的时候换工作难度绝对会小一些。 如果你抉择了年底到职，这个时候你就须要思考你们公司的年终奖是什么时候发，你在哪个工夫点到职，进而你也就晓得了本人在哪个工夫内面试、拿offer是最划算的了，毕竟进去打工都是为了赚钱，没有情理和钱过不去。 简历制作这部分我举荐一篇阮一峰的文章给大家 以我的项目为主体，设计你的简历 针对企业的须要，突出你的技能 我的项目的三要素（我的项目 = 产品 + 技术 + 后果） 量化你的我的项目，给出数字 简历内推假如此时你曾经有心仪的公司、简历也筹备好了、面试温习也曾经进行的差不多了，那么就能够开始找人内推简历了，然而留神不要一上来就试本人想去的公司（ps：你要是大神就当我没说...），倡议先找两到三个公司试试水，比方你特地想去字节，那就能够先投递一下百度、滴滴、美团，面完之后依据本人的状况是再补救补救本人的有余还是去投递本人想去的公司。 上面再介绍一下具体的内推渠道，一般来说有两个比拟好的内推形式（ps：指的是技术人员）： 熟人内推，分割本人在各个大厂的同学、校友、前共事等等，一般来说熟人的内推品质会比拟高，通过的概率也会大一些。 BOSS直聘，在下面有很多技术leader在找人，个别来找你的都是最近比拟有找人需要的，品质也很高。 进行面试对于进行面试有两点须要留神： 面试工夫，对于像字节、快手这种大小周的公司能够把面试工夫约在周末他们下班的时候，其余的公司能够把面试工夫约在工作日的早晨。 面试节奏，不要短时间内高频面试，面试完须要反思、总结的，短时间高频面试会让你没有工夫思考总结，面试品质没有晋升不说，工夫长了还会让你疲惫不堪，倡议一周以一到两场面试为宜。 拿到offer拿到offer之后次要就是配合背调，确定入职工夫等，最重要的是要记得和上家公司和下家公司别离确定好社保缴纳问题，别断缴。 小结简略介绍了一下过来几年工作中的几点心得，总结了一下过来几个月的面试阶段。 后续还会写一篇文章介绍面试温习的具体内容，比方有哪些比拟举荐的面试内容开源我的项目、我整顿的mysql、redis、kafka等中间件的面试的面试温习笔记、如何通过自我介绍疏导面试官进行发问等等。 可能还会单开一篇文章介绍我是如何从PHP转的Java，讲讲社招如何转语言，说实话都说什么语言都一样，可是我遇到的除了字节之外就没有不看你语言的，所以也想以本人的亲身经历给大家介绍一下这方面如何去筹备。 最初欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！ 这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。

写在后面自己双非本科大三，业余是微电子迷信与工程，学过一点点 Java，我的项目是纯 CRUD 我的项目，未接触过 RPC 我的项目，上面是阿里四个部门的面经，让大佬们见笑了 2.24 淘宝购物车预面 64 min (过)自我介绍 学校的学习和实习的工夫是怎么调配的? 实习的我的项目做了什么?遇到的难点? 在实验室做的我的项目遇到的难点? JPA 和 MyBatis 的区别?讲一下对象字段映射的细节 MySQL 各种索引的一些差别 什么是聚簇索引?什么是非聚簇索引? Innodb 是怎么保障解体恢复能力的?(两阶段日志提交) Innodb的优缺点?(围绕索引数开展讲) 索引笼罩?回表?惟一索引?非惟一索引?最左准则? explain 外面有哪些字段? 一个 SQL 查问很慢,从哪些地方进行优化? 自增 ID 和 UUID 的区别?(叶决裂) 自增 ID 申请完了会产生什么事件? 分库解决了什么问题?分表解决了什么问题? 你感觉学 Java 须要具备哪些根本条件?哪些地方特地重要? 七层网络模型 为什么有了七层还有五层的概念? JVM 内存模型(概述) 讲讲双亲委派,为什么? 你感觉双亲委派这个名字有没有什么问题?你讲讲本人的了解 突破双亲委派的例子,举个例子?怎么突破? 你当初用什么 GC 收集器? Eden 区的对象回收策略? CMS 的 STW 状况? CMS 什么状况会触发 Full GC? 新对象肯定会在新生代 new 进去么? Java8 有什么新的 GC 算法? ...

1、请你谈谈 HashMap 的工作原理 如果被问到 HashMap 相干的问题，它的工作原理都会被作为面试的开场白，这个时候先装作若有所思的样子沉着一下。首先 HashMap 是基于 hashing 的原理，咱们晓得 HashMap 有两个罕用的办法 put()、get()，将键值对传递给 put() 办法时，它调用键对象的 hashCode() 办法来计算 hashcode，而后找到 bucket 地位来贮存值对象。当获取对象时，通过键对象的equals() 办法找到正确的键值对，而后返回值对象。 个别状况下，必定会问如果不同的键对象的 hashcode 值相等会呈现什么样的状况。他们必定是存储在同一个地位的链表中的，应用键对象的 equals() 办法找到键值对。 HashMap + 链表 + 红黑树 的图片援用自 开源中国在 Java1.8 当前，HashMap 在数组、链表的根底上又减少了红黑树的数据结构。在一个数组地位的链表长度大于 8 时数据结构转换为红黑树的构造。 2、HashMap 和 HashTable 的区别有什么？ HashMap 和 HashTable 都实现了 Map 接口，次要的区别集中在线程、同步、速度方面的差异。 HashMap 是非同步的，并且 HashMap 能够存储键值为 null 的对象，容许最多只有一个键能够为 null 对象、容许能够有多个值为 null。HashMap 是线程不平安的，HashTable 是线程平安的。因为 HashTable 是多线程的，所以在单线程的状况下，HashMap 的速度要快一些。HashMap 不能保障存储程序是不变的。3、HashMap 和 HashSet 的区别有什么？ 两者实现的接口不一样，HashMap 实现的是 Map 接口、HashSet 则实现的是 Set 接口。HashMap 存储的是键值对、HashSet 存储的是对象。HashSet 的速度比 HashMap 的要慢一些。计算 hashcode 值的形式不一样，HashMap 应用键对象来计算、HashSet 应用它自身的对象元素来计算。4、当两个对象的 HashCode 雷同会产生什么？ ...

大家好，我是林一一，上面这篇文章是无关 JS 闭包概念和经典应用场景和必刷题的文章，让咱们开始浏览吧????举荐浏览地址掘金浏览地址 思维导图 闭包理解闭包前先来理解一下下级作用域和堆栈内存开释问题。下级作用域的概念函数的下级作用域在哪里创立创立的，下级作用域就是谁var a = 10function foo(){ console.log(a)}function sum() { var a = 20 foo()}sum()/* 输入 10/函数 foo() 是在全局下创立的，所以 a 的下级作用域就是 window，输入就是 10思考题var n = 10function fn(){ var n =20 function f() { n++; console.log(n) } f() return f}var x = fn()x()x()console.log(n)/* 输入* 21 22 23 10/思路：fn 的返回值是什么变量 x 就是什么，这里 fn 的返回值是函数名 f 也就是 f 的堆内存地址，x() 也就是执行的是函数 f()，而不是 fn()，输入的后果不言而喻对于如何查找下级作用域参考：彻底解决 JS 变量晋升的面试题JS 堆栈内存开释堆内存：存储援用类型值，对象类型就是键值对，函数就是代码字符串。堆内存开释：将援用类型的空间地址变量赋值成 null，或没有变量占用堆内存了浏览器就会开释掉这个地址栈内存：提供代码执行的环境和存储根本类型值。栈内存开释：个别当函数执行完后函数的公有作用域就会被开释掉。但栈内存的开释也有非凡状况：① 函数执行完，然而函数的公有作用域内有内容被栈外的变量还在应用的，栈内存就不能开释外面的根本值也就不会被开释。② 全局下的栈内存只有页面被敞开的时候才会被开释闭包是什么在 JS 忍者秘籍(P90)中对闭包的定义：闭包容许函数拜访并操作函数内部的变量。红宝书上对于闭包的定义：闭包是指有权拜访另外一个函数作用域中的变量的函数。MDN 对闭包的定义为：闭包是指那些可能拜访自在变量的函数。这里的自在变量是内部函数作用域中的变量。概述下面的话，闭包是指有权拜访另一个函数作用域中变量的函数 ...

很多小伙伴问我进大厂到底须要怎么的技术能力，趁着年假，通过几天的思考和总结，终于梳理出一份绝对比拟残缺的技能清单，小伙伴们能够对照清单提前准备相干的技能，在平时的工作中留神积攒和总结。只有在平时的工作中总结到位，对技术知其然，知其所以然，进大厂，是瓜熟蒂落的事件。接下来，我就简略的列举下，在我集体看来，进大厂须要的一些技能。当然，这次次要说的是Java技术栈。 一.常见模式与工具学习Java技术体系，设计模式，风行的框架与组件—— 常见的设计模式，编码必备， Spring5，做利用必不可少的最新框架，MyBatis，玩数据库必不可少的组件...... 二.工程化与工具工欲善其事必先利其器，不论是小白，还是资深开发，玩Java技术体系，抉择好的工具，晋升开发效率和团队合作效率，是必不可少的： 三.分布式架构高并发，高可用，海量数据，没有分布式的架构常识必定是玩不转的： 四.微服务架构业务越来越简单，服务分层，微服务架构是架构降级的必由之路，Java技术体系，和微服务相干的技术有哪些呢？ 五.性能优化任何脱离细节的ppt架构师都是耍流氓，向上能指挥若定，向下能解决一线性能问题，Java技术体系，须要理解： 六.底层常识从架构设计，到应用层调优，再深刻理解底层原理，扎实的Java基本功能力让本人变为扫地神僧： 七.我的项目实战无需赘述，如果没有实战经验，如何成为一名架构师？心愿冰河总结的这份进大厂的清单可能为小伙伴们带来实质性的帮忙，祝各位小伙伴可能早日进入本人心仪的大厂。 好了，明天就到这儿吧，我是冰河，咱们下期见~~

举荐浏览：对于iOS面试题汇总(栏目继续更新) 各位最近应该忙于跳槽与面试吧，毕竟金三银四，珍惜好机会，预祝大家面试顺利通过，迎接大厂offer。有须要材料能够私聊我理解 从输出url到页面展现到底产生了什么1、输出地址2、浏览器查找域名的 IP 地址　3、浏览器向 web 服务器发送一个 HTTP 申请4、服务器的永恒重定向响应5、浏览器跟踪重定向地址6、服务器解决申请7、服务器返回一个 HTTP 响应　8、浏览器显示 HTML9、浏览器发送申请获取嵌入在 HTML 中的资源（如图片、音频、视频、CSS、JS等等）iOS高频(根底+底层)面试题你在开发过程中罕用到哪些定时器，定时器工夫会有误差吗，如果有，为什么会有误差？　iOS中常NSTimer、CADisplayLink、GCD定时器，其中NSTimer、CADisplayLink基于NSRunLoop实现，故存在误差，GCD定时器只依赖零碎内核，绝对一前两者是比拟准时的。 误差起因是：与NSRunLoop机制无关， 因为RunLoop每跑完一次圈再去查看以后累计工夫是否曾经达到定时设置的间隔时间，如果未达到，RunLoop将进入下一轮工作，待工作完结之后再去查看以后累计工夫，而此时的累计工夫可能曾经超过了定时器的间隔时间，故会存在误差。 block是类吗，有哪些类型?block也算是个类,因为它有isa指针,block.isa的类型包含 _NSConcreteGlobalBlock 跟全局变量一样,设置在程序的数据区域(.data)中_NSConcreteStackBlock栈上(后面讲的都是栈上的 block)_NSConcreteMallocBlock 堆上这个isa能够按位运算block的分类，__block的作用,block循环援用产生的起因及解决办法blcok分为全局blcok，堆block，栈block。在 MRC下:只有没有拜访内部变量，就是全局block。拜访了内部变量，就是栈block。显示地调用[block copy]就是堆block。在 ARC下:只有没有拜访内部变量，就是全局block。如果拜访了内部变量，那么在拜访内部变量之前存储在栈区，拜访内部变量之后存储在堆区。__block的作用:将内部变量的传递模式由值传递变为指针传递，从而能够获取并且批改内部变量的值。同样，内部变量的批改，也会影响block函数的输入。block循环援用问题：当一个类的对象持有block，block外面又援用了这个对象，那么就是一个循环援用的关系。能够用strong-weak-dance的办法解除循环援用。浅复制和深复制的区别？答案：浅层复制：只复制指向对象的指针，而不复制援用对象自身。深层复制：复制援用对象自身。意思就是说我有个A对象，复制一份后失去A_copy对象后，对于浅复制来说，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象自身资源还是只有一份，那如果咱们对A_copy执行了批改操作,那么发现A援用的对象同样被批改，这其实违反了咱们复制拷贝的一个思维。深复制就好了解了,内存中存在了两份独立对象自身。用网上一哥们艰深的话将就是：浅复制好比你和你的影子，你完蛋，你的影子也完蛋深复制好比你和你的克隆人，你完蛋，你的克隆人还活着。 有想要支付收费材料的能够进裙或者加好友支付，这里有一个iOS交换圈：891 488 181 能够来理解，分享BAT,阿里面试题、面试教训，探讨技术，裙里材料间接下载就行， 大家一起交流学习！类别的作用？继承和类别在实现中有何区别？答案：category 能够在不获悉，不扭转原来代码的状况下往里面增加新的办法，只能增加，不能删除批改。并且如果类别和原来类中的办法产生名称抵触，则类别将笼罩原来的办法，因为类别具备更高的优先级。类别次要有3个作用：(1)将类的实现扩散到多个不同文件或多个不同框架中。(2)创立对公有办法的前向援用。(3)向对象增加非正式协定。 继承能够减少，批改或者删除办法，并且能够减少属性。 oc中的协定和java中的接口概念有何不同？答案：OC中的代理有2层含意，官网定义为 formal和informal protocol。前者和Java接口一样。informal protocol中的办法属于设计模式思考领域，不是必须实现的，然而如果有实现，就会扭转类的属性。其实对于正式协定，类别和非正式协定我很早前学习的时候大抵看过，也写在了学习教程里“非正式协定概念其实就是类别的另一种表达方式“这里有一些你可能心愿实现的办法，你能够应用他们更好的实现工作”。这个意思是，这些是可选的。比方我门要一个更好的办法，咱们就会申明一个这样的类别去实现。而后你在前期能够间接应用这些更好的办法。这么看，总感觉类别这玩意儿有点像协定的可选协定。"当初来看，其实protocal曾经开始对两者都对立和标准起来操作，因为材料中说“非正式协定应用interface润饰“，当初咱们看到协定中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。 oc中可批改和不能够批改类型。答案：可批改不可批改的汇合类。这个我集体简略了解就是可动静增加批改和不可动静增加批改一样。比方NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够增加等，能够动静申请新的内存空间。 对于多态性答案：多态，子类指针能够赋值给父类。这个题目其实能够出到所有面向对象语言中，因而对于多态，继承和封装根本最好都有个自我意识的了解，也并非肯定要把书上材料上写的能背进去。最重要的是转化成自我了解。 告诉和协定的不同之处？答案：协定有管制链(has-a)的关系，告诉没有。首先我一开始也不太明确，什么叫管制链（专业术语了~）。然而简略剖析下告诉和代理的行为模式，咱们大抵能够有本人的了解简略来说，告诉的话，它能够一对多，一条音讯能够发送给多个音讯接受者。代理按咱们的了解，到不是间接说不能一对多，比方咱们晓得的明星经济代理人，很多时候一个经济人负责好几个明星的事务。只是对于不同明星间，代理的事物对象都是不一样的，一一对应，不可能说今天要解决A明星要一个发布会，代理人收回解决发布会的音讯后，别称B的发布会了。然而告诉就不一样，他只关怀发出通知，而不关怀多少接管到感兴趣要解决。因而管制链（has-a从英语单词大抵能够看出，繁多领有和可管制的对应关系。 线程和过程的区别？1> 一个应用程序对应一个过程，一个过程帮忙程序占据一块存储空间 2> 要想在过程中执行工作，就必须开启线程，一条线程就代表一个工作 3> 一个过程中容许开启多条线程，也就是同时执行多个工作 Objective-C如何对内存治理的,说说你的认识和解决办法?1> 每个对象都有一个援用计数器，每个新对象的计数器是1，当对象的计数器减为0时，就会被销毁 2> 通过retain能够让对象的计数器+1、release能够让对象的计数器-1 3> 还能够通过autorelease pool治理内存 如果用ARC，编译器会主动生成治理内存的代码 堆和栈的区别？1> 堆空间的内存是动态分配的，个别寄存对象，并且须要手动开释内存 2> 栈空间的内存由零碎主动调配，个别寄存局部变量等，不须要手动治理内存 为什么很多内置的类，如TableView的delegate的属性是assign不是retain？1> tableView的代理个别都是它所属的控制器，控制器会对它外部的view做一次retain操作 2> 假如tableView也对代理（控制器）做一次retain操作，那么就呈现循环retain问题 定义属性时，什么状况应用copy、assign、retain？1> copy：NSString、Block等类型 2> assign：根本数据类型 3> retain：OC对象类型 ...

作者：小傅哥博客：https://bugstack.cn 积淀、分享、成长，让本人和别人都能有所播种！????一、前言最近给大家整顿一些面试现场，实在的面试题和答案以及总结 尽管技术的知识点是固定的，但不同大厂不同面试官的发问形式却不一样。一方面是你的简历的内容影响，另外一方面是受面试官的个人经历导致。最终就看你们是否对脾气了，如果不对换个部门从新投 但如果你能把一个知识点真的搞懂，是真的懂。那么，无论面试官怎么问，其实都能答复的很精彩，精彩决定了你的职位和薪资。 为了让大家在当前的面试中都能精彩，像秀一样，特此筹备整顿一些实在的面试现场分享给大家，心愿对每一个求职时都有帮忙。不过这些都是底层技术的学习帮忙，如果你心愿本人更牛，那么要多学习、多积攒！ 如果本文波及的 Java 核心内容不能很好的了解，能够浏览小傅哥的《Java 面经手册》，全书共5章29节，417页11.5万字，耗时4个月实现。涵盖数据结构、算法逻辑、并发编程、JVM以及简历和互联网大厂面试等内容。同时此书并不是单纯的面试题，也不是内卷八股文。而是从一个单纯的和程序员无关的数学知识点开始，深刻解说 Java 的核心技术。 二、面试现场 背景 小伙伴面的是美团，求职方向是团队技术负责人。此次面试以连环诘问的形式为主，喜爱刨根问底，十分考研面试者的技术功底。以下是整顿出的局部面试题，咱们看看这些题该如何答复。 先让写个线程平安的单例模式public class Singleton { private static volatile Singleton instance; private Singleton() { } public static Singleton getInstance(){ if(null != instance) return instance; synchronized (Singleton.class){ if (null == instance){ instance = new Singleton(); } } return instance; }}考查线程平安的单例模式，一方面是对根底的理解，另一方面以单例模式作为入口考查并发编程的知识点。在这里你要晓得，并发编程的三要素包含：原子性、可见性、有序性。那具备三要素知识点的单例模式，次要是如上案例中的双重查看锁和CAS忙等策略。而双重查看锁的单例形式，对于面试官和求职者来说，能够往下持续聊的点就有了。当然，如果你没有写出这样一种单例模式，大概率会被面试官疏导过去。在面试的过程中最好的形式是被动和疏导面试官走，也称对脾气，也就是技术臭味相投的感觉。高并发下，单例模式会存在哪些问题？单例模式就是以避免线程不平安和进步代码执行效率而设计的。双重锁定查看(DCL，Double Check Lock)，也就是为此设计的。别被 DCL 唬住喽可见性和指令重排是怎么回事？可见性，Java 编程语言容许线程访问共享变量，为了确保共享变量能被精确和统一地更新，线程应该确保通过排它锁独自取得这个变量。指令重排，在程序执行过程中为了性能思考,，编译器和 CPU 可能会对指令从新排序。对于并发多线程场景下，指令重排会产生不确定的执行成果。voliate 关键字为什么能够解决可见性和指令重排？可见性 首选，volatile 关键字润饰的共享变量能够提供这种可见性标准，也叫做读写可见。被 volatile 关键字润饰的共享变量在转换成汇编语言时，会加上一个以 lock 为前缀的指令，当CPU发现这个指令时，立刻将以后内核高速缓存行的数据回写到内存，同时使在其余内核里缓存了该内存地址的数据有效。另外，在晚期的 CPU 中，是通过在总线加 LOCK# 锁的形式实现的，但这种形式开销较大。所以Intel开发了缓存一致性协定，也就是 MESI 协定，该解决缓存一致性。volatile 的益处，volatile 是一种非锁机制，这种机制能够防止锁机制引起的线程上下文切换和调度问题。所以，volatile 的执行老本比 synchronized 更低。volatile 的有余，volatile 关键字只能保障可见性，不能保障原子性操作。此外如果你还能答复出，Unsafe.loadFence(); 保障在这个屏障之前的所有读操作都曾经实现。的一些应用，那么面试相对能够加分。指令重排 ...

面向对象的特色有哪些方面？① 形象：形象分为数据抽象和过程形象两方面。数据抽象：针对对象的属性，比方建设一个鸟这样的类，鸟会有以下特色，两个翅膀，两支脚，有羽毛等等个性，写成类都是鸟的属性过程形象：针对对象的行为特色，比方鸟会飞，会跳等等，这些方面的就会形象为办法，即过程，写成类都是鸟的办法② 继承：继承是从已有类失去继承信息创立新类的过程③ 封装：封装是把数据和操作数据的办法绑定起来，对数据的拜访只能通过已定义的接口。④ 多态：多态是同一个行为具备多个不同表现形式或状态的能力（办法的重写） 拜访修饰符public,private,protected(不写修饰符默认只能同一包下拜访) 根本数据类型字符类型：byte，char根本整型：short，int，long浮点型：float，double布尔类型：booleanps: String不是根本数据类型，是final润饰的java类 精度失落问题(如何断定单双精度)float: float f = 3.4是否正确不正确。3.4是双精度，将双精度型（double）赋值给单精度型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因而须要强制类型转换float f =(float)3.4; 或者写成float f =3.4F。 double: 为了避免double精度失落问题，能够应用java.math包中提供的API类BigDecimal用来对超过16位无效位的数进行准确的运算。双精度浮点型变量double能够解决16位无效数。double a = 1;double b = 20.2;double c = 300.02;BigDecimal a1 = new BigDecimal(Double.toString(a));BigDecimal b1 = new BigDecimal(Double.toString(b));BigDecimal c1 = new BigDecimal(Double.toString(c));double result = (a1.add(b1).add(c1)).doubleValue();System.out.println(result);int和Integer有什么区别Java是一个近乎纯净的面向对象编程语言，然而为了编程的不便还是引入了根本数据类型，然而为了可能将这些根本数据类型当成对象操作，Java为每一个根本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了主动装箱/拆箱机制，使得二者能够互相转换。 class 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比拟 }}| 和 ||，& 和 && 的区别|| 和 && 定义为逻辑运算符，而 | 和 & 定义为位运算符&& 如果两个操作数都非零，则条件为真；|| 如果两个操作数中有任意一个非零，则条件为真。& 按位与操作，按二进制位进行"与"运算。运算规定：（有 0 则为 0）0&0=0; 0&1=0; 1&0=0; 1&1=1;| 按位或运算符，按二进制位进行"或"运算。运算规定：（有 1 则为 1） ...

效率条款16：谨记80-20法令80-20法令说：一个程序80%的资源用于20%的代码身上。是的。80%的执行工夫花在大概20%的代码身上，80%的内存被大概20%的代码应用，80%的磁盘拜访动作由20%的代码执行，80%的保护力量花在20%的代码下面。不用拘泥于法令的数字，其根本重点是：软件的整体性能简直总是由其形成因素（代码）的一小部分决定。从某个角度看，80-20法令暗示，大部分时候你所产出的代码，其性能坦白说是平庸的，因为80%的工夫中，其效率不会影响零碎整体性能。或者这不至于对你的自尊心造成太大打击，但应该多少会升高你的压力。从另一个角度看，这个法令暗示，如果你的软件有性能上的问题，你将面临悲惨的前景，因为你不只须要找出造成问题的那一小段瓶颈所在，还必须找出方法来大幅晋升其性能。这些工作中，最麻烦的还是找出瓶颈所在。找性能瓶颈的办法不能靠猜。可行之道是齐全依据察看或试验来辨认出造成你心痛的那20%代码。而辨识之道就是借助某个程序分析器。然而并不是任何分析器都足堪大任，它必须能够间接测量你所在意的资源。条款17：思考应用lazy evaluation（缓式评估）一旦你采纳lazy evaluation，就是以某种形式撰写的你classes，使它们延缓运算，直到那些运算后果迫不及待地被迫切需要为止。如果其估算后果始终不被须要，运算也就始终不执行。lazy evaluation在许多畛域中都可能有用处：可防止非必要的对象复制，可区别operator[]的读取和写动作，可防止非必要的数据库读取动作，可防止非必要的数值计算动作。条款18：分期摊还预期的计算成本此条款背地的哲学可称为超急评估（over-eager evaluation）：在被要求之前就先把事件做上来。over-eager evaluation背地的观点是，如果你预期程序经常会用到某个计算，你能够升高每次计算的均匀老本，方法就是设计一份数据结构以便可能极有效率地解决需要。其中个最简略的一个做法就是将“曾经计算好而有可能再被须要”的数值保留下来（所谓caching）。另一种做法则是事后取出（prefetching）。prefetching的一个典型例子就是std的vector数组扩张的内存调配策略（每次扩充两倍）。条款17和18看似矛盾，理论都体现了计算机中一个古老的思维：用空间换工夫。联合起来看，它们是不矛盾的。当你必须反对某些运算而其后果并不总是须要的时候，lazy evaluation能够改善程序效率。当你必须反对某些运算而其后果简直总是被须要，或其后果经常被屡次须要的时候，over-eager evaluation能够改善程序效率。条款19：理解长期对象的起源C++真正的所谓的长期对象时不可见的——不会在你的源代码中呈现。只有你产生一个non-heap object而没有为它命名，便诞生了一个长期对象。此等匿名对象通常产生于两种状况：一是当隐式类型转换被实施起来以求函数调用可能胜利；二是当函数返回对象的时候。任何时候只有你看到一个reference-to-const参数，就极可能会有一个长期对象被产生进去绑定至该参数上。任何时候只有你看到函数返回一个对象，就会产生长期对象（并于稍后销毁）。学些找出这些架构，你对幕后老本（编译器行为）的洞察力将会有显著地晋升。条款20：帮助实现“返回值优化（RVO）”如果函数肯定得以by-value形式返回对象，你相对无奈打消之。从效率的眼光来看，你不应该在乎函数返回了一个对象，你应该在乎的是那个对象的老本几何。你须要做的，是致力找出某种办法以升高被返回对象的老本，而不是想尽办法打消对象自身。咱们能够用某种非凡写法来撰写函数，使它在返回对象时，可能让编译器打消长期对象的老本。咱们的手腕是：返回所谓的constructor arguments以取代对象。思考分数（rational numbers）的operator*函数，一个有效率而且正确的做法是：const Rational operator*(const Rational& lhs, const Rational& rhs){ return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());}C++容许编译器将长期对象优化，使它们不存在。于是如果你这样调用operator*：Rational a = 10;Rational b(1,2);Rational c = a * b;你的编译器得以打消“operator*内的长期对象”及“被operator*返回的长期对象”。它们能够将return表达式所定义的对象结构于c的内存内。你能够将此函数申明为inline，以打消调用operator*所破费的额定开销。这就是返回一个对象最有效率的做法。条款21：利用重载技术（overload）防止隐式类型转换（implicit type conversions）思考以下代码：class UPInt { // 这个class用于有限精细的整数plublic: UPInt(); UPInt(int value); ...};const UPInt operator+(const UPInt& lhs, const UPInt& rhs);UPInt upi1, upi2;...UPInt upi3 = upi1 + upi2;upi3 = upi1 + 10;upi3 = 10 + upi2;因为有隐式转换，所以以上语句都能执行胜利。但这样执行会产生长期对象，这对执行效率是有影响的。如果有其余做法能够让operator+在自变量类型混淆的状况下呗调用胜利，那便打消了了类型学转换的需要。如果咱们心愿可能对UPInt和int进行加法，咱们须要做的就是将咱们的用意通知编译器，做法是申明数个函数，每个函数有不同的参数表：const UPInt operator+(const UPInt& lhs, const UPInt& rhs); // 将UPInt和UPInt相加const UPInt operator+(const UPInt& lhs, const int& rhs); // 将UPInt和int相加const UPInt operator+(const int& lhs, const UPInt& rhs); // 将int和UPInt相加然而不要写出以下函数：const UPInt operator+(const int& lhs, const int& rhs);因为，C++存在很多游戏规则，其中之一就是：每个“重载操作符”必须取得至多一个“用户定制类型”的自变量。int不是用户定制类型，所以咱们不可能将一个只取得int自变量的操作符加以重载，这会扭转ints的加法意义。条款22：思考以操作符复合模式（op=）取代其单身模式（op）要确保操作符的复合模式（例如，operator+=）和其单身模式（例如，operator+）之间的天然关系可能存在，一个好办法就是以前者为根底实现后者：const Rational operator+(const Rational& lhs, const Rational& rhs){ return Rational(lhs) += rhs;}一般而言，复合操作符比其对应的单身版本效率高，因为单身版本通常必须返回一个新对象，而咱们必须因而累赘一个长期对象的结构和析形成本。至于复合版本则是间接将后果写入其左端自变量，所以不须要产生一个长期对象来搁置返回值。操作符我复合版本比其对应的单身版本有着更高效率的偏向。身为一位程序库设计者，你应该两者都提供；身为一位应用软件开发者，如果性能是重要因素的话，你应该思考以复合版本操作符取代其单身版本。条款23：思考应用其余程序库不同的设计者面对不同的个性会给予不同的优先权。他们的设计各有不同的就义。于是，很容易呈现“两个程序库提供相似机能，却又相当不同的性能体现”的状况。所以一旦你找出程序的性能瓶颈（通过分析器），你应该思考是否有可能因为改用另一个程序库而移除了那些瓶颈。条款24：理解virtual functions、multiple inheritance、virtual base classes、runtime type identification的老本虚函数的第一个老本：你必须为每个领有虚函数的class消耗一个vtbl空间，其大小视虚函数的个数（包含继承而来的）而定。虚函数的第二个老本：你必须在每一个领有虚函数的对象内付出“一个额定指针”的代价。inline意味着在编译期将调用端的调用动作被调用函数的函数本体取代，而virtual则意味着直到运行期才直到哪个函数被调用。因而虚函数的第三个老本就是：你事实上等于放弃了inlining。多重继承往往导致virtual base classes（虚构基类）的需要。virtual base classes可能导致对象内的暗藏指针减少。RTTI让咱们得以在运行期取得objects和classes的相干信息，它们本寄存在类型为type_info的对象内。你能够利用typeid操作符获得某个class相应的type_info对象。RTTI的设计理念是：依据class的vtbl来实现。举个例子，vtbl数组中，索引为0的条目可能内含一个指针，指向“该vtbl所对应的class”的相应的type_info对象。使用这种实现办法，RTTI的空间老本就只需在每一个class vtbl内减少一个条目，再加上每个class所需的一份type_info对象空间。

在面试当中，有时候会问到你在我的项目中用过多线程么？ 对于一般的应届生或者工作工夫不长的高级开发 ？？？—— crud仔流下了没有技术的眼泪。 博主这里整顿了我的项目中用到了多线程的一个简略的实例，心愿能对你有所启发。 多线程开发实例利用背景利用的背景非常简单，博主做的我的项目是一个审核类的我的项目，审核的数据须要推送给第三方监管零碎，这只是一个很简略的对接，然而存在一个问题。 咱们须要推送的数据大略三十万条，然而第三方监管提供的接口只反对单条推送（别问为什么不反对批量，问就是没讨撕论比好过）。能够估算一下，三十万条数据，一条数据按3秒算，大略须要250（为什么恰好会是这个数）个小时。 所以就思考到引入多线程来进行并发操作，升高数据推送的工夫，进步数据推送的实时性。 设计要点避免反复咱们推送给第三方的数据必定是不能反复推送的，必须要有一个机制保障各个线程推送数据的隔离。 这里有两个思路： 将所有数据取到汇合（内存）中，而后进行切割，每个线程推送不同段的数据利用 数据库分页的形式，每个线程取 [start,limit] 区间的数据推送，咱们须要保障start的一致性这里采纳了第二种形式，因为思考到可能数据量后续会持续减少，把所有数据都加载到内存中，可能会有比拟大的内存占用。 失败机制咱们还得思考到线程推送数据失败的状况。 如果是本人的零碎，咱们能够把多线程调用的办法抽出来加一个事务，一个线程异样，整体回滚。 然而是和第三方的对接，咱们都没法做事务的，所以，咱们采纳了间接在数据库记录失败状态的办法，能够在前面用其它形式解决失败的数据。 线程池抉择在理论应用中，咱们必定是要用到线程池来治理线程，对于线程池，咱们罕用 ThreadPoolExecutor提供的线程池服务，SpringBoot中同样也提供了线程池异步的形式，尽管SprignBoot异步可能更不便一点，然而应用ThreadPoolExecutor更加直观地控制线程池，所以咱们间接应用ThreadPoolExecutor构造方法创立线程池。 大略的技术设计示意图： 外围代码下面叭叭了一堆，到了show you code的环节了。我将我的项目里的代码抽取进去，简化出了一个示例。 外围代码如下： /** * @Author 三分恶 * @Date 2021/3/5 * @Description */@Servicepublic class PushProcessServiceImpl implements PushProcessService { @Autowired private PushUtil pushUtil; @Autowired private PushProcessMapper pushProcessMapper; private final static Logger logger = LoggerFactory.getLogger(PushProcessServiceImpl.class); //每个线程每次查问的条数 private static final Integer LIMIT = 5000; //起的线程数 private static final Integer THREAD_NUM = 5; //创立线程池 ThreadPoolExecutor pool = new ThreadPoolExecutor(THREAD_NUM, THREAD_NUM * 2, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(100)); @Override public void pushData() throws ExecutionException, InterruptedException { //计数器，须要保障线程平安 int count = 0; //未推送数据总数 Integer total = pushProcessMapper.countPushRecordsByState(0); logger.info("未推送数据条数：{}", total); //计算须要多少轮 int num = total / (LIMIT * THREAD_NUM) + 1; logger.info("要通过的轮数:{}", num); //统计总共推送胜利的数据条数 int totalSuccessCount = 0; for (int i = 0; i < num; i++) { //接管线程返回后果 List<Future<Integer>> futureList = new ArrayList<>(32); //起THREAD_NUM个线程并行查问更新库，加锁 for (int j = 0; j < THREAD_NUM; j++) { synchronized (PushProcessServiceImpl.class) { int start = count * LIMIT; count++; //提交线程，用数据起始地位标识线程 Future<Integer> future = pool.submit(new PushDataTask(start, LIMIT, start)); //先不取值，避免阻塞,放进汇合 futureList.add(future); } } //统计本轮推送胜利数据 for (Future f : futureList) { totalSuccessCount = totalSuccessCount + (int) f.get(); } } //更新推送标记 pushProcessMapper.updateAllState(1); logger.info("推送数据实现，需推送数据:{},推送胜利：{}", total, totalSuccessCount); } /** * 推送数据线程类 */ class PushDataTask implements Callable<Integer> { int start; int limit; int threadNo; //线程编号 PushDataTask(int start, int limit, int threadNo) { this.start = start; this.limit = limit; this.threadNo = threadNo; } @Override public Integer call() throws Exception { int count = 0; //推送的数据 List<PushProcess> pushProcessList = pushProcessMapper.findPushRecordsByStateLimit(0, start, limit); if (CollectionUtils.isEmpty(pushProcessList)) { return count; } logger.info("线程{}开始推送数据", threadNo); for (PushProcess process : pushProcessList) { boolean isSuccess = pushUtil.sendRecord(process); if (isSuccess) { //推送胜利 //更新推送标识 pushProcessMapper.updateFlagById(process.getId(), 1); count++; } else { //推送失败 pushProcessMapper.updateFlagById(process.getId(), 2); } } logger.info("线程{}推送胜利{}条", threadNo, count); return count; } }}代码很长，咱们简略说一下要害的中央： ...

问题： 找第 K 大的数 在一个数组里在数据流中找最大的 K 个数 在一个数组里在数据流中找呈现频率最高的 K 个数 在一个数组中在数据流中在文件中这种题适宜各种follow up 核实问题：是否须要准确的后果？数据是离线的(文件模式计算一次失去一个后果)还是在线的(数据流可有限次查问实时后果)？ -问题1 - 找第 K 大的数： 在一个整数数组中，找第 K 大的数 [Leetcode题目]解法1: 快排整个数组 O(nlogn)解法2: 快选第K大 O(n) + 快排前k项 O(klogk) = O(n + klogk) 在一个数据流中，找第 K 大的数 [Leetcode题目]解法: 最小堆，最小堆的堆顶就是第 K 大的数，插入O(lgk), 查问O(1) -问题2 - 找最大的 K 个数： 在一个整数数组中，找最大的 K 个数解法：同问题1.1解答 在一个数据流中，找最大 K 个数解法: 同问题1.2解答，插入O(lgk), 如果查问不须要放弃程序，则O(n)，能够用java的iterator实现；如果查问须要放弃程序，则先无序的拿出，而后排序，即O(klgk) 问题3 - 找最高频的 K 个数

List汇合java.util.List接口extends Collection接口 List接口的特点：有序的汇合，存储元素和取出元素的程序是统一的有索引，蕴含了一些带索引的办法容许存储反复的元素List接口中带索引的办法（特有）public void add(int index, E element); 将指定的元素，增加到该汇合中的指定地位上。public E get(int index); 返回汇合中指定地位的元素。public E remove(int index); 移除列表中指定地位的元素，返回的是被移除的元素。public E set(int index, E element); 用指定元素替换汇合中指定地位的元素，返回值 更新前的元素。留神：操作索引的时候，肯定要避免索引越界异样。 public static void main(String[] args) { //创立一个List汇合对象，多态 List<String> list = new ArrayList<>(); //应用add办法往汇合里增加元素 list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("a"); System.out.println(list); // public void add(int index, E element); 将指定的元素，增加到该汇合中的指定地位上。 //在c和d之间增加DNA list.add(3, "DNA"); System.out.println(list); //public E remove(int index); 移除列表中指定地位的元素，返回的是被移除的元素。 //移除c元素 String removeE = list.remove(2); System.out.println("被移除的元素：" + removeE); System.out.println(list); //public E set(int index, E element); 用指定元素替换汇合中指定地位的元素，返回值 更新前的元素。 //把最初一个a替换成A String setE = list.set(4, "A"); System.out.println("被替换的元素：" + setE); System.out.println(list); //List汇合遍历有三种形式 //应用一般的for循环 for (int i = 0; i < list.size(); i++) { //public E get(int index); 返回汇合中指定地位的元素。 String s = list.get(i); System.out.println(s); } System.out.println("--------------------"); //应用迭代器 Iterator<String> it = list.iterator(); while (it.hasNext()) { String str = it.next(); System.out.println(str); } System.out.println("--------------------"); //应用加强for for (String s : list) { System.out.println(s); } }-----------------------------------------------------------------------------------------------------------------[a, b, c, d, a][a, b, c, DNA, d, a]被移除的元素：c[a, b, DNA, d, a]被替换的元素：a[a, b, DNA, d, A]abDNAdA--------------------abDNAdA--------------------abDNAdALinkedListjava.util.LinkedList汇合implements List接口LinkedList汇合的特点： ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 网络申请，协定介绍下网络协议分层？OSI七层模型： TCP/IP 四层模型： 参考资料： 网络原理（一）——协定分层 put,patch,post区别？相同点：三个都是用于批改申请 不同点： put 与 post 区别 put：等幂性，间断调用一次/屡次成果雷同，无副作用; 应用场景：批改用户名接口, 提交屡次，后果也是一样的;post：是非幂等性的，创立博客接口，屡次提交创立多个put 与 patch区别 put：间接资源笼罩型的应用put, 比方分销模块化接口；patch: 对已知文件进行部分更新，比方批改用户名；常见的网络协议有哪些？HTTP协定: 超文本传输协定，规定了浏览器和万维网服务器相互通信的规定。应用：浏览网页，网页下载FTP协定：文件传输协定。应用：FTP服务端上传软件SMTP协定：简略邮件传输协定，在其之上指定了一条音讯的一个或多个接收者，而后音讯文本会被传输。应用：foxmailNFS协定：网络文件系统，文件共享的协定。用户和程序能够像拜访本地文件一样拜访远端系统文件。应用：Linux搭建网盘UDP协定：用户数据报协定，反对多方数据传输 应用：DNS ，QQTCP/IP协定：传输控制协议，每一条TCP只能点对点传输 应用：http底层技术，QQ（（UDP协定为主，TCP协定为辅助），websocketTelnet协定：远程登陆，应用明文传输数据，有一些平安问题，缓缓被淘汰。连贯客户端举荐应用SSH协定参考资料：几种常见的网络协议 UDP与TCP的区别？UDP协定：无连贯，尽最大可能交传，没有拥塞管制、面向报文，反对一对一，一对多，多对多交互通信。 TCP协定：面向连贯，提供牢靠交付，有流量管制，拥塞管制，提供全工管制，面向节节流，每一条TCP连贯只能点对点的（一对一） 参考资料：一文搞定 UDP 和 TCP 高频面试题！ ajax 过程？(1)创立XMLHttpRequest对象,也就是创立一个异步调用对象. (2)创立一个新的HTTP申请,并指定该HTTP申请的办法、URL及验证信息. (3)设置响应HTTP申请状态变动的函数. (4)发送HTTP申请. (5)获取异步调用返回的数据. (6)应用JavaScript和DOM实现部分刷新. DNS解析过程，及优化计划？定义：通过域名解析找到服务器主机IP地址，不便通信查找该域名对应的IP地址、重定向（301）、收回第二个GET申请 1) 查找流程： 浏览器查找DNS缓存本机（零碎级别）查找DNS缓存dns服务器 -主动获取DNS服务器地址（局域网id） 路由器（做dns转发，也会有缓存）运营商ISP调配的 （间接连贯），局部运营商会通过dns劫持做广告植入指定DNS服务器地址（首选，备选）--长处：解析快/无污染/防劫持google dnsali/baidu/open/114 DNShost定义的配置文件本地域名DNS服务器（）-->根域名服务器--> COM顶级域名服务器-->x.com域名器参考资料：在Windows中，抉择TCP/IPv4协定设置中的“主动获取DNS服务器地址”，计算机到底做了什么？ 一个页面从输出 URL 到页面加载显示实现，这个过程中都产生了什么？上面以HTTP协定为例： 在浏览器输出 URL浏览器查看缓存 未缓存：发动新申请已缓存： 陈腐：间接提供给客户端不陈腐（过期）：否则与服务器进行验证判断陈腐（是否过期）的http字段 Expires 和Expires (HTTP1.0) : 值为一个相对工夫示意缓存陈腐日期Cache-Control (HTTP1.1)：max-age=, 值为以秒为单位的最大陈腐工夫浏览器解析URL（获取 协定/主机/端口/path）浏览器组装一个HTTP（GET）申请报文浏览器获取主机IP地址 ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 vue你应用过 Vuex 吗？Vuex 是一个专为 Vue.js 利用程序开发的状态管理模式。每一个 Vuex 利用的外围就是 store（仓库）。“store” 基本上就是一个容器，它蕴含着你的利用中大部分的状态 ( state )。 （1）Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候，若 store 中的状态发生变化，那么相应的组件也会相应地失去高效更新。 （2）扭转 store 中的状态的惟一路径就是显式地提交 (commit) mutation。这样使得咱们能够不便地跟踪每一个状态的变动。 次要包含以下几个模块： State：定义了利用状态的数据结构，能够在这里设置默认的初始状态。Getter：容许组件从 Store 中获取数据，mapGetters 辅助函数仅仅是将 store 中的 getter 映射到部分计算属性。Mutation：是惟一更改 store 中状态的办法，且必须是同步函数。Action：用于提交 mutation，而不是间接变更状态，能够蕴含任意异步操作。Module：容许将繁多的 Store 拆分为多个 store 且同时保留在繁多的状态树中。Vue 组件间通信有哪几种形式？Vue 组件间通信是面试常考的知识点之一，这题有点相似于凋谢题，你答复出越多办法当然越加分，表明你对 Vue 把握的越纯熟。Vue 组件间通信只有指以下 3 类通信：父子组件通信、隔代组件通信、兄弟组件通信，上面咱们别离介绍每种通信形式且会阐明此种办法可实用于哪类组件间通信。 （1）props / $emit 实用 父子组件通信 这种办法是 Vue 组件的根底，置信大部分同学耳闻能详，所以此处就不举例开展介绍。 （2）ref 与 $parent / $children 实用 父子组件通信 ref：如果在一般的 DOM 元素上应用，援用指向的就是 DOM 元素；如果用在子组件上，援用就指向组件实例$parent / $children：拜访父 / 子实例（3）EventBus （$emit / $on） 实用于 父子、隔代、兄弟组件通信 ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 算法斐波那契数列介绍？别称：黄金分割数列从第三位起，每个数字都是前两位数字之和 [3, 5, 8, 13, 21] //迭代法生成斐波那契数列 function fib(n) { var fib_n = function(curr, next, n) { if (n == 0) { return curr; } else { return fib_n(next, curr+next, n-1); } } return fib_n(0, 1, n); } alert(fib(40));常见的算法有哪些？排序算法：疾速排序，归并排序 、计数排序（8大排序算法）搜索算法：回溯、递归、剪枝技巧图论：最短树、最小生成树、网络流建模动静布局：背包问题、最长子序列、计数问题根底技巧：分治、倍增、二分、贪婪参考资料： 互联网公司最常见的面试算法题有哪些？ 分治算法？实用状况： 规模放大到肯定水平就能够容易地解决能够合成为若干个较小的雷同问题，具备最优子结构性质子问题的解能够合并为该问题的解子问题互相独立，子问题不蕴含公共的子问题实现流程： 相似数学归纳法，找到解决问题的求解方程公式，而后依据方程公式设计递归程序【合成】原问题合成为若干个规模较小，互相独立，与原问题模式雷同的子问题【解决】规模较小而容易则间接解决，否则递归解决子问题（思考随着问题规模增大时的求解办法）【合并】将子问题的解合并的为原问题的解，找到求解的递归函数（各种规模和因子），设计递归程序即可应用案例： 二分搜寻疾速排序参考资料： 五大罕用算法之一：分治算法 递归算法介绍？函数中存着调用函数自身的状况，这种景象就叫递归联想（汉诺塔）： 把用木块（一共5块）叠起来的金字塔，转换到另一个柱子上，能够应用一个两头柱子，每次只能挪动一个木块，大木块不能压在小木块下面，最小门路通用解决思路（步骤）： 【实现雷同函数】把一个问题分解成具备雷同解决思路的子问题，能调用一个函数实现【终止条件】函数调用前判断终止条件 参考资料： 动静布局算法？参考资料： 牛逼了，原来大神都是这样学动静布局的… 贪婪算法介绍？贪婪算法（贪心法），只思考当下最优解，不思考全局。心愿从：部分最优解-> 全局最优解，并常常却不是步骤： 【拆分】：把问题拆成若干步骤【每步最优解】每一步都选取以后状态 最好/优的抉择（部分最无利的抉择）【循环】重叠出的后果也是最好/优的解联想（找零钱，起码数量）：找零钱：31块 核心思想：只思考当下最优解，不思考全局找出符合条件中（x≤31），最优抉择：20元找出符合条件中（x≤11），最优抉择：10元找出符合条件中（x≤1），最优抉择：1元毛病案例：找零钱41元 如果此时货币面值里有（25元，20元，10元，5元，1元） 贪婪算法的策略：25+10+5+1理论最优解策略： 20+20+1长处： 简略，高效，省去了为找最优解可能须要穷举操作，通常作为其余算法的辅助算法来应用毛病： 不思考总体，每次选取部分最优解，不再进行回溯解决，所以很少状况下失去最优解参考资料： 小白带你学---贪婪算法（Greedy Algorithm) ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 挪动端挪动端高清屏适配计划？几个要解决的重要问题： 布局 > 字体大小 > 1px边框 > 高清图 参考资料： 挪动端高清屏适配计划 挪动端尺寸单位？px: 相对长度单位，rem：绝对长度单位，绝对于根元素htmlem：绝对长度单位，绝对于父级参考资料： css单位中px和em,rem的区别 事件穿透的原理及解决方案？原理 ： 300ms提早问题，事件穿透了（可跨页面）解决方案： 不要混用touch,click， touch300ms会触发clicktap后提早350ms再暗藏mask，打消掉touch之后的click （tap后提早350毫秒再暗藏mask）第三方插件fastclick高清屏1px边框问题的解决方案？伪类+transform（scale） 实现border-image， backgroud-image 实现viewport+rem解决办法： 应用svg来设置border-image； .example { border: 1px solid transparent; border-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' height='2px'%3E%3Crect fill='%2300b1ff' width='100%25' height='50%25'/%3E%3C/svg%3E") 2 2 stretch; }浏览器有哪些兼容些问题，你是如何解决的？html5的兼容性能够应用htmlshiv.js来解决（能够兼容到ie6-ie8）css3 新个性，独自减少前缀（能够应用postcss的插件 Autoprefixer）; IE条件正文js兼容性：jquery挪动端兼容性问题？ios下软键盘弹出，fixed元素容易定位出错，影响fixed元素定位； 解决方案：可用iscroll插件解决这个问题； zepto点击穿透的bug：应用fastclick插件代替挪动端300s提早解决计划？应用插件fastclick应用zepto的touch事件代替能够绑定ontouchstart事件事件穿透的原理及解决方案？原理 ： 300ms提早问题，事件穿透了（可跨页面）解决方案： 不要混用touch,click， touch300ms会触发clicktap后提早350ms再暗藏mask，打消掉touch之后的click （tap后提早350毫秒再暗藏mask）第三方插件fastclickH5与原生APP交互的原理？一、APP调用H5 【不倡议应用】app做为容器，尽量不要去调用H5的办法，这样会导致数据流凌乱，APP webview容器不能做到模块化步骤 h5中裸露一些全局对象, 把变量，办法注入到window对象下app中调用这些对象二、H5调用APP 因为h5不能间接拜访宿主APP，所以这种调用绝对简单一点1）APP向h5注入一个全局JS对象 长处：简略 毛病：可能存在安全隐患,android零碎 H5中间接调用： window.appSdk.double(10); //20 2）H5发动一个自定义协定申请 scheme协定，app的一种页面跳转协定步骤： 【定协定】app自定义协定 ydl-user://ceshi/list 跳转到【原生】测评列表页ydl-user://h5/test?params={"url":" http://www.x.com/ceshi/1"} //跳转到【H5】测评详情页，params 参数局部 应用UrlEncode编码 且不能有空格【定回调】h5定义好回调函数 window.bridge={getDouble:value=>{}, getTriple:value=>{}}【发申请】H5发动一个自定义协定申请， ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 react 如何实现keep-alive?Keep-alive是缓存路由应用的，保留之前路由的状态实现办法： 应用npm库： react-router-cache-routerReact-activationreact错误处理？次要的api(生命周期): componentDidCatch(error,errorInfo): 同样能够将谬误日志上报给服务器getDerivedStateFromError(error)：更新state使下一次渲染可能显示降级后的UI注意事项： 仅可捕捉其子组件的谬误，无奈捕捉其本身的谬误你有应用过suspense组件吗？动静加载（异步组件）加载时会有提早，在提早期间能够将一些内容展现给用户，比方：loading (react16.6新增的API) const resource = fetchProfileData();function ProfilePage() { return ( <Suspense fallback={<h1>Loading profile...</h1>}> <ProfileDetails /> <Suspense fallback={<h1>Loading posts...</h1>}> <ProfileTimeline /> </Suspense> </Suspense> );}function ProfileDetails() { // 尝试读取用户信息，只管该数据可能尚未加载 const user = resource.user.read(); return <h1>{user.name}</h1>;}function ProfileTimeline() { // 尝试读取博文信息，只管该局部数据可能尚未加载 const posts = resource.posts.read(); return ( <ul> {posts.map(post => ( <li key={post.id}>{post.text}</li> ))} </ul> );}参考资料： 何为 Suspense？ 怎么动静导入组件，按需加载，代码宰割？只有当组件被加载时，对应的资源才会导入react-loadable: npm 库 按需加载react.lazy: 原生反对（新版本16.6），配合suspense一起应用，还要webpack code splittingrequire(component) : 在特定条件下，动静引入react Context介绍？次要api: ...

什么是JUC 在Java中，线程局部是一个重点，本篇文章说的JUC也是对于线程的。JUC就是java.util .concurrent工具包的简称。这是一个解决线程的工具包，JDK 1.5开始呈现的。 过程与线程过程过程（Process） 是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。 在当代面向线程设计的计算机构造中，过程是线程的容器。程序是指令、数据及其组织模式的形容，过程是程序的实体。是计算机中的程序对于某数据汇合上的一次运行流动，是零碎进行资源分配和调度的根本单位，是操作系统构造的根底。程序是指令、数据及其组织模式的形容，过程是程序的实体。 线程线程（thread） 是操作系统可能进行运算调度的最小单位。它被蕴含在过程之中，是过程中的理论运作单位。一条线程指的是过程中一个繁多程序的控制流，一个过程中能够并发多个线程，每条线程并行执行不同的工作。 总结过程：指在零碎中正在运行的一个应用程序；程序一旦运行就是过程；过程——资源分配的最小单位。 线程：零碎调配处理器工夫资源的根本单元，或者说过程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 对于Java而言：Thread、Runnable、Callable 扩大:Java 真的能够开启线程吗？ public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". */ if (threadStatus != 0) throw new IllegalThreadStateException(); /* Notify the group that this thread is about to be started * so that it can be added to the group's list of threads * and the group's unstarted count can be decremented. */ group.add(this); boolean started = false; try { start0(); started = true; } finally { try { if (!started) { group.threadStartFailed(this); } } catch (Throwable ignore) { /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */ } } } // 调用本地办法区 调用c++办法，所以说java不能启动线程 private native void start0();并发与并行并发编程的实质：充分利用CPU的资源 ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 redux[TOC] Redux 介绍？redux是js状态容器，提供可预测化的状态治理它认为： web利用是一个状态机，视图与状态是一一对应的关系所有的状态，保留在一个对象外面设计思维： 每个state变动可预测动作与状态对立治理Redux与 MobX的区别？【代码量】 redux>mobx redux： 须要定义一堆的action, dispatch,reducermobx： store和扭转的办法【开发难度】 redux>mobx mobx：应用面向对象的编程思维，绝对简略redux：比较复杂，函数式编程思维，同时须要借助一系列的中间件来解决异步和副应用【调试难度】 mobx>redux redux：状态不可变，返回一个新的状态，同时应用纯函数；,redux 提供工夫回溯的开发工具，同时纯函数以及更少的形象，让调试变得更加容易mobx：中状态可变，可对其间接批改，mobx中有更多的形象和封装，调试比拟艰难，同时后果难预测【store数】redux：单个store mobx: 多个store【功能性】redux> mobxredux: 可回溯状态，工夫旅行，适宜：画板利用，表格利用，很多时候须要撤销，重做等操作 mobx: 间接批改源数据实用场景总结： mobx： 简略我的项目，适宜数据不简单的利用redux：大型项目，有回溯需要redux的实现流程？用户（通过view）收回Action,收回形式是调用dispatch办法；Store主动调用 Reducer ,传入两个参数，以后state,收到的Action，Reducer 返回新的 Statestate更新后，store就会调用监听函数， 依据state触发从新渲染，更新view整个流程中数据都是单向流动的，这种形式保障了流程的清晰几个外围概念： Store :数据中心，整个利用只能有一个storeState: store对象蕴含的所有数据Action: 用户触发的行为名称（通过action再去触发state的扭转，最终响应view的扭转）Action Creator: 生成action的函数，可生成多种actionReducer: store收到action后，解决state的函数，叫到reducer，接管两个参数：action ，和以后state；返回值： 新的stateDispatch: view收回action的惟一办法Redux与Vuex区别?相同点： 都是做状态治理库都是从Flux中衍生来的（繁多数据源，单向数据流）不同点： 【适用范围】redux是一个泛用的实现，也能够用在vue中，然而符合度不如vuex多个vuex中引入module能够把store划分成多个单元 ； redux罕用的中间件？redux-logger ： 日志中间件，输入触发的action，和通过reducer解决前后的state值；redux-thunk：解决异步 长处： 体积小：实现形式简略，只有不到20行代码应用简略：没有引入像redux-sage 或者 redux-observable 额定范式，上手简略毛病： 耦合重大：异步操作与redux的action 偶合在一起，不方便管理性能弱：罕用的性能须要本人封装redux-saga：解决异步 异步解耦：异步操作被转移到独自的saga.js中，不再掺杂在action.js 或 component.js中异样解决：受害于generator function的 saga实现，代码异样/申请失败 都能够间接通过 try/catch语法间接捕捉解决功能强大：提供了大量的saga辅助函数和 Effect 创立器 供开发者应用灵便：能够将多个saga 串行/并行组合起来，造成一个十分实用的异步flow易测试：提供了各种case的测试计划，包含 mock task ,分支笼罩等redux-promise：解决异步redux-observable ...

前言：想零碎学习前端面试题，强烈推荐浏览 在线电子书（反对手机版，不断更新） 。 本书特点：零碎全面（涵盖前端核心技术点），简洁，针对性强（针对面试场景设计）。 欢送在github上留言反馈 ES6+[TOC] 介绍下Generator?Generator函数是ES6提供的一种 异步编程解决方案,Generator函数是分段执行的，yield表达式是暂停执行的标记，而next办法能够复原执行Generator函数是一个状态机，封装了多个外部状态。执行Generator 函数会返回一个遍历器对象，能够顺次遍历Generator函数外部的每个状态。 Generator与一般函数的区别： 【不执行】调用Generator函数后，该函数并不执行【返回指针】返回的是一个指向外部状态的指针对象，而不是函数运行后果（遍历器对象 Iterator Object）【持续运行】必须调用遍历器对象的next办法，使得指针移向下一个状态，每次调用next办法，就继续执行，直到遇到下一个yield表白 式(或return语句）为止。Generator API： next(): 返回一个由yield 表达式生成的值return(): 返回给定的值并完结生成器throw(): 向生成器抛出一个谬误function* helloWorldGenerator(){ yield 'hello'; //遇到yield 暂停执行 yield 'world'; return 'ending';}let hw = helloWorldGenerator(); //调用不执行函数，只是返回一个遍历器对象hw.next(); //{value:'hello',done:false} 调用next办法继续执行，直到遇到yield或return表达式hw.next(); //{value:'world',done:false}hw.next(); //{value:'ending',done:true}hw.next(); //{value:undefind,donw:true} 参考资料： Generator 函数的语法 ES6 Set 和 Array 的区别？区别： 【重复性】 set: value不反复 //通过此个性，可用来去重array: value 可反复ES6 Map和Objects的区别？Map对象保留键值对，工作值（对象或原始值）都能够做为一个键或一个值区别（Maps的长处）： 【key值类型】 Map：key能够是对象Objects: key只能是一个string 或是 symbol【键的程序】 Map: 有序Objects: 无序【size】 -Map: 减少size属性，间接获取Objects: 只能依附手动计算【键名抵触】 Map: 默认不蕴含任何键，只蕴含显式插入的键Object: object都有本人的原型，原型链上的键名有可能和你本人对象上的设置的键名产生抵触 （ES5开始可用Object.create(null)来创立一个没原原型的对象，但这种用法不常见）【性能】 Map: 在频繁增删键值对的场景下体现更好Object: 在频繁增加/删除键值对的场景下未作出优化 ...

我将文中提到的的 MySQL、Redis、Kafka 思维导图放到了我的公众号中，大家能够关注我的公众号【haxianhe】，回复 “思维导图” 支付高清pdf版思维导图。 在上一篇文章 涨薪50%，从小厂逆袭快手 - 附面经 中，我概述性的给出了社招跳槽有哪些环节要去筹备，那么明天我会给出面试温习比拟举荐的复习资料、如何温习以及有哪些常见的注意事项。 自我介绍自我介绍是面试的一场面试第一个环节，而一个好的自我介绍是能够疏导整场面试的节奏的，上面就简略介绍一下如何筹备一份“适合”的自我介绍。 首先，咱们要晓得面试官想通过自我介绍理解什么信息。 在技术面试中，面试官除了想在你自我介绍的工夫看应聘者的简历之外，个别会想理解以下几点信息：年龄，毕业院校，工作年限，工作经验，行业背景，我的项目教训，技术面等这些根底信息，而后依据自我介绍和简历信息就能够深刻的聊一下具体的我的项目教训，技术问题等。 个别在进行自我介绍的时候概述性的介绍一下本人的学历背景、工作经验、我的项目教训，以及本人善于的技术面即可。如果面试官对你介绍的哪局部内容感兴趣，他会具体问你的。 我的项目教训这部分是社招面试的重头戏，总的准则是 以“我的项目教训”包容“线上问题”，撑持“技术亮点”。 面试提到的技术亮点是须要我的项目教训来撑持的。 大多数人在日常的工作中，用到的技术是十分无限的，可能就是 CRUD 外带一些调优，这也是普遍现象。反之，如果一个高级开发，在面试中说，之前开发的模块既有jvm调优、又有分布式组件，再外带数据库性能优化，仿佛可信度也不高。 对此，你须要用“解决过的线上问题”去撑持想要开展的技术亮点，须要你平时工作中积极主动的去参加线上问题的解决，比方有 oom 问题、redis缓存被击穿，或者其余分布式组件的case，你参加排查并解决，那么未来面试的时候，你天然能够以此为根底去开展你当时筹备好的技术亮点。 这样的话，就像下面的那张图一样，你就有足够的支撑物去撑持你的分布式组件以及其余值钱的技能了。 总之，技术自身不值钱，面试官只关怀你如何应用技术去解决线上问题的。 我的项目介绍在面试时，通过寒暄后，个别面试官会让介绍我的项目教训，常见的问法是：“说下你最近的（或最拿得出手的）一个我的项目”。 在面试前筹备我的项目形容，别胆怯，因为面试官什么都不晓得 面试官是人，不是神，拿到你的简历的时候，是没法核实你的我的项目细节的（个别公司会到录用后，用背景考察的形式来核实）。 更何况，你做的我的项目是以月为单位算的，而面试官最多用3分钟来从你的简历上理解你的我的项目教训，所以你对我的项目的相熟水平要远远超过面试官，所以你一点也不必缓和。 如果你的工作教训比面试官还丰盛的话，甚至还能够管制整个面试流程。 上面给出了你和面试官的状况比照： 你面试官对你以前的我的项目和技能很理解只能听你说，只能依据你说的内容做出判断在面试过程中的职责在很短的工夫内防守胜利即可如果找不出破绽，就只能算你以前做过筹备工夫面试前你有短缺的工夫筹备个别在面试前用3分钟浏览你的简历沟通过程你能够出错，但别出关键性的谬误不会太尴尬你，除非你太差技巧你有足够的技巧，也能够从网上找到足够多的面试题其实就问些通用的有法则的问题既然面试官无奈理解你的底细，那么他们怎么来验证你的我的项目教训和技术？ 上面总结了一些罕用的发问形式： 发问形式目标让你形容工作教训和我的项目（极有可能是最近的），看看你说的是否和简历上统一看你是否真的做过这些我的项目看你简历上我的项目里用到的技术，比方框架、数据库，而后针对这些技术提些根本问题还是验证你是否做过我的项目，同时看你是否理解这些技术，为进一步发问做筹备针对某个我的项目，不断深入地问一些技术上的问题，或者从不同侧面问一些技术实现，看你前后答复外面是否有矛盾深刻核实你的我的项目细节针对某技术，问些我的项目里肯定会遇到的问题，比方候选人说做过数据库，那么就会问索引方面的问题通过这类问题，核实候选人是否真的有过我的项目教训（或者还仅仅是学习教训）筹备我的项目的各种细节，一旦被问倒了，就阐明你没做过 一般来说，在面试前，大家该当筹备我的项目形容的说辞，自信些，因为这部分你说了算，流畅些，因为你通过充分准备后，能够晓得你要说些什么。 而且这些是你理论的我的项目教训（不是学习教训，也不是培训教训），那么一旦让面试官感觉你都说不上来，那么可信度就很低了。 不少人是拘泥于“我的项目里做了什么业务，以及代码实现的细节”，这就相当于把后继发问权间接交给面试官。 下表列出了一些不好的答复形式： 答复形式结果我在XX软件公司做了XX门户网站我的项目，这个我的项目做到了XX性能，具体是XX和XX模块，各模块做了XX性能，客户是XX，最初这个我的项目挣了XX钱间接打断，因为业务需要我不须要理解，我会间接问他我的项目里的技术（须要招聘一个Java后端开发，会Spring MVC）最近一个我的项目我是用C#（或其余非Java技术）实现的，实现了……或者我最近做的不是开发，而是测试……或者我最近的我的项目没有用到Spring MVC发问，你最近用到SSH技术的我的项目是什么时候，而后在评语上写：最近XX工夫没接触过SSH在毕业设计的时候（或者在读书的时候，在学习的时候，在XX培训学校，在XX实训课程中），……间接打断，发问你这个是否是商业我的项目，如果不是，你有没有其余的商业教训。如果没商业我的项目教训，除非是校招，否则就间接完结面试形容我的项目时，一些要害因素（比方公司、工夫、所用技术等）和简历上的不匹配咱们会深究这个不统一的状况，如果是简历造假，那么可能间接中断面试，如果真的是笔误，那么就须要提供正当的解释在防止上述不好的答复的同时，大家能够按下表所给出的因素筹备我的项目介绍。 因素款式管制在1分钟外面，讲出我的项目根本状况，比方项目名称，背景，给哪个客户做，实现了根本的事件，做了多久，我的项目规模多大，用到哪些技术，数据库用什么，而后酌情简略说一下模块。重点突出背景，技术，数据库和其余和技术无关的信息。我在XX公司做了XX外汇保证金交易平台，客户是XX银行，次要实现了挂盘，实盘成交，保证金杠杆成交等性能，数据库是Oracle，前台用到JS等技术，后盾用到Java的SSH，几个人做了X个月。不须要详细描述各功能模块，不须要说太多和业务无关但和技术无关的。如果面试官感兴趣，等他问。要被动说出你做了哪些事件，这部分的形容肯定须要和你的技术背景统一。我做了外汇实盘交易系统，挂单成交零碎，XXX模块，做了X个月形容你在我的项目里的角色我次要是做了开发，但在开发前，我在项目经理的率领下参加了业务调研，数据库设计等工作，前期我参加了测试和部署工作。能够形容用到的技术细节，特地是你用到的技术细节，这部分尤其要留神，你说进口的，肯定要晓得，因为面试官前面就依据这个问的。你如果做了5个模块，宁肯只说你能纯熟说上口的2个。用到了Java外面的汇合，JDBC，…等技术，用到了Spring MVC等框架，用技术连贯数据库。这部分你危险本人承当，如果能够，不露声色说出一些热门的因素，比方Linux，大数据，大拜访压力等。但一旦你说了，面试官就会间接问细节。这个零碎里，部署在Linux上，每天要解决的数据量是XX，要求是在4小时，1G内存是的状况下解决完5千万条数据。均匀访客是每分钟XXX。线上问题大家平时工作中肯定要 把握住呈现“线上问题”的机会。 因为，性能做了只是具备了我的项目教训，然而面试的时候真正“值钱”的其实是技术的难点与解决方案，而个别技术难点广泛随同着“线上问题”。所以，平时工作中积极主动点，呈现了线上问题不论是不是本人的都去查、去解决，预先围绕着“问题景象、问题剖析、问题影响、解决方案、问题扩大”等去总结、记录到本人的笔记总，后续都是本人最贵重的财产。 技术亮点联合本人遇到过的线上问题，优先筹备分布式组件方面的技术亮点，罕用的分布式组件次要有 MySQL、Redis、Kafka等。 这部分内容能够参考JD上对技术要求，有针对性的去筹备，也能够参考我上面介绍的对于中间件局部的内容。 编程语言对于这部分内容，转语言的同学可能更须要关注一下。 首先，须要明确的是你想转到什么语言，那你就须要当时筹备好那个语言面试可能要问的内容，因为企业招你进去是干活的而不是再像校招那样，先把你招进去再去造就你。投简历前你是能看到JD的，JD上个别都有对于须要把握的技术的明确的要求。 对于Java的温习资料，举荐开源我的项目 JavaGuide中间件常见的中间件次要有：MySQL、Redis、Kafka，接下来我简略介绍一下我的温习教训。 温习资料对于中间件的温习资料，举荐开源我的项目 advanced-javaMySQL温习的话，还有两本书给大家举荐一下： 《MySQL 技术底细：InnoDB 存储引擎》《高性能 MySQL》Redis 温习的话，也给大家举荐一本书： 《Redis 设计与实现》复习方法个别我会联合下面举荐的书和开源我的项目去整顿一份本人的思维导图（思维导图我在上面放了截图）和笔记。 MySQL Redis Kafka ...

面向对象面向过程更重视于事件的每一个步骤和程序，面向对象则更重视于事件有哪些参与者以及各须要做什么 JDK JRE JVMjdk： Java开发工具包jre：Java运行时环境jvm：Java虚拟机 ==和equals==比的是栈中的值，根本类型是变量值，援用类型是堆中内存对象的地址equals：object默认也是采纳==比拟，通常会重写，重写后equals其实是比拟两个字符串的内容 String x = "string";String y = "string";String z = new String("string");System.out.println(x==y); // trueSystem.out.println(x==z); // falseSystem.out.println(x.equals(y)); // trueSystem.out.println(x.equals(z)); // true String str1 = "hello"; String str2 = new String("hello"); String str3 = str2; //援用传递 System.out.println(str1 == str2); //false System.out.println(str1 == str3); //false System.out.println(str2 == str2); //true System.out.println(str1.equals(str2)); //true System.out.println(str1.equals(str3)); //true System.out.println(str2.equals(str3)); //true简述final作用 ，为什么局部变量外部类和匿名外部类只能拜访部分final变量final能够润饰：类（不可被继承）、办法（不可被重写）、变量（不可更改值） String、StringBuilder、StringBufferString是final润饰的，不可变，每次操作都会产生新的String对象StringBuilder和StringBuffer都是在原对象上操作，StringBuffer是线程平安的，StringBuilder线程不平安，性能：StringBuilder>StringBuffer>String 重载和重写的区别重载：产生在同一个类中，办法名必须雷同，参数类型不同，个数、程序、不同，办法的返回值和拜访修饰符能够不同，产生在编译时；重写：产生在父子类中，办法名、参数列表必须雷同，返回值范畴小于等于父类，抛出异样方位小于等于父类，拜访修饰符范畴大于父类，富国父类办法为private则不能重写该办法。 接口和抽象类抽象类能够存在一般成员函数，而接口中只能存在 public abstract办法抽象类中的成员变量能够时各种的，而接口中成员变量只能是public static final抽象类只能继承一个，而接口能够实现多个接口的设计目标是对行为进行束缚，而抽象类的设计目标是代码复用，抽象类是对类实质的形象，表达式是is a的关系，而接口是对行为的形象，表达式是like a的关系，接口的外围是定义行为，即实现类能够做什么，至于主体是谁，如何实现的，接口并不关怀。-应用场景：当你关注一个事物本质的时候，用抽象类，当你关注一个操作的时候，用接口。 List和Set的区别List：有序，按对象进入的程序保留对象，可反复，可容许多个null元素对象，取元素能够应用iterator接口获得所有元素，在遍历一遍，还能够应用get(int index)获取指定下标的元素Set：无序，不可反复，最多容许有一个null元素对象，取元素只能用Iterator接口获得所有元素，再逐个遍历各个元素Iterator取值遍历： ...

前言Integer和int 最实质的区别就是：Integer是封装类，int是根本数据类型（这是废话）。 本文是心愿能对Integer和int的区别进行更具体的比照阐明并加以举例 Integer和int的区别Integer的默认初始值是null，而int的初始值是int也就是说Integer可能辨别出未赋值和值为0的区别，而int却不能表白出未赋值的状况，所以int不适宜作为web层的表单数据填写。（例如：一个学生参加考试且问题为0，和没加入考试成绩为null）Integer是类，自带很多办法供应用，而int只能做一些根本的±*/=的操作Integer变量必须先实例化，int变量间接应用 对于Integer在阐明Integer的时候有几个小知识点提一下： 拆箱和装箱 什么时候拆箱：根本数据类型和援用数据类型做运算时什么时候装箱：根本数据类型赋值给援用数据类型时“==”和“equals()” “==”：在比拟根本数据类型时比拟的是数值，比拟援用数据类型时比拟的是对象堆内存地址equals()：在Object类中是通过“==”来比拟的，但大多时候，咱们会将其进行重写在Integer类中，“==”用来比拟对象地址是否雷同，而equals()被重写，他会先判断参数中对象是否为Integer类型，如果是则判断值是否雷同。 public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; }几点阐明Integer变量和int变量比拟值时，只有值是相等的，后果就为true（因为Java会主动拆箱，将Integer拆为int，在进行比拟） Integer a = new Integer(1);int b = 1;System.out.println(a == b);//true两个通过new生成的Integer变量是永远不相等的（因为new生成的是两个新对象，内存地址不同） Integer a = new Integer(1);Integer b = new Integer(1);System.out.println(a == b);//false一个new产生的变量和一个非new产生的Integer变量也是不相等的（因为非new产生的Integer变量指向Java常量池中的对象，而new产生的变量指向堆中新建对象，他俩所在的内存地址不同） Integer a = new Integer(1);Integer b = 1;System.out.println(a == b);//false两个非new产生的Integer变量比拟：当值在-128~127之间时，后果为true，当值在此区间外后果为false（因为Integer常量池的存储范畴是[-128,127]，在此范畴内是间接存储于常量池的，都指向同一个地址。在此范畴外的数须要通过堆内存创立一个新对象。比方Integer a=1会将1写入缓存中，下次再写Integer b=1时会间接从缓存中去，不必new了，所以取到的地址也是雷同的） Integer a = 1;Integer b = 1;System.out.println(a == b);//trueInteger a = 129;Integer b = 129;System.out.println(a == b);//false最初欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！ 这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。 ...

很多小伙伴问我我是如何同时拿到字节跳动，腾讯和美团Offer的。明天咱们就来简略的聊聊除了技术外，大厂还会看重哪些技能。 当然，大厂对于技术的要求也是比拟高的。起码工作年限的长短要和应该具备的能力匹配。不可能你工作1年左右工夫要求你把握P7、P8级别的能力，也不可能你工作10年左右只是要求你把握到P6级别的能力。进大厂，首先你的工作年限起码要和应该具备的能力匹配。留神∶这里说的是起码，具体意思就是说工作年限至多要和应该具备的能力匹配。有些很聪慧的人工作1、2年可能达到P7级别，也不是不可能的事件。我始终感觉，工作年限并不等同于工作教训，工作年限充其量只是工作经验而已，有些人工作了近10年，我的项目倒是做了不少，但根本就是CRUD，没啥含金量，工作教训充其量也就1年，说1年的工作教训，实质上曾经不少了。为啥这样说？因为这种人近10年来做的工作，一名毕业生3个月工夫根本就可能把握了，再进行一两个月的强化，根本就可能达到相应的程度了。所以，工作年限并不等同于工作教训。 说简略点，我了解的工作教训就是你在工作过程中，总结的解决问题的能力，这种能力是其他人不会轻而易举就学会的，它是真正属于你的货色。很多培训机构宣扬的4个月工夫达到XXX工作教训，在我看来，是扯淡的。他们基本没有了解啥是工作教训。当然，通过培训兴许可能更快的把握一些技术，也可能更快的解决一些问题。然而，如果想造成本人的工作教训，造成一套本人解决问题的方法论，还是有很长的一段路要走。进大厂，不是久而久之的事件。当然，我这里说的是社招，校招就另说了。如果你想通过本人的能力进大厂，兴许通过培训机构也能进，但我感觉有些培训机构的确很水。为啥？看下图吧。所以，我更提倡本人在平时的工作过程中多积攒，多总结，造成一套本人解决问题的方法论。只有在平时的工作过程中总结到位，进大厂是很天然的事件。而不是等到想进大厂的时候，长期去找各种面试题和面经来常备不懈，通过这种形式进大厂的概率极低！ 大厂除了对技术人员的技术能力要求高之外，对于集体的学习能力，疾速定位问题和解决问题的能力，场景剖析能力，业务理解能力，潜在问题的剖析能力等要求的都比拟高。从实质上讲，这些能力才是一个技术人员真正要把握的工作教训，这些也绝不是通过几个月的简略培训就可能把握的。 总之，大厂的用户体量大，业务简单，基于大厂本身的业务思考，大厂对于面试者的要求会比拟高。而作为技术人员，如果想进大厂，就须要在平时的工作过程中，留神积攒和总结，造就本人的各项能力（本文中提到的集体学习能力，疾速定位问题和解决问题的能力，场景剖析能力，业务理解能力，潜在问题的剖析能力等)。只有在平时的工作中总结到位，进大厂，是很天然的事件。 最初，阿里的小姐姐说年后我能够换工作地点。 好了，明天就到这儿吧，我是冰河，咱们下期见~~

这是why哥的第89篇原创文章 前两天，有一个读者给我发了一张图片。 我问：发什么肾么事了？ 于是有了这样的对话： .png) 他发的图，就是微信静止步数排行榜的截图： 其实扯了这么多，这就是个常见的面试场景题：如何设计一个排行榜？ 这个题吧，其实就是考你面试筹备范畴的广度，见过就会答，没见过...就难说了。 当然，如果你在理论业务中做过排行榜，那么这题正中下怀，你也不要笑出声来，场景题面试官是会给你思考工夫的。 所以你不要张口就来，你只须要眉头稍稍一皱，给面试官说：这题我想想啊。 而后略微组织一下语言，说进去就行。 这次的文章，就带着大家剖析一下“排行榜”这个场景题，到底应该怎么做。 基于数据库这个题，如果是真的之前没有遇见过，可能最容易进入大家视线的就是平时接触的最多的数据库了。 因为一想到“排行榜”，就想到了 order by。 一想了 order by，就想到了数据库。 一想到了数据库... 兄弟，你路就走窄了。 尽管我已经就基于 MySQL 做过排行榜，因为过后是为了一个较量长期搭建的服务，基本就没有引入 Redis。我评估了一下搭建 Redis 的工夫和用 MySQL 间接开发的工夫。 于是抉择了 MySQL。 而让我抉择 MySQL 的根本原因还是我曾经晓得进入决赛的队伍只有 10 支，也就是说我的排行榜表外面从始至终也只有 10 条数据。 选手提交代码之后，零碎实时算分，而后更新排行榜表。 而后接口返回给前端页面上面这些数据，而上面这些数据都在一个表外面： 队伍依照历史最高分数排名队伍名称历史最高分数最近一次提交得分最近一次提交工夫前端每隔一分钟调用我的接口，雷同分数，名次雷同，所以我在接口外面用一条比较复杂的 sql 去查询数据库，下面的这些字段就都有了。 你看，排行榜的确是能够用 MySQL 来做的。 不肯定非得上 Redis，记住一句话：脱离业务场景的方案设计，都是耍流氓。 然而这玩意和“万物皆对象”一样，别对着面试官说，这肯定不是面试官想要听到的答案。 或者说，这只是想要听到的一部分答复。 这个答复能用的起因是我给了一个具体的场景，用户量十分的小，怎么玩都能够。 甚至咱们不借助 MySQL 的排序，把数据查出来，在内存外面排序都能够。 然而如果，这是一个游戏排行榜，随着游戏玩家的减少，达到千万用户级别的话，这个计划必定是不行了。 当然，兴许你会给我扯什么查问慢就加索引，数据量大就分库分表的计划。 怎么说呢，下面这句话是没有错的。 然而一旦数据量大起来了，这个计划其实就不是一个特地好的计划。 这问题，得从根上治理。 基于 Redis这个场景其实就是在考查你对于 Redis 的 sorted set 数据结构的把握。 ...

Java办法详解什么是办法？Java办法是语句的汇合，它们在一起执行一个性能。 办法是解决一类问题的步骤的有序组合办法蕴含于类或对象中办法在程序中被创立，在其余中央被援用示例： package com.wmwx.method;public class Demo01 { //main办法 public static void main(String[] args) { int sum = add(1, 2); //调用add办法 System.out.println(sum); } //add办法 实现加法性能 public static int add(int a, int b){ return a+b; }}办法的长处Java中的办法有以下几个长处： 使程序变得更简短而清晰。有利于程序保护。能够进步程序开发的效率。进步了代码的重用性。 办法的设计准则设计办法的准则：办法的本意是功能块，就是实现某个性能的语句块的汇合。咱们设计办法的时候，最好放弃办法的原子性，就是一个办法只实现1个性能，这样利于咱们前期的扩大。 办法的定义其根本语法为： 修饰符 返回值类型 办法名(参数类型 参数名){ ... 办法体 ... return 返回值;}Java的办法蕴含一个办法头和一个办法体，相似于其余语言中的函数，是一段用来实现特定性能的代码片段。以下是一个办法的所有组成部分： 修饰符：可选，通知编译器如何调用该办法，定义了该办法的拜访类型。返回值类型 ：办法可能会有返回值，那么该返回值的数据类型就是该办法的返回值类型。有些办法执行所需的操作，但没有返回值。在这种状况下，办法的返回值类型应用关键字void。办法名：是办法的理论名称。办法名和参数表独特形成办法签名。参数类型：参数像是一个占位符，又被称为形参。当办法被调用时，传递值给参数，这个值被称为实参。参数列表是指办法的参数类型、程序和参数的个数。参数是可选的，一个办法能够不蕴含任何参数。办法体：办法体蕴含具体的语句，定义该办法的性能。例图： 办法的调用Java 反对两种调用办法的形式，依据办法是否返回值来抉择。 当办法返回一个值的时候，办法调用通常被当做一个值。如果办法返回值是void，办法调用肯定是一条语句。示例： package com.wmwx.method;public class Demo02 { public static void main(String[] args) { int maxNum = max(10, 20); //调用有返回值的max办法，作为赋给变量maxNum的值 System.out.println(maxNum); } //定义有返回值的max办法 public static int max(int num1, int num2){ int result = 0; if (num1==num2){ System.out.println("两数相等！"); return num1; } if (num1>num2){ result = num1; }else{ result = num2; } return result; }}办法的重载重载：如果一个类的多个办法领有雷同的办法名，然而有不同的参数列表，那么Java编译器会依据办法签名判断哪个办法应该被调用。 ...

阿里 AliExpress 前端团队 2022 春招开始了！ 就是我当初所在的部门，快来一起游玩 ~ 招聘对象岗位：前端实习生工程师招聘对象：2022届毕业生（2021年11月-2022年10月毕业，国外学生以理论状况为准）工作地：杭州岗位要求： 酷爱技术，对技术有强烈的求知欲，且有持之以恒的精力；关注用户体验，对于蹩脚的用户体验无奈容忍；踊跃乐观工作生活态度，辩证的思维能力对待剖析事物；有不错的英文程度，能和各国家工程师欢快沟通；实习期满，通过对立的转正问难，即可取得秋招口头 Offer 其它实习生招聘岗位也能够投递：Java研发工程师、客户端研发工程师（IOS/Android）、测试开发工程师、产品经理。投递时，注明个人信息和应聘岗位。 团队介绍咱们是一支融入了全世界各地优良前端工程师的国际化体验技术团队，服务于阿里巴巴 AliExpress 事业部全球化电商的全链路用户产品，蕴含但不限于：会员、商品、店铺、搜寻、营销、交易、领取、物流等。 咱们的使命是，基于高效生产环境，打造极致的电商全链路（寰球买、寰球卖、寰球付、寰球运）产品和多端的用户体验，服务于寰球200多个国家的消费者、商家以及生态从业者，用技术发明新商业。 咱们的愿景是，融入寰球多元的工程师文化，技术和用户体验寰球顶尖的前端技术团队。 咱们的劣势是，服务于寰球数十亿的用户、商家及生态从业者，你将有机会为全世界各地的数十亿用户定制他们专属的极致用户体验；电商全链路产品反对，你将更有机会参加到业务和技术的全链路各环节的建设中；全球化多域和多端协同的利用架构，你的服务和端利用将面临全球化简单用户环境所带来的高难度挑战，为了应答这些挑战，你将可能在不同的国家并肩作战。 你能播种到全球化多域多端架构下，极致用户体验的挑战性工作机会；阿里团体和业界前端各畛域最成熟的前沿技术的学习和实际的机会；一对一师兄制，在日常工作、技术成长和职业规划上都能给到帮忙；实习期满，通过对立转正问难，即可取得口头 Offer，实习转正通过率远高于秋季招聘通过率；实习期未通过问难的同学，也能够长期的师兄辅导，并且优先进入秋季招聘面试环节，通过率高于其余一般面试者；简历投递形式 & 联系方式邮箱：yibin.xb@alibaba-inc.com（邮件名：岗位+学校+姓名+微信号，并附上个人简历）微信分割：xb9207，进群答疑并投递简历。也能够扫以下二维码进群。扫码进群：扫描下方二维码进群（如失败可增加我的微信哈） 常见问题Q：我是2021年的应届毕业生，是否能够投递简历？社招是否能够投递简历 ？A：能够。咱们也欢送你投递简历给咱们，并备注你的毕业工夫。我会依照去年的校招规范进行面试流程的安顿，面试通过者，即可发放校招Offer。社招同学，请分割微信号 xb9207，独自投递简历。 Q：实习工夫是怎么安顿的，是否反对线上实习A：实习起码一个月工夫，具体工夫会和候选人磋商决定。实习的模式是必须到杭州办公地实习，临时不反对近程的线上实习。因而还身处国外无奈回国的同学们，不能参加本次实习岗位的招聘。然而也不必灰心，如果你有志愿退出咱们，也能够投递简历，咱们也会给你指派师兄，帮忙你的技术成长和秋季招聘辅导。 Q：我投递简历后，是怎么样的面试流程A：咱们首先会给你指派辅导师兄，同时也会拉你进入指定的钉钉群，答疑解惑。3月中旬会举荐你的简历到阿里的校招零碎中，进行面试流程。通常是3轮技术面试和1轮HR面试。过程中，师兄会全程进行辅导。 Q：我没有通过实习面试，秋招还能够投递吗？A：能够持续加入秋季招聘。对于进入面试环节，但没有通过本次实习生面试的同学，如果你依然很心愿退出咱们团队，咱们会有师兄对你长期辅导，在技术和集体职业规划上，那么秋季招聘，你会有更好的状态参加面试。 Q：我没有通过转正面试，秋招还能够加入吗，有什么劣势吗？A：依然能够加入秋季招聘。并且你们的师兄会长期跟进，对你的辅导。同时，在秋季招聘开始时，你会取得优先进入面试环节的机会。依据以往的教训，这些同学在秋季招聘时，退出咱们的机会更大。

图解游戏规则大家都晓得运动员长跑接力赛，明天咱们并不是讲接力赛，咱们讲“接力合作赛”，须要咱们从新定义下游戏规则：如下图所示 当初有运动员A，B，先定义游戏规则：赛道目前是300米，每个运动员在跑完第一个100米时，须要期待其余运动员跑完第一个100米，比方运动员A先跑完100米，而此时运动员B只跑了95米，那运动员A必须要期待运动员B跑完残余的5米，而后再一起接着跑第2个100米，第三个100米，规定也和第1个100米类同，最初咱们能够得出一个论断，两个运动员跑完300米赛道，最长须要花多少工夫。【本案例纯属虚构，为了讲清楚CyclicBarrier】。上面咱们用代码模仿执行。 案例阐明import java.util.concurrent.BrokenBarrierException;import java.util.concurrent.CyclicBarrier;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * @author ：jiaolian * @date ：Created in 2021-03-01 14:56 * @description：回环屏障测试--接力赛 * @modified By： * 公众号:叫练 */public class CyclicBarrierTest { private static final int THREAD_COUNT = 2; private static CyclicBarrier cyclicBarrier = new CyclicBarrier(2,()->{ System.out.println(Thread.currentThread().getName()+"冲破屏障"); }); private static ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT); public static void main(String[] args) { Runnable myTask = new MyTask(); //初始化两个运动员 for (int i=0 ;i<THREAD_COUNT; i++) { executorService.submit(myTask); } } private static class MyTask implements Runnable { @Override public void run() { try { System.out.println(Thread.currentThread().getName()+"第1个100米"); cyclicBarrier.await(); System.out.println(Thread.currentThread().getName()+"第2个100米"); cyclicBarrier.await(); System.out.println(Thread.currentThread().getName()+"第3个100米"); cyclicBarrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } } }}如上代码：线程池模仿执行两个运动员，每个运动员执行完每个100米必须期待另一个运动员，执行后果和咱们构想统一，如下图所示。其中pool-1-thread-1，pool-1-thread-2别离示意运动员A，运动员B。CyclicBarrier初始化参数中有一个Runnable是用来冲破屏障回调的函数。 ...

join应用上篇咱们介绍了CountDownLatch，顺便说到了Thread中的join办法！ import java.util.concurrent.TimeUnit;/** * @author ：jiaolian * @date ：Created in 2021-02-28 21:43 * @description：join测试 * @modified By： * 公众号:叫练 */public class JoinTest { public static void main(String[] args) throws InterruptedException { Thread threadA = new Thread(()->{ try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":想先执行"); },"线程A"); //开启一个线程A threadA.start(); //主线程会持有子线程的锁,子线程还没开始主线程就阻塞了,期待子线程完结后告诉; threadA.join(); System.out.println(Thread.currentThread().getName()+ "线程执行"); }}如上代码所示：在JoinTest开启一个线程A，threadA调用join()办法，主线程会期待threadA执行结束！也就是两秒后，主线程执行最初一句话，运行后果如下图所示！ 咱们深刻源码，join办法底层其实就是一个wait办法，但当初问题是：明明调用者是线程A，可阻塞的是mian线程，不应该阻塞的是threadA吗？ 证实问题：明明调用者是线程A，可阻塞的是mian线程咱们参照Thread中join源码，将下面的代码革新如下： import java.util.concurrent.TimeUnit;/** * @author ：jiaolian * @date ：Created in 2021-02-28 21:43 * @description：join测试 * @modified By： * 公众号:叫练 */public class JoinCodeTest { public static void main(String[] args) throws InterruptedException { MyThread threadA = new MyThread("线程A"); //开启一个线程A threadA.start(); //主线程会持有子线程的锁,子线程还没开始主线程就阻塞了,期待子线程完结后告诉; threadA.join2(0); System.out.println(Thread.currentThread().getName()+ "线程执行"); } private static class MyThread extends Thread { public MyThread(String name) { super(name); } @Override public void run() { try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":想先执行"); } //复制Thread源码中的join办法测试阻塞的是线程A还是main线程？ public final synchronized void join2(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { //尽管调用者是线程A，但真正执行阻塞的是main线程！ System.out.println(Thread.currentThread().getName()+"会阻塞"); wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } } }}如上代码所示：MyThread继承Thread，并复制了join源码，将join批改成join2，并在join2办法中减少了一个输入语句，System.out.println(Thread.currentThread().getName()+"会阻塞")用来测试阻塞的是线程A还是main线程，所以在JoinCodeTest的main办法中ThreadA是调用join2办法， ...

看到的文章链接如下https://mp.weixin.qq.com/s/8G...题目如下 /** 2. 寻找特定 IPIPV4 的 IP 地址是32位的二进制数，为加强可读性，通常咱们以8位为1组进行宰割，用十进制来示意每一部分，并用点号连贯，譬如 192.168.1.1。显然，存在这样的 IP 地址，0到9十个数字各呈现一次。具备这样特色的 IP 地址里，示意成二进制数时，二进制数左右对称（也就是“回文”，示意成32位二进制不省略0）的状况有几种，别离是哪些？要求性能尽可能高*/记录下 可能有脱漏 最初后果是80种 有点相似算法题两数之和 可能还有更好的解法 临时还没想到 var findSpecialIp = function(nums, target) { let res = [] let m = new Map() let group = [] var isPalindrome = function(x) { // 查看回文 return x.toString() == x.toString().split("").reverse().join(""); }; let hasRepeatNum = function(...args) { let a = args.toString() let b = [...new Set(a.split(""))] return a.length !== b.length } let getIp = function([a,b], [c,d]) { //[16,8] [32,4] return [ `${a}.${c}.${d}.${b}`, `${b}.${c}.${d}.${a}`, `${a}.${d}.${c}.${b}`, `${b}.${d}.${c}.${a}` ] } for(let i = 0; i< 256; i++ ) { if(!hasRepeatNum(i) || i < 11) { let self = (i).toString(2).padStart(8, 0) // 转为2进制后补0 let re = self.split("").reverse().join("") // 翻转 if(!isPalindrome(self)) { //如果不是回文 if(m.has(self)) { // i 和 num 对称 组成回文 let num = m.get(self) if(!hasRepeatNum(i, num)) { group.push([i, num]) } } else { m.set(re, i) } } } } for(let i = 0 ; i < group.length; i++) { for(let j = i+1; j < group.length; j++) { if(!hasRepeatNum(group[i].join(""),group[j].join(""))) { res = res.concat(getIp(group[i], group[j])) } } } return res};

反射反射Java代码和Java文件Java代码根本格局 1. Java代码都在类内或者接口内 2. class 类名 { 成员变量 构造方法 成员办法 Annotation 注解 }Java文件要求: 1. 通常状况下一个Java文件对应一个Java类 2. Java文件蕴含以后Java代码的所有内容！！！Java文件和.class字节码文件Java文件 FirstJava.java 通过编译器 javac ==> javac FirstJava.java ==> FirstJava.class.class字节码文件是什么??? 二进制可执行文件。 .class字节码文件中会蕴含Java文件的所有内容。 .class字节码文件蕴含Java程序的所有可执行内容(正文不参加编译和执行)。class字节码文件在内存中的地位 class字节码文件和Java代码关系 Class类相干办法Class Class.forName(String packageNameAndClassName) throws ClassNotFoundException; 依据残缺的包名.类名获取对应的Class类对象 ClassNotFoundException 未找到指定类Class 类对象.getClass(); 通过类对象获取以后类对象对应的Class类对象 例如： Person p = new Person(); p.getClass() ==> Person类对应Class对象Class 类名.class; 通过类名获取以后类对应属性 Class对象 例如: Person.class ==> Person类对应Class对象。 package com.qfedu.a_reflect;/** * Class类办法演示 * * @author 期年之前ying@ * */public class GetClassObject { public static void main(String[] args) throws ClassNotFoundException { /* * Class Class.forName(String packageNameAndClassName) * throws ClassNotFoundException; */ Class cls1 = Class.forName("com.project.a_reflect.Person"); /* * Class 类对象.getClass(); */ Person person = new Person(); Class cls2 = person.getClass(); /* * Class 类名.class; */ Class cls3 = Person.class; /* * 不论是通过哪一种形式获取指定类的Class对象，都是同一个Class对象 * 因为以后Person类在以后程序中有且只占用一次代码区空间。 */ System.out.println("cls1 == cls2 : " + (cls1 == cls2)); System.out.println("cls2 == cls3 : " + (cls2 == cls3)); System.out.println("cls3 == cls1 : " + (cls3 == cls1)); }}操作Constructor 构造方法类通过Class类对象获取对应类的Constructor构造方法类对象Constructor[] getConstructors(); 获取以后Class对象对应类中所有非私有化构造方法类对象数组。 Constructor[] getDeclaredConstructors(); 【暴力反射】 获取以后Class对象对应类中的所有构造方法类对象数组，包含私有化构造方法。 Constructor getConstructor(Class... parameterTypes); 获取以后Class对象中，指定参数数据类型的构造方法。获取的构造方法为非私有化构造方法 Class... parameterTypes Class类型不定长参数，用于束缚以后构造方法对应的数据类型。 例如: 无参数构造方法 cls.getConstructor(); ==> Person(); 两个参数构造方法(int, String) cls.getConstructor(int.class, String.class) ==> Person(int, String) Constructor getDeclaredConstructor(Class... parameterTypes); 【暴力反射】 获取以后Class对象中，指定数据类型的构造方法，包含私有化构造方法 例如: 获取私有化String类型构造方法 cls.getDeclaredConstructor(String.class) ==> private Person(String.class)操作Constructor类对象创立对应类对象Object newInstance(Object... parameters); 通过Constructor类对象，执行对应的构造方法，创立对应类对象 Object... 不定长参数，要求数据类型为Object类型。 例如: Person(); 无参数构造方法 Person p1 = (Person) constructor.newInstance(); Person(int, java.lang.String); Person p2 = (Person) constructor.newInstance(10, "Java真好学"); package com.qfedu.a_reflect;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;/** * 操作Constructor构造方法类对象 * * @author 期年之前ying@ * */public class GetConstructorObject { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { /* * Class Class.forName(String packageNameAndClassName) * throws ClassNotFoundException; */ Class cls = Class.forName("com.project.a_reflect.Person"); /* * 1. 获取以后Class对象对应类中所有非私有化构造方法类对象数组 */ Constructor[] constructors = cls.getConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } System.out.println(); /* * 2. 【暴力反射】 * 获取以后Class对象对应类中的所有构造方法类对象数组，包含私有化构造方法。 */ Constructor[] declaredConstructors = cls.getDeclaredConstructors(); for (Constructor constructor : declaredConstructors) { System.out.println(constructor); } System.out.println(); /* * 3. 获取以后Class对象中，指定参数数据类型的构造方法。获取的构造方法为非私有化构造方法 */ Constructor constructor1 = cls.getConstructor(); Constructor constructor2 = cls.getConstructor(int.class); Constructor constructor3 = cls.getConstructor(int.class, String.class); System.out.println(constructor1); System.out.println(constructor2); System.out.println(constructor3); /* * 4. 【暴力反射】 * 获取以后Class对象中，指定数据类型的构造方法，包含私有化构造方法 */ Constructor constructor4 = cls.getDeclaredConstructor(String.class); System.out.println(constructor4); System.out.println(); /* * newInstance 创立类对象 */ Person p1 = (Person) constructor1.newInstance(); Person p2 = (Person) constructor2.newInstance(10); Person p3 = (Person) constructor3.newInstance(20, "张三爱Java"); System.out.println(p1); System.out.println(p2); System.out.println(p3); /* * 给予暴力反射操作应用权限！！！ * setAccessible(boolean flag); */ constructor4.setAccessible(true); Person p4 = (Person) constructor4.newInstance("Java高兴多"); System.out.println(p4); }}操作 Method 成员办法类通过Class类对象获取对应类的Method成员办法类对象Method[] getMethods(); 通过Class类对象调用，获取以后类内的所有非私有化成员办法，蕴含从父类继承而来子类能够应用的非私有化办法。 Method[] getDeclaredMethods(); 【暴力反射】 通过Class类对象调用，获取以后类内的所有成员办法，包含私有化成员办法，然而不包含从父类继承而来的办法。 Method getMethod(String methodName, Class... parameterTypes); 通过Class类对象调用，依据办法名称和对应的形式参数列表数据类型获取对应的成员办法，能够获取父类继承办法，不能获取私有化成员办法 例如: 无参数成员办法 获取 game(); cls.getMethod("game"); 有参数成员办法 获取 game(String); cls.getMethod("game", String.class); Method getDeclaredMethod(String methodName, Class... parameterTypes); 通过Class类对象调用，依据办法名称和对应的形式参数列表数据类型获取对应的成员办法，能够获取私有化成员办法，不能获取父类成员办法。 例如: 无参数私有化成员办法 testPrivate(); cls.getDeclaredMethod("testPrivate"); 有参数私有化成员办法 testPrivate(String); cls.getDeclaredMethod("testPrivate", String.class);操作Method类对象执行办法Object invoke(Object obj, Object... parameters); 通过Method类对象调用，执行对应办法。 Object obj 执行以后办法的类对象。 Object... parameters 对应以后办法的理论参数列表package com.qfedu.a_reflect;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;/** * 操作Method类对象 * * @author 期年之前ying@ * */public class GetMethodObject { public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { /* * Class Class.forName(String packageNameAndClassName) * throws ClassNotFoundException; */ Class cls = Class.forName("com.project.a_reflect.Person"); /* * 1. 通过Class类对象调用，获取以后类内的所有非私有化成员办法， * 蕴含从父类继承而来子类能够应用的非私有化办法。 */ Method[] methods = cls.getMethods(); for (Method method : methods) { System.out.println(method); } System.out.println(); /* * 2. 获取以后类自有成员办法，包含私有化办法，然而不蕴含父类继承给子类的办法 */ Method[] declaredMethods = cls.getDeclaredMethods(); for (Method method : declaredMethods) { System.out.println(method); } System.out.println(); /* * 3. 依据指定办法名字和参数类型，获取非私有化成员办法 */ Method game1 = cls.getMethod("game"); Method game2 = cls.getMethod("game", String.class); System.out.println(game1); System.out.println(game2); System.out.println(); /* * 4. 依据指定的办法名称和参数类型，获取私有化成员办法 */ Method testPrivate1 = cls.getDeclaredMethod("testPrivate"); Method testPrivate2 = cls.getDeclaredMethod("testPrivate", String.class); System.out.println(testPrivate1); System.out.println(testPrivate2); System.out.println(); /* * 调用办法 */ Object object = cls.getConstructor().newInstance(); game1.invoke(object); game2.invoke(object, "World Of Tank"); /* * 给予暴力反射操作权限 */ testPrivate1.setAccessible(true); testPrivate2.setAccessible(true); testPrivate1.invoke(object); testPrivate2.invoke(object, "西红柿+黄瓜+鸡蛋+羊肉串"); }}操作 Field 成员变量类通过Class类对象获取对应类的Field成员变量类对象Field[] getFields(); 获取类内所有非私有化成员变量数组 Field[] getDeclaredFields(); 【暴力反射】 获取类内所有成员变量数组，包含私有化成员变量Field getField(String fieldName); 依据成员变量名字获取对应的成员变量对象，要求以后成员变量非私有化 例如: public int test; cls.getField("test");Field getDeclaredField(String fieldName); 【暴力反射】 获取类内指定名字的成员变量对象，包含私有化成员变量 例如: private String name; private int id; cls.getDeclaredField("name"); cls.getDeclaredField("id"); 操作Field类对象赋值取值成员变量Field[] getFields(); 获取类内所有非私有化成员变量数组 Field[] getDeclaredFields(); 【暴力反射】 获取类内所有成员变量数组，包含私有化成员变量Field getField(String fieldName); 依据成员变量名字获取对应的成员变量对象，要求以后成员变量非私有化 例如: public int test; cls.getField("test");Field getDeclaredField(String fieldName); 【暴力反射】 获取类内指定名字的成员变量对象，包含私有化成员变量 例如: private String name; private int id; cls.getDeclaredField("name"); cls.getDeclaredField("id"); package com.qfedu.a_reflect;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;/** * 操作Field类对象 * * @author 期年之前ying@ * */public class GetFieldObject { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException { /* * Class Class.forName(String packageNameAndClassName) * throws ClassNotFoundException; */ Class cls = Class.forName("com.project.a_reflect.Person"); /* * 1. 获取类内所有非私有化成员变量数组 */ Field[] fields = cls.getFields(); for (Field field : fields) { System.out.println(field); } System.out.println(); /* * 2. 获取类内所有成员变量数组，包含私有化成员变量 */ Field[] declaredFields = cls.getDeclaredFields(); for (Field field : declaredFields) { System.out.println(field); } System.out.println(); /* * 3. 依据成员变量名字获取对应的成员变量对象，要求以后成员变量非私有化 */ Field test = cls.getField("test"); System.out.println(test); System.out.println(); /* * 4. 获取类内指定名字的成员变量对象，包含私有化成员变量 */ Field id = cls.getDeclaredField("id"); Field name = cls.getDeclaredField("name"); System.out.println(id); System.out.println(name); System.out.println(); /* * 取值赋值成员变量 */ Object obj = cls.getConstructor().newInstance(); System.out.println(obj); test.set(obj, 100); System.out.println(obj); System.out.println(test.get(obj)); id.setAccessible(true); name.setAccessible(true); id.set(obj, 10); name.set(obj, "大哥好英武"); System.out.println(obj); System.out.println(id.get(obj)); System.out.println(name.get(obj)); System.out.println(); System.out.println(id.getType()); System.out.println(name.getType()); }}暴力反射受权class AccessibleObject 类内办法public static void setAccessible(AccessibleObject[] array, boolean flag); 通过类名调用的动态工具形式，给予AccessibleObject类对象或者其子类对象数组，赋值操作权限。 子类对象包含： Field Method Constructor public void setAccessible(boolean flag); 通过AccessibleObject类对象调用，繁多权限受权，Field Method Constructor都能够应用。案例操作须要应用 1. String办法 2. IO流 举荐字符流操作 3. 反射 4. 自行理解 ==> String 转其余类型办法 百度 parse系列办法文件名: studentInfo.txt文件内容:className=com.qfedu.a_reflect.Studentname=李四age=18gender=falsejavaScore=59webScore=59dbScore=59指标 文件内容转Student类对象package com.qfedu.a_reflect;import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.util.Arrays;@SuppressWarnings("all")public class ReflectDemo { public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, NoSuchFieldException { // 1. 创立缓冲字符输出流 解决 文件 BufferedReader br = new BufferedReader(new FileReader("./data/studentInfo.txt")); // 2. 读取文件数据 String classInfo = br.readLine(); String className = classInfo.substring(classInfo.indexOf("=") + 1); // 3. 启动万恶之源 获取Class对象，加载指定类 Class cls = Class.forName(className); // 4. 创立对应类对象 Object obj = cls.getConstructor().newInstance(); // 5. 读取文件，利用循环操作 String info = null; Object value = null; // 每一次从文件中读取一行数据 while ((info = br.readLine()) != null) { // 依照 = 宰割信息 name=李四 String[] split = info.split("="); System.out.println(Arrays.toString(split)); // 依据信息获取对应成员变量对象 Field field = cls.getDeclaredField(split[0]); field.setAccessible(true); // 获取成员变量数据类型 Class type = field.getType(); // 以后成员变量数据为String类型 if (type.equals(String.class)) { value = split[1]; // field.set(obj, split[1]); // 成员变量数据类型为int类型 } else if (type.equals(int.class)) { value = Integer.parseInt(split[1]); // 成员变量数据类型为boolean类型 } else if (type.equals(boolean.class)) { value = Boolean.parseBoolean(split[1]); } field.set(obj, value); } System.out.println(obj); // 敞开资源 br.close(); }}最初欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！ 这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。 ...

目前筹备到了浏览器这部分，加上之前面试过程中，对于这部分的问题都答的很差，所以把一些自认为有价值的知识点整顿了进去。 什么是跨域？为什么浏览器要应用同源策略？你有几种形式能够解决跨域问题？理解预检申请嘛？浏览器的同源策略导致了跨域，同源策略属于浏览器的平安机制，如果协定、域名、端口有一个不同就是跨域，申请会失败。同源策略次要是用于防备CSRF攻打的。简略点说，CSRF 攻打是利用用户的登录态发动歹意申请。 解决跨域的办法： JSONP/CORS/代理服务 1.JSONP JSONP 的原理很简略，就是利用 <script> 标签没有跨域限度的破绽。通过 <script> 标签指向一个须要拜访的地址并提供一个回调函数来接收数据当须要通信时。JSONP 应用简略且兼容性不错，然而只限于 get 申请。 <script src="http://domain/api?param1=a&param2=b&callback=jsonp"></script><script>    function jsonp(data) { console.log(data) }</script>   2.CORS CORS 须要浏览器和后端同时反对。浏览器会主动进行 CORS 通信，实现 CORS 通信的要害是后端。只有后端实现了 CORS，就实现了跨域。服务端设置 Access-Control-Allow-Origin 就能够开启 CORS。 该属性示意哪些域名能够拜访资源，如果设置通配符则示意所有网站都能够拜访资源。尽管CORS和前端没什么关系，然而须要晓得通过这种形式解决跨域问题的话，发送的申请会别离为简略申请和简单申请。对于简单申请来说，首先会发动一个预检申请，该申请是 option 办法的，通过该申请来晓得服务端是否容许跨域申请。 3.代理通过代理把前端申请的域名转发到后端域名上，暗藏实在的服务端。可通过webpack或nigix实现。 有几种形式能够实现存储性能，别离有什么优缺点？什么是 Service Worker？cookie，localStorage，sessionStorage，indexDB皆可实现存储 个性cookielocalStoragesessionStorageindexDB数据生命周期个别由服务器生成，能够设置过期工夫除非被清理，否则始终存在页面敞开除非被清理，否则始终存在数据存储大小4K5M5M有限  对cookie应用时须要留神安全性 属性作用value如果用于保留用户登录态，应该将该值加密，不能应用明文的用户标识http-only不能通过 JS 拜访 Cookie，缩小 XSS 攻打secure只能在协定为 HTTPS 的申请中携带same-site规定浏览器不能在跨域申请中携带 Cookie，缩小 CSRF 攻打  Service Worker 是运行在浏览器背地的独立线程，个别能够用来实现缓存性能。应用 Service Worker的话，传输协定必须为 HTTPS。因为 Service Worker 中波及到申请拦挡，所以必须应用 HTTPS 协定来保障平安。实现缓存性能个别分为三个步骤： 首先须要先注册 Service Worker，而后监听到 install 事件当前就能够缓存须要的文件，在下次用户拜访的时候就能够通过拦挡申请的形式查问是否存在缓存，存在缓存的话就能够间接读取缓存文件，否则就去申请数据。事件的触发过程是怎么样的？晓得什么是事件代理嘛？  事件触发有三个阶段： window 往事件触发处流传，遇到注册的捕捉事件会触发流传到事件触发处时触发注册的事件从事件触发处往 window 流传，遇到注册的冒泡事件会触发 一般来说，如果咱们只心愿事件只触发在指标上，这时候能够应用 stopPropagation 来阻止事件的进一步流传。 事件代理如果一个节点中的子节点是动静生成的，那么子节点须要注册事件的话应该注册在父节点上事件代理的形式相较于间接给指标注册事件来说，因为不须要给子节点登记事件，所以节俭了内存。 ...

我将我本次面试遇到的面试题整顿成了一份面经，大家能够关注我的公众号【haxianhe】，回复 “面经” 支付。 一会儿就要办到职手续了，趁着这会儿没啥事，简略写一篇文章，分享一下本人的跳槽教训给大家，心愿能对大家有所帮忙。 个人经历我18年从华北电力大学毕业，毕业之后校招进入一家中小厂，这里就不提名字了。 工作了两年多了，这两头负责过独自的我的项目，设计过有深度的技术计划，也干过无脑的CRUD。 总的来说这段经验让我播种了很多，让我从一名糊涂无知的学生成长为一个能够扛起事的社会人。 因为还没有正式到职，很多货色就不具体说了，简略总结几点这期间的播种： 1.积攒很重要 从入职的第一天起就应该养成一个积攒笔记的好习惯，比方技术文档、线上问题、技术计划、线上总结、技术分享等等。这些内容的积攒对于本人前面无论是进步工作效率（不走反复的路），还是降职、面试都特地重要。 2.思考很重要,多想想我还能做什么 工作之后肯定要养成“实现工作后多想想我还能做点什么”的习惯。需要实现很简略，那就考虑一下能不能加一个降级逻辑让性能更强壮，或者考虑一下除了以后实现计划，业内还有哪些比拟成熟的实现计划，各自的优缺点各是什么等等，总之只有想做能做的事件很多很多。很多人都说本人始终在CRUD，然而到底是你只能CRUD，还是你抉择了CRUD呢，毕竟你做的更好也没有人会批评你。 3.把握住呈现“线上问题”的机会 性能做了只是具备了我的项目教训，然而面试的时候真正“值钱”的其实是技术的难点与解决方案，而个别技术难点广泛随同着“线上问题”。所以，平时工作中积极主动点，呈现了线上问题不论是不是本人的都去查、去解决，预先围绕着“问题景象、问题剖析、问题影响、解决方案、问题扩大”等去总结、记录到本人的笔记总，后续都是本人最贵重的财产。 面试教训我是跨语言面的 Java 开发岗，前前后后面了很多一二线互联网公司，其中包含腾讯，阿里，字节、快手、美团、滴滴、微博等等，累计拿到了快手、微博、好将来等大小公司的offer，最初决定去快手了。 上面概括性介绍一下我的面试经验，心愿能对大家换工作的时候有所借鉴。 首先在思考好的确想要跳槽之后，能够从上面这几点着手筹备面试温习： 指标企业工夫节点简历制作面试温习简历内推进行面试拿到offer指标企业 如果通过认真思考感觉本人的确想要面试换工作的话，那首先要思考的就是本人的指标企业是什么，是去大公司当螺丝钉、还是去一个中小公司当万金油。 也能够联合本人的畛域常识进行抉择，比方想做视频那就去抖音、快手、视频号，想做物流那就去顺丰、菜鸟、京东物流，想做娱乐内容那就去腾讯、字节、快手、微博，想做教育那就去猿辅导、作业帮、好将来。 工夫节点 工夫节点问题，包含面试工夫点、到职工夫点等。 首先是面试工夫点，你抉择不同的工夫节点去面试，拿到offer的难易水平齐全不同。同一个岗位，不同工夫点面试，难度和要求是不一样的，因为这要看缺人的水平和岗位HC的数量。 个别两种状况下比拟容易通过面试拿到offer： 急着招人干活的时候年底坑比拟多的时候先来说说急着招人干活的状况，因为团队招人总是滞后于需要的，所以很多团队总是不定时的会呈现“人不够用”的状况，每当这个时候因为急着找人进来干活所以对应聘者的要求也就没那么高。 再就是年底的时候，因为每年年底各个团队都须要做来年的打算，所以这个时候广泛须要多招一些人进来做更多的事件。再就是年底的时候每个公司为了应答来年可能呈现的人员散失，都会战略性的储备一些人。 所以，综上如果有熟人分割你某个岗位急招人是比拟好的机会，此外就是年底的时候换工作难度绝对会小一些。 如果你抉择了年底到职，这个时候你就须要思考你们公司的年终奖是什么时候发，你在哪个工夫点到职，进而你也就晓得了本人在哪个工夫内面试、拿offer是最划算的了，毕竟进去打工都是为了赚钱，没有情理和钱过不去。 简历制作 这部分我举荐一篇阮一峰的文章给大家 如何写一份无效的技术简历？我这里简略给大家总结一下，有须要的人去看具体的文章内容。 以我的项目为主体，设计你的简历针对企业的须要，突出你的技能我的项目的三要素（我的项目 = 产品 + 技术 + 后果）量化你的我的项目，给出数字面试温习 面试温习总体能够从上面这几个方面动手，大家能够参照着进行温习、筹备，后续这块我会独自写一篇文章来进行分享，有趣味的敌人能够关注一下我的公众号，也就这一两天。 简历内推 假如此时你曾经有心仪的公司、简历也筹备好了、面试温习也曾经进行的差不多了，那么就能够开始找人内推简历了，然而留神不要一上来就试本人想去的公司（ps：你要是大神就当我没说...），倡议先找两到三个公司试试水，比方你特地想去字节，那就能够先投递一下百度、滴滴、美团，面完之后依据本人的状况是再补救补救本人的有余还是去投递本人想去的公司。 上面再介绍一下具体的内推渠道，一般来说有两个比拟好的内推形式（ps：指的是技术人员）： 熟人内推，分割本人在各个大厂的同学、校友、前共事等等，一般来说熟人的内推品质会比拟高，通过的概率也会大一些。BOSS直聘，在下面有很多技术leader在找人，个别来找你的都是最近比拟有找人需要的，品质也很高。进行面试 对于进行面试有两点须要留神： 面试工夫，对于像字节、快手这种大小周的公司能够把面试工夫约在周末他们下班的时候，其余的公司能够把面试工夫约在工作日的早晨。面试节奏，不要短时间内高频面试，面试完须要反思、总结的，短时间高频面试会让你没有工夫思考总结，面试品质没有晋升不说，工夫长了还会让你疲惫不堪，倡议一周以一到两场面试为宜。拿到offer 拿到offer之后次要就是配合背调，确定入职工夫等，最重要的是要记得和上家公司和下家公司别离确定好社保缴纳问题，别断缴。 小结简略介绍了一下过来几年工作中的几点心得，总结了一下过来几个月的面试阶段。 后续还会写一篇文章介绍面试温习的具体内容，比方有哪些比拟举荐的面试内容开源我的项目、我整顿的mysql、redis、kafka等中间件的面试的面试温习笔记、如何通过自我介绍疏导面试官进行发问等等。 可能还会单开一篇文章介绍我是如何从PHP转的Java，讲讲社招如何转语言，说实话都说什么语言都一样，可是我遇到的除了字节之外就没有不看你语言的，所以也想以本人的亲身经历给大家介绍一下这方面如何去筹备。 此外，我还将我本次面试遇到的面试题整顿成了一份面经，大家能够关注我的公众号【haxianhe】，回复 “面经” 支付。

为什么 HashMap 容量 capacity 大小是 2 的 n 次幂？为什么应用 e.hash & (capacity - 1) 位运算作取模公式？为什么扩容时应用 e.hash & oldCap 来计算扩容后的数组索引？本文通过推导 HashMap 中的取模和扩容算法以答复上述问题。1. 按位与(&)运算的了解2. 取模运算 2.1 当 e.hash 为负数2.2 当 e.hash 为正数 正数取模怎么算 整数除法取整取模怎么算3. 扩容运算 3.1 推导 e.hash & oldCap = 0 时，y = x3.1 推导 e.hash & oldCap = 1 时，y = x + oldCap4.总结1. 按位与(&)运算的了解位运算的运算规定如下： 两个二进制的数按位与，如 A & B，当 B 中某一位为 1，则保留 A 上对应位上的数。假如 B = 1000(二进制)，第四位为 1。当 A = 1001(二进制)，A & B 获得第四位为 1，失去 A & B = 1000(二进制)；当 A = 0110(二进制)，A & B 获得第四位为 0，失去 A & B = 0000(二进制)； ...

前言Spring IOC管制反转是通过反射机制与工厂模式的联合，上面给大家模仿一下 生存案例引入2000 年，你们家开了一家叫 “笑笑” 的包子铺 ------爸2002 年，你们城东新开了一家分店 “笑笑” 包子铺------妈2004 年，你们城西也新开了一家分店"笑笑" 包子铺-----你…多年后，包子铺越开越多，口味难以保障…“笑笑” 包子铺老板：当前咱们几个外围班子只在一家做包子，所有分店不在做包子，间接来咱们这里提货即可        带来的益处：                1、所有包子铺的口味统一                2、所有包子铺不在关注做包子，只卖，做包子的过程(管制权限)–某一个工厂外面—IOC(Spring的管制反转)------>工厂模式 代码案例构建污浊类public class Book { private String name; private String author; private double price; public Book (){} @Override public String toString() { return "Book{" + "name='" + name + '\'' + ", author='" + author + '\'' + ", price=" + price + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } public Book(String name, String author, double price) { this.name = name; this.author = author; this.price = price; }}class AB extends Book{}class AC extends Book{}传统形式构建实例 //1、传统形式 //弊病：须要本人构建对象(new),若我的项目中有几百个类，通过该形式构建实例不可取 Book b1 = new AB(); Book b2 = new AC();污浊类的工厂类BookFactorypublic class BookFactory { //应用简略反射降级 public static Book getBook1() throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //1、先应用反射获取Book的Class对象 Properties pro = new Properties(); //2、获取配置文件信息，加载配置文件 pro.load(new FileInputStream("D://JavaServletProject//ServletDemo//ZhenAiDemoVersionTwo//src//org//soffteem//sources//book//book.properties")); //3、失去配置文件外面的key值，依据key值反射失去class对象 Class<Book> bookClass = (Class<Book>)Class.forName(pro.getProperty("className")); //4、获取有参结构器 Constructor<Book> cons = bookClass.getDeclaredConstructor(String.class,String.class,double.class); //5、通过反射构建对象实例 return cons.newInstance(pro.getProperty("name"),pro.getProperty("author"),Double.parseDouble(pro.getProperty("price"))); } //如果用户过去须要书，会依据类名去构建书对象，原始办法 public static Book getBook(String name){ Book book = null; if (name.equals("AB")){ b = new AB(); }else if (name.equals("AC")){ b = new AC(); }else { //....如果有很多的书籍屡次断定..... } return book; }}传统形式上降级//2、当初有了笑笑包子铺(污浊类工厂)//弊病：此时不须要构建对象，然而仍然须要手动输出对象名称 System.out.println("请您输出须要的书名"); //....此处省略局部代码...... Book book = BookFactory.getBook("你输出的名字");通过简略反射降级className=org.soffteem.myspring.Bookauthor=王大锤name=倚天屠龙记price=38.9//3、不必输出就能构建对象//弊病：如果不是Book对象而是其余对象呐？调用该工厂的这个办法只可能返回Book对象System.out.println("获取书籍：" + BookFactory.getBook1());相似Spring IOC容器的工厂构建XML文件<?xml version="1.0" encoding="utf-8" ?><beans> <!--书籍类--> <bean id="book" class="org.soffteem.myspring.Book"> <property name="name" value="倚天屠龙记"></property> <property name="author" value="金庸"></property> <property name="price" value="25.3"></property> </bean> <!--各种其余类--> <!--此处的student类没有展现--> <bean id="student" class="org.soffteem.test.Student"></bean></beans>相似"Spring IOC容器"类public class ApplicationContextUtils { //文档对象 Document document; //1、初始化文档对象 public ApplicationContextUtils() throws DocumentException { //1.1 通过dom4j的jar读取xml文件，获取文档对象 SAXReader reader = new SAXReader(); this.document = reader.read("D://JavaServletProject//ServletDemo//ZhenAiDemoVersionTwo//src//org//soffteem//sources//book//books.xml"); } //2、反射 + 汇合 + xml解析 获取Bean实例 public <T>T getBean(String id,Class<T> tc) throws ClassNotFoundException, IllegalAccessException, InstantiationException { //2.1 解析xml文件，获取根节点 <beans><beans> Element element = document.getRootElement(); //2.2 获取根节点(<beans>)所有的子节点 <bean></bean> List<Element> list = element.elements(); //3、迭代所有的<bean>节点 for (Element e:list){ //3.1 失去<bean>子节点中id的值 String myId = e.attributeValue("id"); //3.2 失去<bean>子节点中class的数值 String className = e.attributeValue("class"); //3.3 断定:依据用户输出的id进行指定的实例化 //因为此处可能不只只有一个污浊类的节点配置项，要依据用户输出的id值实例化执行的配置节点 if (myId.equals(id)){ //3.3.1 反射以后id对应的className的class对象 Class c = Class.forName(className); //3.3.2 再次断定：若是父类呐？此处判断父类我是通过class对象断定的 if (c == tc){ //3.3.3 通过反射构建对象 T obj = tc.newInstance(); //3.3.4 失去以后<bean>节点中的所有<properties>子节点 List<Element> props = e.elements(); //3.3.5 失去所有的孙子节点对象<properties> for (Element prop:props){ //3.3.5.1 失去孙子节点的每一个属性内容name与value对应的值 String name = prop.attributeValue("name"); String value = prop.attributeValue("value"); //3.3.5.2 将内容赋值到对象属性中 setAttribute(tc.getDeclaredFields(),obj,name,value); } //返回对象 return obj; } } } return null; } //封装给属性赋值的办法 //① 须要失去所有的属性 ② 给哪个对象赋值 ③ 给哪个属性赋值 ④赋值的内容 public <T>void setAttribute(Field[] fields,T obj,String key,String value) throws IllegalAccessException { //1、循环属性，失去具体的属性值 for (Field field:fields){ //2、要想给属性赋值，因为属性是公有的，须要设置属性的拜访权限 field.setAccessible(true); //3、考虑一下属性的类型：根本属性类型、对象类型 Class type = field.getType();//获取以后属性字段field的类型 //此处我只写了几个根本数据类型，其余类型可自行添加...... if (key.equals(field.getName())){ if (type == int.class){ field.set(obj,Integer.parseInt(value)); }else if (type == double.class){ field.set(obj,Double.parseDouble(value)); }else if (type == String.class){ field.set(obj,value); }else { //若是对象类型 field.set(obj,value); } } } }}模仿"Spring容器"构建实例//1、构建 "Spring容器" 最先实例化可通过on-load-startup属性,前期交给tomcat容器ApplicationContextUtils application = new ApplicationContextUtils();//2、通过"Spring容器"联合配置文件的Id属性值获取Book对象Book book = application.getBean("book",Book.class);//3、格式化输入对象，进行内容展现System.out.println(book.toString());模仿"Spring容器"构建实例步骤总结构建污浊类，也就是JavaBean类构建工厂类，便于JavaBean通过工厂创立实例实例化工厂，调用工厂类的办法获取实例对象Spring IOC获取实例步骤总结构建污浊类构建Spring框架的配置文件将污浊类注入到配置文件中实例化Spring容器，通过getBean()办法依据Id属性值来获取对应的实例最初欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！ 这些材料的内容都是面试时面试官必问的知识点，篇章包含了很多知识点，其中包含了有基础知识、Java汇合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。 ...

CountDownLatch理论利用明天是正月十五，给大家拜个暮年啦！ 元宵节是中国传统节日，吃汤圆不能少啊，明天咱们统计下“叫练”吃汤圆工夫，并用代码模仿下叫练吃汤圆！其中用到咱们的CountDownLatch了！ import java.util.concurrent.CountDownLatch;import java.util.concurrent.TimeUnit;/** * @author ：jiaolian * @date ：Created in 2021-02-26 14:49 * @description：CountDownLatch模仿统计吃汤圆破费工夫 * @modified By： * 公众号:叫练 */public class CountDownLatchSpeedTimeTest { public static void main(String[] args) throws InterruptedException { //定义一个CountDownLatch计数器 CountDownLatch countDownLatch = new CountDownLatch(1); long start = System.currentTimeMillis(); //创立一个“叫练”线程吃汤圆 new Thread(()->{ int time = (int)(Math.random()*10) + 1; //模仿统计吃汤圆破费 try { TimeUnit.SECONDS.sleep(time); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"吃完汤圆"); //计数器递加 countDownLatch.countDown(); },"叫练线程").start(); //主线程阻塞期待"叫练线程"执行结束 countDownLatch.await(); System.out.println("主线程：吃汤圆共破费"+(System.currentTimeMillis()-start)+"毫秒"); }}如上代码所示：一共有两个线程，主线程和自定义“叫练”线程，在主线程中定义一个CountDownLatch计数器，初始值为1，创立一个“叫练”线程用随机数模仿吃汤圆工夫，主线程调用countDownLatch.await()阻塞期待"叫练线程"执行结束，最初主线程统计“叫练”线程执行吃完汤圆所破费工夫。执行可能后果如下图所示。 ...

思维导图 变量晋升机制一.什么是变量晋升？变量晋升示例/* 你应该见过上面的相似代码，那你晓得这是为什么*/console.log(a) // undefinedvar a = 10定义：变量晋升是当栈内存作用域造成时，JS代码执行前，浏览器会将带有var, function关键字的变量提前进行申明 declare(值默认就是 undefined)，定义 defined(就是赋值操作)，这种事后解决的机制就叫做变量晋升机制也叫预约义。在变量晋升阶段：带 var 的只申明还没有被定义，带 function 的曾经申明和定义。所以在代码执行前有带 var 的就提前申明，比方这里的 a 就赋值成 undefined，在代码执行过程中遇到创立函数的代码浏览器会间接跳过。不思考变量晋升阶段的 js 运行机制相干参考 JS 运行机制根底版 解说示例var a =12var b = ab = 1function sum(x, y) { var total = x + y return total}sum(1, 2) PS: 函数在调用时创立执行上下文对象还有其余要害的步骤作用域创立，this指向等这些内容放在前面文章讲，这样的机制有点相似变量晋升。上面的函数创立过程都会被按作相似于变量晋升来了解。变量晋升只产生在以后作用域。比方：在页面开始加载时，只有全局作用域产生变量晋升，这时候的函数中存储的都是代码字符串。二. 带 var 和不带 var 的区别全局作用域中不带var申明变量尽管也能够然而倡议带上 var申明变量，不带 var 的相当于给window对象设置一个属性罢了。公有作用域(函数作用域)，带 var 的是公有变量。不带 var 的是会向下级作用域查找，如果下级作用域也没有那么就始终找到 window 为止，这个查找过程叫作用域链。全局作用域中应用 var 申明的变量会映射到 window 下成为属性。a = 12 // == window.aconsole.log(a) // 12console.log(window.a) // 12var a = b =12 // 这里的 b 也是不带 var 的。/* 相当于*/var a = 12;b = 12思考题问上面别离输入什么？// 1console.log(a, b)var a =12, b ='林一一'function foo(){// 2 console.log(a, b)// 3 var a = b =13 console.log(a, b)}foo()console.log(a, b)/* 输入： undefined undefined undefined "林一一" 13 13 12 13*/2.. 问上面的后果和下面的有何不同？console.log(a, b)var a =12, b = '林一一'function foo(){ console.log(a, b)// var a =b =13 console.log(a, b)}foo()// 4console.log(a, b)/* 输入： undefined undefined 12 "林一一" 12 "林一一" 12 "林一一*/解答下面的思考题不晓得你都对了没，上面让我来解答，详情看图思路：1处的 a, b 其实就是window上面的属性为 undefined。在函数外部因为变量晋升机制 a带 var 一开始就是 undefined，b不带var 将向下级作用域查找，找到全局作用域下的林一一所以2处打印进去的就是 undefined "林一一"。随后 a =13，window.b =13，即原来 b='林一一' 变成了 b=13，打印出13, 13，最初第4处打印处12, 13。所以联合流程图，很显著晓得答案 ...

线程与过程概念过程：过程指的是一段正在运行的程序线程：一个程序运行中能够执行多个工作，工作就称之为线程。过程能够有多个线程，各个线程之间共享程序的内存空间 为什么有了过程，还会呈现线程？每个过程有本人独立的地址空间，多并发申请，为每一个申请创立一个过程，导致系统开销、用户申请效率低 区别每个过程有用本人独有的变量，线程共享数据，线程之间的通信相比于过程之间的通信更加无效，更加容易线程相比于过程创立/销毁开销 更小过程是资源分配的最小单位，线程是CPU调度的最小单位多过程程序更加强壮，多线程程序只有有一个线程挂掉，对其共享资源的其余线程也回产生影响如果谋求速度，谋求零碎稳固抉择线程；如果频繁的创立和销毁，抉择线程； 线程的创立说完线程的基本知识，那么久要谈谈在利用中，咱们应该如何创立线程，理论利用中创立线程次要有以下四种办法，如下： 办法一：继承Thread类，重写run()办法class MyThread extends Thread{ @Override public void run() { while(true){ System.out.println("eat food"); } }}public class TestDemo1 { public static void main(String[] args) { //边吃饭边看电视 //创立子线程对象 Thread thread = new MyThread(); //启动吃饭的thread thread.run(); //main线程 while(true){ System.out.println("watch Tv"); } } }办法二：实现Runable接口class MyRunnable implements Runnable{ @Override public void run() { while(true){ System.out.println("eat food"); } }}public class TestDemo1 { public static void main(String[] args) { //实现runnable接口 创立子线程 创立子线程对象 Thread thread = new Thread(new MyRunnable()); thread.start(); } }办法三：匿名线程 应用匿名外部类 //匿名外部类 创立线程 new Thread(){ @Override public void run() { System.out.println("thread 0"); } }.start();办法四：实现Callable接口，重写call()办法利用Callable创立时，步骤较为简单，具体如下：a.创立Callable接口的实现类，重写call办法b.创立Callable实现类的实例，应用FutureTask包装该实例c.将FutureTask实例作为参数创立线程对象d.启动该线程e.调用FutureTask的get办法获取子线程的执行后果 ...

computed: show me the code computed : { foo() { if(this.a>0){ return this.a} else { return this.b + this.c }}}data() { a: 1,b: 1,c: 1,}计算属性会缓存上一次的计算结果，强调:是上一次而不是所有历史；每次调用this.foo，是返回上一次的后果还是执行foo函数返回最新的后果? 是靠computed的响应式结构器外部的变量dirty管制，dirty为true就执行foo，返回最新的后果，否则就返回缓存的值，并且每次执行foo当前，都会把dirty还原为false也就是说 dirty 管制了是否从缓存里读取值，那么什么时候dirty会被批改为true呢? deps有批改或者新增(不便记忆，并不是新增会触发，而是新增时也会同步的触发dirty的批改)的时候；computed的响应式结构器外部除了有dirty还有一个deps的数组，数组项是foo这个计算属性的依赖项，留神了，这个依赖不是代码外表上的this.a，this.b，this.c，而是在执行foo函数时，只有触发了某个值的getter，才会被增加到依赖数组，deps默认为[]，当第一次执行foo函数时，碰到if(this.a)，触发了this.a的getters，就把this.a增加到deps，这时，依赖性里只有this.a，并且同步批改dirty为true，继续执行foo函数，返回最新的后果 伪代码示意就是假如此时deps里只有this.a 执行this.b='2'if(!deps.includes('this.b')){return 上一次的值}执行this.a=2，返回最新的值， 如果刚开始时 this.a=-1，依赖数组里有a,b,c，这个时候this.a=-2，新值和旧值一样，那么会返回上一次的值呢还是会从新计算? 如果返回上一次的值(foo中的console没有执行)，就阐明这个实践有问题，

一.LinkedList数据结构1.1 数据结构LinkedList 底层数据结构是一个双向链表，整体构造如下图所示： 注意事项：链表每个节点叫做 Node，Node 有 prev 属性，代表前一个节点的地位，next 属性，代表后一个节点的位 置first 是双向链表的头节点，它的前一个节点是 null。last 是双向链表的尾节点，它的后一个节点是 null；当链表中没有数据时，first 和 last 是同一个节点，前后指向都是 null；因为是个双向链表，是没有大小限度的。1.2 Node private static class Node<E> { E item; // 节点值 Node<E> next; // 指向的下一个节点 Node<E> prev; // 指向的前一个节点 Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }二.源码剖析2.1 LinkedList类正文解析应用“双向链表”来实现List与Deque接口。 实现了所有List接口中的办法，并且容许寄存所有元素，包含Null。所有的操作都可通过双向链表实现。通过从结尾或者结尾遍历汇合，去靠近要操作的那个元素。是非线程平安的，多线程状况下，举荐应用线程安全类：Collections#synchronizedList加强 for 循环，或者应用迭代器迭代过程中，如果数组大小被扭转，会疾速失败，抛出异样。2.2 新增源码解析： 新增节点时，咱们能够抉择追加到链表头部，还是追加到链表尾部，add 办法默认是从尾部开始追加，addFirst 方 法是从头部开始追加： 增加： /** * 将元素增加到链表尾部，等于addFirst */ public boolean add(E e) { linkLast(e); return true; }从尾部减少： /** * 从尾部开始追加节点 */ void linkLast(E e) { // 把尾节点数据暂存 final Node<E> l = last; // 新建新的节点，初始化入参含意： // l 是新节点的前一个节点，以后值是尾节点值 // e 示意以后新增节点，以后新增节点后一个节点是 null final Node<E> newNode = new Node<>(l, e, null); // 将新建节点追加到尾部 last = newNode; //如果链表为空 l 是尾节点，尾节点为空，链表即空，头部和尾部是同一个节点，都是新建的节点 if (l == null) first = newNode; else //否则把前尾节点的下一个节点，指向以后尾节点。 l.next = newNode; //大小和版本更改 size++; modCount++; }从头部减少： /** *从头部开始追加节点 */ private void linkFirst(E e) { // 把头节点数据暂存 final Node<E> f = first; // 新建新的节点，初始化入参含意： // l 是新节点的前一个节点，以后值是尾节点值 // f 示意以后新增节点，以后新增节点后一个节点是 null final Node<E> newNode = new Node<>(null, e, f); // 将新建节点追加到头部 first = newNode; //如果链表为空 f 是头节点，头节点为空，链表即空，头部和尾部是同一个节点，都是新建的节点 if (f == null) last = newNode; else //上一个头节点的前一个节点指向以后节点 f.prev = newNode; size++; modCount++; }注意事项：头部追加节点和尾部追加节点，只是前者是挪动头节点的 prev 指向，后者是挪动尾节点的 next 指向，两者区别不大。2.3 删除实现源码解析：LinkedList节点删除的形式和追加相似，咱们能够抉择从头部删除，也能够抉择从尾部删除，删除操作会把节点的值，前后指 ...

写在后面又到了年底跳槽顶峰季，很多小伙伴进来面试时，不少面试官都会问到音讯队列的问题，不少小伙伴答复的不是很完满，有些小伙伴是心里晓得答案，嘴上却没有很好的表达出来，究其根本原因，还是对相干的知识点了解的不够透彻。明天，咱们就一起来探讨下这个话题。注：文章有点长，你说你能一鼓作气看完，我有点不信！！ 文章已收录到： https://github.com/sunshinelyz/technology-binghe https://gitee.com/binghe001/technology-binghe 什么是音讯队列？音讯队列（Message Queue）是在音讯的传输过程中保留音讯的容器，是利用间的通信形式。音讯发送后能够立刻返回，由音讯零碎保障音讯的牢靠传输，音讯发布者只管把音讯写到队列外面而不必思考谁须要音讯，而音讯的使用者也不须要晓得谁公布的音讯，只管到音讯队列外面取，这样生产和生产便能够做到拆散。 为什么要应用音讯队列？长处： 异步解决：例如短信告诉、终端状态推送、App推送、用户注册等数据同步：业务数据推送同步重试弥补：记账失败重试零碎解耦：通信上下行、终端异样监控、分布式事件核心流量消峰：秒杀场景下的下单解决公布订阅：HSF的服务状态变动告诉、分布式事件核心高并发缓冲：日志服务、监控上报应用音讯队列比拟外围的作用就是：解耦、异步、削峰。 毛病： 零碎可用性升高 零碎引入的内部依赖越多，越容易挂掉？如何保障音讯队列的高可用？零碎复杂度进步 怎么保障音讯没有反复生产？怎么解决音讯失落的状况？怎么保障消息传递的程序性？一致性问题 A 零碎解决完了间接返回胜利了，人都认为你这个申请就胜利了；然而问题是，要是 BCD 三个零碎那里，BD 两个零碎写库胜利了，后果 C 零碎写库失败了，咋整？你这数据就不统一了。以下次要探讨的RabbitMQ和Kafka两种音讯队列。 如何保障音讯队列的高可用？RabbitMQ的高可用RabbitMQ的高可用是基于主从（非分布式）做高可用性。RabbitMQ 有三种模式：单机模式（Demo级别）、一般集群模式（无高可用性）、镜像集群模式（高可用性）。 一般集群模式一般集群模式，意思就是在多台机器上启动多个 RabbitMQ 实例，每个机器启动一个。你创立的 queue，只会放在一个 RabbitMQ 实例上，然而每个实例都同步 queue 的元数据（元数据能够认为是 queue 的一些配置信息，通过元数据，能够找到 queue 所在实例）。你生产的时候，实际上如果连贯到了另外一个实例，那么那个实例会从 queue 所在实例上拉取数据过去。 这种形式的确很麻烦，也不怎么好，没做到所谓的分布式，就是个一般集群。因为这导致你要么消费者每次随机连贯一个实例而后拉取数据，要么固定连贯那个 queue 所在实例生产数据，前者有数据拉取的开销，后者导致单实例性能瓶颈。 而且如果那个放 queue 的实例宕机了，会导致接下来其余实例就无奈从那个实例拉取，如果你开启了音讯长久化，让 RabbitMQ 落地存储音讯的话，音讯不肯定会丢，得等这个实例复原了，而后才能够持续从这个 queue 拉取数据。 所以这个事儿就比拟难堪了，这就没有什么所谓的高可用性，这计划次要是进步吞吐量的，就是说让集群中多个节点来服务某个 queue 的读写操作。 镜像集群模式这种模式，才是所谓的 RabbitMQ 的高可用模式。跟一般集群模式不一样的是，在镜像集群模式下，你创立的 queue，无论元数据还是 queue 里的音讯都会存在于多个实例上，就是说，每个 RabbitMQ 节点都有这个 queue 的一个残缺镜像，蕴含 queue 的全副数据的意思。而后每次你写音讯到 queue 的时候，都会主动把音讯同步到多个实例的 queue 上。 那么如何开启这个镜像集群模式呢？其实很简略，RabbitMQ 有很好的治理控制台，就是在后盾新增一个策略，这个策略是镜像集群模式的策略，指定的时候是能够要求数据同步到所有节点的，也能够要求同步到指定数量的节点，再次创立 queue 的时候，利用这个策略，就会主动将数据同步到其余的节点下来了。 ...

如果你已经经验过面试，那么肯定听到过面试官的这句话——你有什么问题要问吗?事实上，面试官心愿你能问一些有价值的问题来确定你对这份工作的趣味和激情。此外，向面试官提出相干问题不仅能给你留下良好的印象，还能帮忙你理解一些对公司有用的见解，比方公司的环境、你的日常工作、将来的机会等等。 然而，在面试过程中，你能够在脑海中想出各种各样的问题，然而在面试前筹备好几个问题会加强你的信念，让你在其余求职者中有劣势。当初你肯定在想——在面试中应该问哪些有影响力的问题?不必放心，在这篇文章中，咱们会通知你几个最受欢迎的问题，你能够向面试官发问，从而给面试官留下好印象，减少你面试胜利的机会。 1. 你能通知我公司文化和价值观吗? 你能够从这里开始发问。这个问题将帮忙你理解公司的文化和外围价值观，从而进一步帮忙你辨认公司的工作环境。问这个问题的另一个目标是让面试官晓得你真的对这份工作感兴趣和关怀，想晓得公司对这份工作的要求。 2. 这份工作我的主要职责是什么? 这个问题能够帮忙你具体理解你的工作角色，以及你在公司的日常工作职责。不过你要记住，如果你每天的职责在工作形容中曾经被分明详尽地提到，那么尽量避免问这个问题。 3.这份工作最大的挑战是什么? 这里有另一个突出的问题!首先，它会让你理解工作的理论状况，并帮忙你对将来的工作岗位做好筹备。其次，当你具体探讨这个问题时，面试官会对你面对挑战的能力有一个理解。 4. 职业发展前景如何? 这也是一个能够问面试官的相干问题。它会帮忙你理解公司将来的职业倒退过程。这个问题还能够让面试官感触到你在这家公司的长期愿景。此外，你必须确保不要问一些与职业倒退无关的不必要或不明智的问题，比方——我什么时候会加薪或升职，等等。 5. 员工有职业倒退的机会吗? 在这里，你能够询问这家公司是否推广职业倒退文化，是否提供一些职业倒退我的项目。这样你就能晓得公司是否给员工提供了学习和成长的机会。这也能够让面试官理解你的学习和职业倒退指标。然而，在问这个问题的时候，你必须记住，这个问题听起来不能太自私或个人主义，因为这会给面试官带来负面影响。 6.公司将来的指标是什么? 事实上，除了询问职业倒退和其余职业倒退机会，你还须要询问公司将来的指标。这样能够让面试官看到你对公司和工作机会的关注和好奇。此外，你也能够把这个问题转化为一个机会，让面试官晓得你之前对公司的钻研，分享一些对于公司将来指标的要害见解或信息。 7. 公司如何评估员工的体现? 你能够通过问这个问题来表白你对这份工作的好奇以及你对在这家公司长期工作的愿景。 同时，这也会帮你找到一些对于该公司的工作详情和职业倒退的额定有价值的信息，这对你将来的倒退有帮忙。通过这个问题，你能够理解公司的几个要害绩效指标和其余绩效衡量标准。 8. 对于我的资格、简历等，还有什么须要我廓清的吗? 你必须记住，面试还没有完结，你还有机会给面试官留下深刻印象，并展现一些面试官还没有探讨到的技能和劣势。因而，倡议你问问面试官，你是否有更多的货色能够提供给他，对你的评估和做出最终决定有帮忙。不过，不要从特定的工作背景的角度来吹牛任何不相干或不必要的技能。 9. 依据我的面试体现，你想给我什么倡议? 你能够向面试官询问一些对于你面试体现的倡议或反馈，以留下正确的印象，并与面试官建设更好的业余分割。这不仅会向面试官展现你乐观和踊跃的本色，也会帮忙你失去一些有价值的倡议，这些倡议将进一步对你将来的面试或其余职业机会有很大帮忙。 10. 面试过程的下一步是什么? 只管这个问题能够被认为是后续工作的一部分，你也能够向面试官提出这个问题来展现你对这个工作机会的激情和奉献精神。同时，它也会帮忙你理解下一步的面试流程和相应的时间表，为你本人做相应的筹备。然而，问这个问题的时候你要体现得十分业余，不要体现得太急或不耐烦。 这些是你在面试中能够问的几个最受举荐的问题，能够给面试官带来踊跃的影响。 然而，你也能够依据面试的状况问一些其余的问题。 要记住的是，这些问题应该是具体的，和工作相干的!!

面向对象要了解面向对象思维，咱们先要晓得什么是对象？ 《Java编程思维》中提到“万物皆为对象”的概念。它将对象视为一种奇异的变量，它除了能够存储数据之外还能够对它本身进行操作。它可能间接反映现实生活中的事物，例如人、车、小鸟等，将其示意为程序中的对象。每个对象都具备各自的状态特色（也能够称为属性）及行为特色（办法），java就是通过对象之间行为的交互来解决问题的。 面向对象就是把形成问题的事物分解成一个个对象，建设对象不是为了实现一个步骤，而是为了形容某个事物在解决问题中的行为。 类是面向对象中的一个很重要的概念，因为类是很多个具备雷同属性和行为特色的对象所形象进去的，对象是类的一个实例。 类具备三个个性：封装、继承和多态。 三大特色 封装：核心思想就是“暗藏细节”、“数据安全”，将对象不须要让外界拜访的成员变量和办法私有化，只提供合乎开发者志愿的私有办法来拜访这些数据和逻辑，保障了数据的平安和程序的稳固。所有的内容对外部不可见。继承：子类能够继承父类的属性和办法，并对其进行拓展。将其余的性能继承下来持续倒退 。多态：同一种类型的对象执行同一个办法时能够体现出不同的行为特色。通过继承的高低转型、接口的回调以及办法的重写和重载能够实现多态。办法的重载自身就是一个多态性的体现。三大思维 面向对象思维从概念上讲分为以下三种：OOA、OOD、OOP OOA：面向对象分析（Object Oriented Analysis） OOD：面向对象设计（Object Oriented Design） OOP：面向对象程序（Object Oriented Programming ） 类与对象类示意一个共性的产物，是一个综合的特色，而对象，是一个共性的产物，是一个个体的特色。 （相似生存中的图纸与实物的概念。） 类必须通过对象才能够应用，对象的所有操作都在类中定义。 类由属性和办法组成： 属性：就相当于人的一个个的特色办法：就相当于人的一个个的行为，例如：谈话、吃饭、唱歌、睡觉一个类要想真正的进行操作，则必须依附对象，对象的定义格局如下: 类名称 对象名称 = new 类名称() ; 如果要想拜访类中的属性或办法（办法的定义），则能够依附以下的语法模式： 拜访类中的属性： 对象.属性 ; 调用类中的办法： 对象.办法(理论参数列表) ; 类必须编写在.java文件中；一个.java文件中，能够存在N个类，然而只能存在一个public润饰的类；.java文件的文件名必须与public润饰的类名齐全始终；同一个包中不能有重名的类；匿名对象没有对象名称的对象就是匿名对象。 即栈内存中没有名字，而堆内存中有对象。匿名对象只能应用一次，因为没有任何的对象援用，所以将称为垃圾，期待被GC回收。只应用一次的对象能够通过匿名对象的形式实现，这一点在当前的开发中将常常应用到。public static void main(String[] args){ //Math2 m=new Math2(); //int num=m.sum(100,200); //不通过创建对象名，间接实例对象调用，这就是匿名对象。因为没有对象名指向对象，所以只能调用一次，而后被GC回收。 int num = new Math().sum(100,200); System.out.println(num);}class Math2{ int sum(int x,int y){ return x+y; }}对象内存剖析如下图所示： 创建对象的内存剖析栈(stack)Java栈的区域很小 , 大略2m左右 , 特点是存取的速度特地快 栈存储的特点是：先进后出 存储速度快的起因: 栈内存, 通过 ‘栈指针’ 来创立空间与开释空间 ! ...

前言自己状况：双非一般一本，JAVA后盾开发，第一次面试，面的不是很好...我的项目相干：简略介绍本人做的我的项目以及特点说说同时购物零碎两个人同时付款时如何解决？答了加锁，还有音讯队列，然而如同不是面试官要的答案，间接说了不晓得..说一说淘宝零碎如何解决高并发下客户申请（这些都没有温习过，之前有看过一些，然而太紧张了，一个都答不进去）如何进步SQL查问效率，在语句方面上的优化？ 另外我这里为大家筹备了一线大厂面试材料和我原创的超硬核PDF技术文档，以及我为大家精心筹备的多套大厂面试题（不断更新中），有须要的敌人点这里备注csdn自行下载就好！心愿大家都能找到心仪的工作！ 一面你 Java 是自学的吗，还是跟着学校课程学的，那你看的是哪一本书？有理解 Java 的设计模式吗？你感觉 Spring 框架的 Listener 是什么模式，你用过吗？你对 Spring 的理解是通过什么学习的呢？你能说一下 Listener 的执行程序吗？你理解 Spring 的 AOP 编程吗？那 AOP 有几种切面？你经验外面比拟骄傲，或者说比拟难的中央在哪里？上一问我说对 Java 根底和 MySQL 这块看的比拟多，而后持续诘问你晓得 String 类型在 JVM 外面是怎么体现得吗？你对 JVM 的堆栈有理解吗？String 类型的变量个别存在哪里？这里引出了常量池，而后开始了夺命四连问。如果我定义了一个 String 类型的公有成员 a1，我给他赋了一个初始值，比如说 "abc"，而后我在另一个类外面，也有一个值为 "abc" 的成员变量 a2，如果比拟 a1 == a2，它会相等吗？如果我在一个办法外面定义了一个局部变量 a3，如果比拟 a3 == a1，你感觉会相等吗？如果 a4 = new String("abc")，你感觉这个 a4 会和 a3 相等吗？那如果变量没有 final 润饰，就是 public static String a5，我在构造函数外面给 a5 赋值为 "abc"，你感觉它会和 a1 相等吗？你这边我的项目外面写的集体博客是你本科时候本人验证测试的对吧？Nginx 在你在网上看的博客学的吗？那你能跟我说一下 Nginx 能做几层代理的转发吗？它在 OSI 的第几层？它除了应用层还有别的模式吗？它可能代理 SSH 协定吗？那应用层有什么协定？SSH 协定你晓得它工作在哪一层吗？WebSocket 你晓得工作在哪一层吗？它跟 Socket 有什么区别？你刚讲到你在 DB 这一块比拟善于，具体是哪个 DB？你看了 MySQL 什么书吗？MySQL 的主从你能讲一讲吗？MySQL 有什么命令能够拿到我以后卡住的 SQL？慢查问日志怎么开？如何查看历史的慢查问语句？不开慢查问的话，怎么晓得 MySQL 外面哪里语句执行比拟久？你次要相熟索引这一块是吧，MySQL 的 text 字段能够建索引吗？那如果我只存几个字符呢？它能设前缀索引吗？如果不是前缀索引，就是全列索引，我用 LIKE 查问，LIKE abc%，它会命中索引吗？它为什么能命中索引，匹配程序是什么样的？如果 LIKE %abc，它会命中索引吗？MySQL 中 JSON 的数据格式有理解过吗？你有理解 MySQL 8 的新个性吗？你这里 RPC 框架也是测试项目吗？你有理解过业界的一些 RPC 框架吗？尤其是 Java 畛域？Java 的 RMI 你理解过吗？RMI 和 RPC 有什么区别？Java 的 JMX 理解过吗？Java 的 Bean 有理解过吗？JavaBean 是什么？JavaBean 要合乎什么样的条件？你这边有加入什么较量吗？你对音讯队列有理解吗？你理解过现有的音讯队列吗？数据结构这一块我问一个问题，如果我当初有一个矩阵运算，我心愿你用 Java 来实现，你会怎么去设计这个数据结构？运算过程怎么运算？你感觉是用数组好还是用 List 好？Java 外面，如果我要对一个 List 进行排序，你晓得它外部是怎么实现 sort() 办法的吗？它外面除了快排还有什么排序？它通过什么来判断调用哪种类型的排序？我看你这里写着喜爱关注一些新技术的倒退动向，这一点我比拟好奇在你眼里什么算是新技术，你会关注哪些方面？新技术就 Java？开始怼 Java 的版本了，ArrayList<Integer> list = new ArrayList<>(); 前面尖括号不必写类型，这个个性是什么时候呈现的？Modules 形容文件你晓得是什么时候呈现的吗？永恒代是在哪个版本去掉的？MetaSpace 是什么时候呈现的？MetaSpace 大小个别倡议设置为多少？它有可能会爆吗？ ...

前言感激字节的不离不弃！！！还愿博客！！！半年多的秋招终于完结了自我介绍一下：本科双非，研究生211，除了学校的课程设计和两个毕设简直什么其余的我的项目都没做过，自认不是技术大牛，一般的一名研究生 （因为面试过很屡次，后面两面就不离开写了，写一些我记得的问到的知识点，第三面独自给个排面，把感觉和前两面不一样的中央写进去） 一面、二面：过程、线程相干（区别、如何传递音讯、还会波及到jvm内存的五个模块）线程同步、锁相干（可能会问一些比拟细节的货色，要晓得一些原理方面的常识，有源码根底会好一些）汇合（线程平安的汇合有哪些、是怎么实现的、hashmap的实现的原理、还有被问到Arraylist的扩容、linkedlist底层是怎么实现的、还有concurrenthashmap是怎么保障同步的）多态的实现原理（动静代理）String的底层是怎么实现的（个人感觉是想听到final数字吧）虚拟内存（我不记得哪里问了，但面试官说问了，可能是我太菜了吧，没听懂问题）http与https的区别、https加密形式网络的模型（OSI和TCP/IP的分割）发送www.baidu.com会有哪些操作，应用哪些协定tcp和udp的区别，tcp怎么保障可靠性的（相干的协定、算法，为什么三次握手、四次挥手都有提到）DNS协定是怎么实现的用到了什么协定（这个我是一脸懵逼，就说DNS底层实现是UDP其余的我也就不分明了）数据库索引构造、事物以及事物的隔离性理解的设计模式（单例模式的双重校验锁并且会问为什么会有volatile、为什么会有两个判空、不加volatile行不行）内核态和用户态的区别中断理解多少（下面有提到中断）IO、socket都会问到三面：（尽管加入过很屡次面试，但只有两次三面，所以不多）会问我的项目（我集体说的是毕设，而后会依据你说的我的项目的某个点始终问，问到你不会或者没啥问的了为止）数据库设计：实现一个二级评论的性能，能够依据工夫和热度进行不同的显示并查集的考查会问一些怎么去学习呀、遇到什么难题怎么解决之类的问题感觉三面更看重的是我的项目相干的一些货色，从中会体现出学习能力、学习办法之类的货色，也会问一些数据库系统设计相干的题目）手撕代码：（工夫太长记得不多，就是多刷了几遍《剑指offer》和牛客上的高频题，leetcode有工夫也能够刷一刷）实现大数的求和实现线程平安的单例模式找出有序数组中两个数的和将空格替换成%20之类的小结这一圈面试下来，就是感觉首先得把计算机的基础知识（计算机网络、操作系统、数据库、设计模式、Java根底（我集体是java方向）、多线程、算法）都要尽可能多尽可能深的理解，不然很容易被问住我的面试有的是三面连着一天就实现了，有的是三面都是离开的，所以不连着不肯定就是挂了，有可能是面试官工夫上安顿抵触，面试官的态度都很好，也很业余，HR也特地的棒，字节的反馈也是很快的，从面试到offer也就一周半的工夫期间收到过很多封感谢信，感激本人没有放弃，也感激字节不厌弃，能够让我始终有被捞、面试的机会，感激牛客这个平台，给了我很大的帮忙最初祝大家都拿到称心如意的offer，也祝大家前程似锦 最初我为大家筹备了一些Java架构学习材料，学习技术内容蕴含有：Spring，Dubbo，MyBatis, RPC, 源码剖析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等有须要的敌人关注公众号：前程有光回复材料支付

面试过程简略做个自我介绍吧。面试官您好。。。看到了你的我的项目教训，简略介绍一下你的我的项目吧。。。。你的我的项目中用到了 React，用的是那个版本呢？用的 React 16.5（记错了，应该是 16.8）React 16.5 曾经有 Hooks 了吗？没有（局面一度非常难堪，React 16.8.0 是第一个反对Hook 的版本）。Hooks 和 class 有哪些劣势？有时 class 里不必的生命周期函数中会呈现雷同的逻辑，应用 Hooks 使得代码更易保护。lucifer 注: hooks 带来的劣势一方面是赋予了函数式组件更多功能，使得其从性能上可齐全代替 class 组件。 另一方面 hooks 发明了一种新的代码组织形式，和以前的 mixin 以及 render props 的出发点是相似的，但其重视雷同性能的代码放到一起，使得代码逻辑复用多了一种抉择。当然这其中有利有弊，因为篇幅限度，不在这里开展。你用过 Hooks 的哪些办法？哪些函数？用过 useEffect。lucifer 注: 倡议大家多讲几种，比方 useState, useCallback 等。useEffect 有什么特点？应用 useEffect 能够模仿一些生命周期函数，比方 componentDidMount，componentDidUpdate，componentWillUnmount。react 的生命周期有哪些？挂载时有 componentDidMount，更新的时候有 componentDidUpdate，shouldcomponentUpdate，卸载的时候有 componentWillUnmount 等。componentWillReceiveProps() 你理解过吗？没有理解过。起初查文档说 componentWillReceiveProps() 不太罕用。当 Redux 中的数据发生变化时，哪几个生命周期会发生变化？或者解释一下 Redux 的运行机制？乱答了一通……答得不好。其中谈到了 redux 次要用于简单的数据流。lucifer 注：举荐大家浏览 深刻了解redux简单的数据流是指什么样的？给本人挖了个坑，没太说明确，起因在于不理解 Redux 的利用场景，即为什么要应用 Redux。这篇文章 讲得挺好的，意思就是当咱们的状态散布在多个组件中，跟踪这些组件的状态变得繁琐时，就能够应用 Redux 来对立治理了。webpack 平时做过哪些配置？平时会设置 loader 和 plugin，用过插件 commonChunks 等。plugin 和 loader 有什么区别？loader 相当于一个模块转化器，比方将 less 文件转化为 css 文件，plugin 反对一些拓展的插件，比方 HTMLWebpackplugin，commonChunks 等。loader 如何将 less 文件转化为 css 文件？这里没搞清楚是问具体配置还是问原理，后果面试官就换下一个话题了。lucifer 注：其实就是 ast 的解析和转化，具体内容大家能够搜寻下相干文章。loader 的执行程序是什么样的？从右往左、从下往上。lucifer 注：没看到从下到上什么意思。 不过 loader 的执行程序是借鉴了 compose，函数式编程中的 compose 的联合程序就是从右向左，而性能相似的 pipe 则是从左到右，大家常见的 linux 管道（pipe）就是从左到右。我想配置一个单页利用，如何配置 entry 局部？entry: {// 这里写什么}ES6 理解吗？let, const, Map, Set, 箭头函数等等。上面的代码 b 等于什么？let a = [1, 2, 4]let b = a.map(v => { v= v*2 })我先答复了 b = [1, 4, 8]（脑子抽了，小学数学都算错），面试官问为什么不是 [2, 4, 8]，我说说错了???? ...

目录WaitGroup介绍WaitGroup的实现 AddDoneWaitWaitGroup介绍waitGroup ，也是在go语言并发中比拟罕用的语法，所以在这里咱们一起分析 waitGroup 的应用形式及其源码解读。 WaitGroup 也是sync 包下一份子，用来解决工作编排的一个并发原语。它次要解决了并发-期待问题：比方当初有三个goroutine，别离为goroutineA，goroutineB，goroutineC，而goroutineA须要期待goroutineB和goroutineC这一组goroutine全副执行结束后，才能够执行后续业务逻辑。此时就能够应用 WaitGroup 轻松解决。 在这个场景中，goroutineA为主goroutine，goroutineB和goroutineC为子goroutine。goroutineA则须要在检查点(checkout point) 期待goroutineB和goroutineC全副执行结束，如果在执行工作的goroutine还没全副实现，那么goroutineA就会阻塞在检查点，直到所有goroutine都实现后能力继续执行。 代码实现： package mainimport ( "fmt" "sync")func goroutineB(wg *sync.WaitGroup) { defer wg.Done() fmt.Println("goroutineB Execute") time.Sleep(time.Second)}func goroutineC(wg *sync.WaitGroup) { defer wg.Done() fmt.Println("goroutineC Execute") time.Sleep(time.Second)}func main() { var wg sync.WaitGroup wg.Add(2) go goroutineB(&wg) go goroutineC(&wg) wg.Wait() fmt.Println("goroutineB and goroutineC finished...")}运行后果: goroutineC ExecutegoroutineB ExecutegoroutineB and goroutineC finished...上述就是WaitGroup 的简略操作，它的语法也是比较简单，提供了三个办法，如下所示： func (wg *WaitGroup) Add(delta int)func (wg *WaitGroup) Done()func (wg *WaitGroup) Wait()Add：用来设置WaitGroup的计数值(子goroutine的数量)Done：用来将WaitGroup的计数值减1，起始就是调用Add(-1)Wait：调用这个办法的goroutine会始终阻塞，直到WaitGroup的技术值变为0接下来，咱们进行分析 WaitGroup 的源码实现，让其无处可遁，它源码比拟少，除去正文，也就几十行，对老手来说也是一种不错的抉择。 ...

我认为单向数据流的益处在于所有的状态扭转(mutation)可追溯。举个例子，父组件保护了一个状态，假如子组件可随便更改父组件甚至祖宗组件的状态，那各组件的状态扭转就会变得难以追溯，父组件的状态也可能被子组件意外批改而不可觉察。而单向数据流保障了父组件的状态不会被子组件意外批改如果要批改，只能通过在子组件中dispatch一个action来对全局状态批改，全局状态在通过props分发给子组件；又或是调用父组件的办法；又或是发事件，这些操作是肉眼可见且可控的（用函数式来说，保障了组件就是无副作用的纯函数），不至于造成状态总被意外批改而导致难以保护的状况。

你对Java线程池理解吗？你有用过线程池吗？那先说下线程池外围参数吧。。。对不起，我回去再看看吧。 为了一丝体面，咱们明天来整顿几个面试中常考线程池面试问题吧！ 为什么要用线程池？线程复用。线程的重复使用是线程池设计的重点，如果须要开启1000个线程执行程序，零碎会创立1000个线程，如果用线程池来执行1000个工作，并不需要开启1000个线程，只须要设置corePoolSize外围线程大小数量，最大线程数量，队列大小即可反复利用线程置换工作，而且1000个线程切换效率并不低，也就是说线程越多效率不肯定高。所以在多线程环境理论开发中咱们举荐用多线程。更好的治理线程。ThreadPoolExecutor能够控制线程数量，依据理论利用场景设置队列数量和饱和策略。你说下线程池外围参数？corePoolSize ： 外围线程大小。线程池始终运行，外围线程就不会进行。maximumPoolSize ：线程池最大线程数量。非核心线程数量=maximumPoolSize-corePoolSizekeepAliveTime ：非核心线程的心跳工夫。如果非核心线程在keepAliveTime内没有运行工作，非核心线程会沦亡。workQueue ：阻塞队列。ArrayBlockingQueue，LinkedBlockingQueue等，用来寄存线程工作。defaultHandler ：饱和策略。ThreadFactory ：线程工厂。新建线程工厂。execute工作增加流程？ 线程池执行execute/submit办法向线程池增加工作，当工作小于外围线程数corePoolSize，线程池中能够创立新的线程。当工作大于外围线程数corePoolSize，就向阻塞队列增加工作。如果阻塞队列已满，须要通过比拟参数maximumPoolSize，在线程池创立新的线程，当线程数量大于maximumPoolSize，阐明以后设置线程池中线程曾经解决不了了，就会执行饱和策略。饱和策略晓得吗？上图咱们说过，当线程数量大于maximumPoolSize，就会执行饱和策略。ThreadPoolExecutor类中一共有4种饱和策略。通过实现RejectedExecutionHandler接口。 AbortPolicy ： 线程工作抛弃报错。默认饱和策略。DiscardPolicy ： 线程工作间接抛弃不报错。DiscardOldestPolicy ： 将workQueue队首工作抛弃，将最新线程工作重新加入队列执行。CallerRunsPolicy ：线程池之外的线程间接调用run办法执行。上面咱们在代码中看下饱和策略应用形式。 import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.CountDownLatch;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;/** * @author ：jiaolian * @date ：Created in 2021-02-20 16:28 * @description：线程池抛弃策略 * @modified By： * 公众号:叫练 */public class AbortTest { //线程数量 private static final int THREAD_COUNT = 50; private static final CountDownLatch COUNT_DOWN_LATCH = new CountDownLatch(THREAD_COUNT); private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger(1); //线程池抛弃策略 public static void main(String[] args) throws InterruptedException { //新建一个线程池 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor( 3,5,1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20),new ThreadPoolExecutor.AbortPolicy()); //DiscardPolicy 抛弃 //AbortPolicy 抛弃报错 //DiscardOldestPolicy 将队列对首的工作抛弃,执行以后线程工作 //CallerRunsPolicy 间接调用run办法 //提交线程 for (int i=0; i<THREAD_COUNT; i++) { threadPoolExecutor.execute(()->{ try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+" execute!"+ATOMIC_INTEGER.getAndIncrement()); COUNT_DOWN_LATCH.countDown(); }); } COUNT_DOWN_LATCH.await(); //敞开线程 threadPoolExecutor.shutdown(); }}如上代码：外围线程数量是3，最大线程数量是5，阻塞队列是20，共提交50个线程，这里饱和策略用的是AbortPolicy，剖析执行线程池过程，线程池中首先开启3个外围线程Worker，发现3个线程解决不了50个线程工作，于是线程池就向阻塞队列增加工作，发现还是阻塞队列也包容不下50个工作，于是又减少至2个线程同时运行线程工作，一共是5个线程同时运行工作，此时线程池中共有25个工作会被执行，还有25个工作会被抛弃，因为咱们用的是AbortPolicy饱和策略，会报错，截局部图如下划红线所示。一共执行了25个工作。其余几种策略大家能够参照执行。 ...

给定一个整数数组 nums 和一个目标值 target ，在该数组中找出和为目标值的两个整数，并返回他们的数组下标。 JavaScript 实现应用了 ES6 中的 Map 对象，代码如下： const nums = [2, 7, 11, 15], target = 9;function sumofTwoNumber(nums, target) { let map = new Map(); for(let i=0; i<nums.length; i++) { let k = target - nums[i]; if(map.has(k)) { return [map.get(k), i] } map.set(nums[i], i) } return []}const res = sumofTwoNumber(nums, target);console.log(res); // [0, 1]Java 实现应用 HashMap 实现，代码如下： package com.company;import java.util.ArrayList;import java.util.List;import java.util.HashMap;public class SumOfTwoNumberUsingHashMap { public static List<Integer> sumOfTwoNumber(List<Integer> nums, Integer target) { HashMap<Integer, Integer> map = new HashMap<>(); for(int i=0; i<nums.size(); i++) { int k = target - nums.get(i); if(map.containsKey(k)) { List<Integer> list = new ArrayList<>(); list.add(map.get(k)); list.add(i); return list; } map.put(nums.get(i), i); } List<Integer> list = new ArrayList<>(); return list; } public static void main(String[] args) { List<Integer> nums = new ArrayList<>(); nums.add(2); nums.add(7); nums.add(11); nums.add(15); List<Integer> res = sumOfTwoNumber(nums, 9); System.out.println(res); // [0, 1] }}

公众号（五分钟学大数据）将推出大数据面试系列文章—五分钟小面试，此系列文章将会深入研究各大厂笔面试真题，并依据笔面试题扩大相干的知识点，助力大家都可能胜利入职大厂！ 大数据笔面试系列文章分为两种类型：混合型（即一篇文章中会有多个框架的知识点—死记硬背）；专项型（一篇文章针对某个框架进行深刻解析—专项演练）。 此篇文章为系列文章的第一篇（混合型） 第一题：大数据口试题-Java相干（美菜网）写出下列程序的输入：class Father{ static { System.out.println("Static Father"); } { System.out.println("Non-static Father"); } public Father(){ System.out.println("Constructor Father"); }}public class Son extends Father{ static { System.out.println("Static Son"); } { System.out.println("Non-static Son"); } public Son(){ System.out.println("Constructor Son"); } public static void main(String[] args) { System.out.println("First Son"); new Son(); System.out.println("Second Son"); new Son(); }}运行后果： Static FatherStatic SonFirst SonNon-static FatherConstructor FatherNon-static SonConstructor SonSecond SonNon-static FatherConstructor FatherNon-static SonConstructor Son剖析： 这道程序题考查的是Java中的动态代码块、结构代码块、构造函数的概念。 动态代码块 static {}：随着类的加载而执行，即JVM加载类后就执行，而且只执行一次，执行优先级高于非动态的初始化块，它会在类初始化的时候执行一次，执行实现便销毁，它仅能初始化类变量，即static润饰的数据成员。 ...

一、什么是泛型？1.泛型是一种未知的数据类型，当咱们不晓得应用什么数据类型的时候，能够应用泛型。2.泛型也能够看作是一个变量，用来接收数据类型（留神接管的是数据类型）。 E e:Element 元素T t:Type 类型例如：ArrayList汇合在定义的时候，不晓得汇合中都会存储什么类型的数据，所以类型应用泛型。 public class ArrayList<E> { public boolean add(E e) {} public E get(int index){}}创立汇合对象的时候，就会确定泛型的数据类型 二、泛型的益处创立汇合对象,应用泛型益处: 防止了类型转换的麻烦,存储的是什么类型,取出的就是什么类型；把运行期异样(代码运行之后会抛出的异样),晋升到了编译期(写代码的时候会报错)；弊病: 泛型是什么类型,只能存储什么类型的数据； private static void show01() { ArrayList<String> list = new ArrayList<>(); list.add("abc"); list.add(1);//报错：add(java.lang.String)in ArrayList cannot be applied to (int) //应用迭代器遍历list汇合 Iterator<String> it = list.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s+"->"+s.length()); } }创立汇合对象,不应用泛型益处: 汇合不应用泛型,默认的类型就是Object类型,能够存储任意类型的数据； 弊病: 不平安,会引发异样； private static void show02() { ArrayList list = new ArrayList(); list.add("abc"); list.add(1); //应用迭代器遍历list汇合 //获取迭代器 Iterator it = list.iterator(); //应用迭代器中的办法hasNext和next遍历汇合 while(it.hasNext()){ //取出元素也是Object类型 Object obj = it.next(); System.out.println(obj); //想要应用String类特有的办法,length获取字符串的长度;不能应用 多态 Object obj = "abc"; //须要向下转型 //会抛出ClassCastException类型转换异样,不能把Integer类型转换为String类型 String s = (String)obj; System.out.println(s.length()); } }三、泛型的定义与应用1.定义应用含有泛型的类/** 定义一个含有泛型的类,模仿ArrayList汇合 泛型是一个未知的数据类型,当咱们不确定什么什么数据类型的时候,能够应用泛型 泛型能够接管任意的数据类型,能够应用Integer,String,对象Student... 创建对象的时候确定泛型的数据类型 */public class GenericClass<E>{ private E name; public E getName() { return name; } public void setName(E name) { this.name = name; }}应用该类public class DemoGenericClass { public static void main(String[] args) { //不写泛型默认为Object类型 GenericClass gc = new GenericClass(); gc.setName("只能是字符串"); Object obj = gc.getName(); System.out.println(obj); GenericClass<Integer> gc2 = new GenericClass<>(); gc2.setName(1); Integer name1 = gc2.getName(); System.out.println(name1); //创立GenericClass对象,泛型应用String类型 GenericClass<String> gc3 = new GenericClass<>(); gc3.setName("小明"); String name2 = gc3.getName(); System.out.println(name2); }}2.定义和应用含有泛型的办法泛型定义在办法的修饰符和返回值类型之间 ...

序言在前端三大支流的框架中，咱们可能会常常听到 React 是单向数据流，采纳单向数据绑定，而 Vue 2.x 也是单向数据流，但同时反对单向数据绑定和双向数据绑定，而 Angular 和 AngularJS 又有所不同，到底数据绑定与数据流之间有什么关联？单向数据绑定就等价于单向数据流吗？反对双向数据绑定就肯定是双向数据流吗？这篇文章将理清在前端三大框架中数据绑定与数据流之间的关联与区别。 注：若以下文章中没有特地指明 Vue 的版本，默认代表 Vue 2.x 。Angular 个别意义上是指 Angular 2 及以上版本，而 AngularJS 专指 Angular 的所有 1.x 版本。 单向数据绑定 vs 双向数据绑定所谓数据绑定，就是指View层和Model层之间的映射关系。单向数据绑定：Model的更新会触发View的更新，而View的更新不会触发Model的更新，它们的作用是单向的。 双向数据绑定：Model的更新会触发View的更新，View的更新也会触发Model的更新，它们的作用是互相的。 React 采纳单向数据绑定 当用户拜访View时，通过触发Events进行交互，而在相应Event Handlers中，会触发对应的 Actions，而Actions 通过调用 setState 办法对View的State 进行更新，State更新后会触发View的从新渲染。 能够看出，在 React 中，View 层是不能间接批改 State，必须通过相应的 Actions 来进行操作。 单向数绑定的优缺点： 长处：所有状态变动都能够被记录、跟踪，状态变动通过手动调用触发，源头易追溯。 毛病：会有很多相似的样板代码，代码量会相应的回升。 Vue 反对单向数据绑定和双向数据绑定 单向数据绑定：应用v-bind属性绑定、v-on事件绑定或插值模式{{data}}。双向数据绑定：应用v-model指令，用户对View的更改会间接同步到Model。Vue 的双向数据绑定就是指应用v-model指令进行数据绑定，而v-model实质上是v-bind和v-on相组合的语法糖，是框架主动帮咱们实现了更新事件。换句话说，咱们齐全能够采取单向绑定，本人实现相似的双向数据绑定。 双向数据绑定的优缺点： 长处：在操作表单时应用v-model不便简略，能够省略繁琐或反复的onChange事件去解决每个表单数据的变动（缩小代码量）。 毛病：属于暗箱操作，无奈很好的追踪双向绑定的数据的变动。 Angular 反对单向数据绑定和双向数据绑定 单向数据绑定：应用[x]属性绑定、(x)事件绑定或插值模式{{data}}。双向数据绑定：应用[(x)]语法，用户对View的更改会间接同步到Model。除了语法上有所不同，Angular 双向数据绑定与 Vue 相似，也是语法糖，[(x)] 语法联合了属性绑定[x] 和事件绑定 (x)。 AngularJS 反对单向数据绑定和双向数据绑定 ...

前言写给行将加入以及将来加入校招的同学们。 校招介绍校招，全称校园招聘，指企业招聘那些行将毕业的学生。 每年个别有春招、秋招两次，春招的工夫大略在 3 - 5 月，秋招的工夫大略在 7 - 12 月。 不过像淘宝，招聘的时间跨度往往并没有那么长，从今年的教训来看，淘宝的春招大略在 3 - 4 月，秋招大略在 7 - 9 月。 这次要是因为淘宝是有绝对严格的 HC (Head Count 招聘名额)限度，招满即止，所以投递简历还是要趁早，等前期 HC 即满，无论是简历评估、还是 offer 发放，要求都会高一些。 而且因为竞争强烈，淘宝的校招是提前一届的，也就是说，淘宝 21 年的校招面向的其实是 22 届的学生，这也就是说，如果你是 22 届 (22 年 6 月毕业)，21 年 2、3 月份 (大三下学期) 就应该开始加入校招了。 所以对于 22 届的学生而言，加入淘宝校招的话，只有 21 年春招、21 年秋招两次机会。 春招 VS 秋招但千万不要因为还有秋招，就节约了春招这次机会，加入春招其实十分重要，起因有几点： 招聘流程和秋招一样，能够让你提前理解流程、积攒面试教训、造就心理素质通过大厂的面试理解本人的不足之处，及时调整方向补救，为秋招做筹备春招拿到 offer 后，即便不去实习，加入秋招也会有直通车这里多说一点，像淘宝校招每年都会布局肯定的 HC，咱们假如有 30 个，春招和秋招其实是共用这 30 个 HC 的，如果春招招了 20 个，到秋招就只有 10 个名额了，加上秋招投递的人很多，此时有实习的同学也多，竞争会显得分外强烈，所以加入春招就显得很有必要，但加入春招最大的忧愁就是，你筹备的还没有很短缺，这种状况对于所有人其实都是一样的，等你筹备短缺了，其他人也筹备短缺了，你并没有取得劣势。 加入校招的硬性条件像淘宝这样的大厂，为了升高面试老本，其实是有一些绝对根底严格的筛选条件的，这些咱们统称为硬性条件，它决定了你的简历是否能通过评估，进入到面试环节。不过硬性条件并不是肯定要恪守的，但如果你有硬伤，其余方面的要求绝对会高很多。这里解答一些常见的疑难： ...

背景最近淘系开启社招，我分割了很多的同学，理解了大家一些面大厂的经验后，我感觉大家对于面试大厂是不是有点随便…… 面试这种货色并不是投个简历，等着被面就好了，是要做很多筹备的，这个筹备不只是题目和我的项目上的筹备，心理和意识上的筹备同样重要。 不过因为我集体也只在淘宝这个大厂呆过，所以我依据本人的经验，讲讲面试淘宝这种大厂有哪些要留神的点？ 为了让内容更加丰盛，我还参考了内网多篇面试官的思考总结，整顿成这篇文章。 用面试官的思考总结也能够让大家晓得面试官是怎么考查大家的，从而反向要求本人。 硬性条件像淘系这样的大厂部门，为了升高面试老本，其实是有一些绝对根底严格的筛选条件的，这些咱们统称为硬性条件，它决定了你的简历是否能通过评估，进入到面试环节。不过硬性条件并不是肯定要恪守的，但如果你有硬伤，其余方面的要求绝对会高很多。这种最常见的状况就是比方你学历偏低，技术就要十分杰出…… 学历学历重要吗？当然重要啦，集体认为好的学历代表了你的学习能力，它是用来证实学习能力的，企业要一个人，无奈花太多工夫去理解你，只能依据你能拿进去的证实资料来证实能够用你这个人，那学历就是第一抉择。本科算是目前比拟根底的学历要求。 工作年限工作年限是从你毕业开始算起，不是从你开始做前端相干的职位开始算起。而工作年限决定了你应聘前端的评判规范。 说起评判规范，咱们能够从阿里的职业序列开始说起。像技术走的是 P 序列： 或者你比拟好奇每个技术序列的规范，我间接网上给你找了一段： P5 在业余畛域中，对公司职位的规范要求、政策、流程等从业所必须理解的常识根本理解，对于本岗位的工作和产出很理解，能独立实现简单工作，可能发现并解决问题;在我的项目当中能够作为独立的我的项目组成员；能在跨部门合作中沟通分明。P6 在业余畛域中，对公司职位的规范要求、政策、流程等从业所必须理解的常识了解粗浅，可能和经理一起探讨本岗位的产出和工作，并对经理具备肯定的影响力；对于简单问题的解决有本人的见解，对于问题的辨认、优先级调配有见解，长于寻求资源解决问题；也经常因为对于工作的纯熟而有翻新的方法，体现出解决简单问题的能力;可独立领导跨部门的我的项目；在业余方面可能培训和教诲新进员工。P7 在业余畛域，对本人所从事的职业具备肯定的前瞻性的理解，在某个方面独到，对公司对于此方面的技术或治理产生影响；对于简单问题的解决有本人的见解，对于问题的辨认、优先级调配见解尤其有影响力，长于寻求资源解决问题；也经常因为对于工作的纯熟而有翻新的方法，体现出解决问题的能力;可独立领导跨部门的我的项目；可能培训和教诲新进员工；是业余畛域的资深人士；行业外或公司内造就周期较长。换一种好了解的说法就是，应届生进来是 P5，社招个别 P6 起，对应工作年限大抵从 2 年 到 5 年左右，P7 对应的工作年限大抵从 5 年 到 8 年。 比方你 2010 年毕业，做了 3 年后端，而后做了 4 年前端，因为从毕业开始算起，工作 7 年，所以是以 P7(技术专家)的规范来评估你的。 这也就是意味着，工作 2 年到 5 年的同学，如果想来淘宝，请连忙来，过了 5 年，对你的评估规范又会高一级。 跳槽次数公司会对跳槽次数有肯定的要求，这次要是因为频繁的跳槽必定会导致积淀偏少，因为到一个新的环境是须要工夫积淀的，依据以往的教训来看，5 年内 3 跳就是就比拟难承受了，除非你有出众的一面。 内推如果你满足以上条件，你能够试着投递简历，只管你有很多种形式能够投递简历，但我真的情谊倡议，找内推，不要间接就投过去。 找内推会有很多益处： 帮你内推的同学能够给你介绍团队架构以及负责的业务帮你内推的同学才是真正和你站在一条线上的同学呀，找到一个好的内推同学，能够帮你看简历，理解下场面试官是谁，理解面试反馈，给你领导倡议，这些都可能或多或少的帮忙到你。内推胜利的话，他们是有内推奖金的，让他请你吃饭你可能会想，去哪里找内推的同学呢，给大家分享一些技巧： 关注「淘系前端团队」这个公众号，作为淘系前端的官网公众号，推送的都是淘系同学的原创文章，内容你可能看不懂，但没有关系，重点是很多文章底下都有群、二维码、微信号、邮箱之类的，你齐全能够依据本人感兴趣的方向，找相干的文章，而后分割到具体的同学，而后找他们看简历等，他们必定会十分乐意的，毕竟他们留这些信息就是要招人的关注一些你感觉不错的大佬，掘金、Github、知乎都行，招人的时候，他们会公布招聘信息，能够趁机加他们微信，不便交换和内推找冴羽呀，微信号：「mqyqingfeng」。冴羽有什么不好的，不信你看这篇文章，《如何轻松拿到淘宝前端 offer》简历少写废话专业技能 相熟 React、vueJS 等支流 MVVM 框架把握 localStorage、sessionStorage 等前端存储计划，记录用户操作习惯或罕用数据，从而升高 HTTP 申请，晋升用户体验；纯熟应用 git 版本控制工具，进行代码治理，实现麻利开发；纯熟应用 Ajax，实现异步页面无刷新抽取数据，同步校验数据； 纯熟应用 jQuery 框架，实现页面的交互成果，进步用户体验；纯熟应用 HTML5 和 CSS3，实现利用一站式跨屏（PC 端与挪动端）开发；纯熟应用 HTML、CSS、JavaScript 等前端技术，实现网页动态布局，开发兼容支流浏览器的页面，以及实现页面的交互，晋升用户体验；责任形容 ...

前言字节效率真的好高，一下午间接三面完让我等HR电话了 ???? ????面完小孙我也是懵逼的一批所以就把三面的写个集合体吧???????????????? 2021/2/6 字节跳动后端实习 一二三面面经如下：根底篇：过程调度说说吧？讲讲过程调度算法？TCP三次握手四次挥手？为什么四次挥手期待2MSL？HTTPS比照HTTP？HTTPS加密过程？对称加密非对称加密？cookie与session？说说理解的设计模式吧，而后手写DCL，顺带说一下为什么这么写？说说HashMap、Hashtable和ConcurrentHashMap吧？HashMap多线程下会有什么问题？说说Java怎么保障线程平安（答volatile、synchronized、lock体系那一套）说说volataile和synchronized吧，底层实现理解吗？（重排序，可见性，锁收缩那一套）Object类下有哪些办法？序列化与反序列化？说说Java的根本数据类型吧，double占几位？装箱拆箱？（-128到127）说说String、StringBuilder和StringBuffer吧创立一个String对象，外部怎么说？（字符串池那一套）类加载机制说说吧说说双亲委派机制吧说说你理解的排序吧？快排和冒泡你怎么了解的？说说InnoDB的吧四种隔离级别说说吧，怎么实现的？哪种会产生幻读？怎么解决？B+树？为啥不必B树？你理解什么索引？什么时候索引会生效？SQL注入理解吗？怎么避免？算法篇：合并两个有序链表递归非递归 Leetcode21翻转链表的第M到N位 Leetcode92 （这波是小孙我大E了，面试官让小孙我结构输入输出跑一下，没结构进去，被面试官说了一顿????????）最长公共前缀 Leetcode14SQL篇：有一个帖子表、评论表和用户表，求出最近一个月内25岁以内男生评论最多的帖子，按多少排序，分页0到10我的项目与日常篇：挑一个你感觉有亮点的我的项目说说吧？我的项目登录怎么做的？带三来实习，实习多久？答：半年以上到岗工夫，不能早点吗？答：一月暑假，能够跟学校沟通平时Java怎么学的？答：看书+看视频反诘篇：一面：无反诘，面试官给我说你等一下，而后就溜了。。二面：后果什么时候进去？答：很快，去给leader说一下二面：部门日常做什么？答：做一些领取逻辑这块的二面：宁感觉我这次面试有哪些方面须要进步？答：根底挺ok的，看得出来是常常刷题的，然而我让你结构链表输入输出这么简略你结构不进去？这可比你下面写的算法简略多了，小火汁代码量不太彳亍啊。三面：后果什么时候进去？答：我这边曾经通过了，后续也没有面试了，等HR跟你沟通吧。总结PS：最初的leader非常的庄重，吓得小孙我有一丝缓和，然而前面反诘我问他后果的时候，他笑了 ???? ????还让我加他微信，有问题问他 ???????????? 最初另外我这里为大家筹备了一线大厂面试材料和我原创的超硬核PDF技术文档，以及我为大家精心筹备的多套大厂面试题（不断更新中），心愿大家都能找到心仪的工作！有须要的敌人：关注公众号前程有光自行下载即可

写在后面：lz大三，专业课还没上完，为了面试本人提前看了计网和OS。因为是第一次找实习，简历也不太会写，之前投了很多家公司都被秒拒了，投的字节也是。起初字节的hr给我打电话说我的简历里没有我的项目是会被零碎主动拒掉的，所以瞎写了几个我的项目，被捞起拉去面试了从大略11月初开始面字节，第一次面三面后挂了，而后又被hr捞起来又面了一次，这次四面过了，可能这个部门真的很缺人吧hhh因为工夫长远，好多细节记不得了一面：我这辈子第一次面试，特地缓和，设施没有调试好，面试官那边听不到我声音，所以就推延面试了，耽搁了面试官的工夫。第二次上来问了：我的项目TCP握手挥手面试官看我没啥教训，我的项目做的也不怎么样，于是说“做两道题吧”判断均衡二叉树。我确认了以下定义开始写，因为太紧张把java的语法都写错了hhh面试官跟我说不必缓和请写出一个高效的在m*n矩阵中判断目标值是否存在的算法，矩阵具备如下特色：每一行的数字都从左到右排序每一行的第一个数字都比上一行最初一个数字大二分，面试官说我逻辑写简单了 而后第一次面试就完结了，全程根本就是在做题，没有问操作系统。可能公司面对没有开发教训的候选人就会让他做题吧。二面：二面面试官看起开不太开心，上来问了我点Java相干的，我答得不好，我跟他说我平时用Java只是刷leetcode，他说那咱们做两道题吧。。。二叉树的最大门路和，Leetcode hard原题，还好我前几天刷过一遍，我感觉这个面试官不怀好意，上来就一道hard，说好的循序渐进呢给定一个字符串m（只含有26个小写字符，假如m的总长度不大于1000），要求在字符串中找到最长的一个间断回文子串k，返回其长度。其中间断回文子串 k 需满足以下条件：（1）整个字符串是回文串（从前往后和从后往前看字符串是一样的）（2）该字符串中的任意相邻字符在ASCII 码表中也是相邻的（3）字符串中字母序必须是且只能是先升序后降序，且字母序只能扭转一次 我拿到题很开心心想这不就是最长回文子串吗，这个我会！而后就要DP。面试官说停停，你再看看这题须要DP吗？我一看，噢，原来一遍遍历就行，而后就开始写，期间写了很多bug，都被面试官挑出来了做完两道题才开始问八股文数据库的隔离级别解决幻读须要什么隔离级别 外存排序，归并Top K问题，快排+剪枝。如果数据量很大没法快排呢？维持一个堆。因为那段时间我Java用的比拟多，心里想的是代码，上来就说PriorityQueue，面试官没听懂我要干啥，问我学过数据结构没，我说哦哦哦用堆，他说你早说用堆不就完了而后第二次面试就完结了，还是做题，做题，做题三面上来先让我自我介绍，我就把学过的课程说了说聊到语言，又说到了Java，我说我这个就是刷题用的，暗示他别问了，他说刷题为啥不必c++，我说好久没用忘了可他还是要问Java(╯▔皿▔)╯ Equals和HashCode办法，自定义数据结构放在HashMap里须要重写哪个。我学Java的时候记得，起初忘了。。HashMap扩容策略，我说链表转红黑树，他说如果红黑树变得很大呢，我说我真不知道别问了他说好好好不问了，咱做题吧。最大子序和，leetcode经典中的经典，间接背进去。他说如果我不仅想要最大的和，还想要区间范畴呢，我就又改了改。他说行，下一题吧。一个先升序后降序的数组，找出某个值在不在这个数组内。二分魔改过了，期间他始终引领我，我说您说的我没太听懂，我依照我的思路写能够吗，他说好的好的，不打搅你了，而后我就给他边写边讲我的思路，他说也行做完了题问我打不打ACM，把我乐的够呛，说我刷题才俩月，哈哈问我用过Linux吗？答曰学计组和OS的时候会用ubuntu，但命令行不太熟会git吗？不会用得惯苹果零碎吗？我说我俩电脑一个win一个mac，会的而后完结了欢快的面试，第二天收到了拒信起初我就去B站先实习了，那边用的也是Go过了两周，又被hr拉去面另外一个组，说缺人，我一开始是不想去的，但还是批准了面试一面聊天聊到了我当初的实习，于是问了我点Go相干的在公司都写什么货色了ConcurrentHashMap如何放弃一致性。我说全局大锁，他说留神性能问题。而后我说能给点提醒吗？他说如果这个HashMap数组特地长呢？我问那可不可以分段加锁？他说能够。起初我回去查了查老版本的Java真的是用的分段加锁，我可真机智slice理解吗，我说临时没用到过。被“讥嘲”了，他说在字节的节奏会快很多，你过去学两三天就要干活了。Goroutine为啥轻量 过程线程相干的，问的比拟深刻。他说：你方才提到了Goroutine对于操作系统是通明的是吧，那么操作系统如何向某个Goroutine发送时钟中断呢？如果不能发送如果有某个Goroutine始终执行怎么办？这个我不太会，他说没事，回去查查HTTPS握手，我说不理解握手，简略地说了对称加密算法和非对称加密算法 ARP协定是什么，我说还没学到IP层，不晓得而后就开始做题了。感觉这个组面的基础知识比拟多，而面的算法都很简略两个排好序的链表排序并去重，我一边讲思路一遍写。tips：写题的时候肯定要和面试官阐明本人的思路，不然面试官不晓得你在干什么就这一道题我问了他们组是做什么的二面这时我经验过的最好受的一次面试，面的货色我根本全没答出来而且面的时候我的电脑死机了，连忙借室友的电脑面的，耽搁了五分钟，回去发现面试官还在等我HTTPS怎么握手，我说不晓得，他说以前不是问过你吗？我才晓得他们有记录的，就说忘了去查了（起初面完去查了ARP解析，我恰好下午看书看到那，就答复进去了，他说你是回去看了吗？我说我只是恰好学到这。。 Cookie理解吗。我把Cookie和session记反了，说cookie是存在服务器端的，他说你确定？我说emmmm...（起初回去一查这么简略的问题都没答对他竟然放我过了。。他说之前问过你的，你有没有回去查过哪些？我就答上次的那个Goroutine相干的问题，说Goroutine之间是合作式调度，如果某一个Goroutine始终在占用CPU而不阻塞那么他是不会让进来的(这是旧版本的个性)，他说那这样的状况就始终占着？不能强行执行调度吗？我说如同是的。起初我回去看了看最新版本的个性，发现能够抢占式调度了。。Go如何利用多核性能？不晓得。（也是回去查，学到了GMP模型，一开始会调配GOMAXPROCS个Processor设计一个秒杀零碎？不会不会不会做题吧荷兰国旗问题。这个我做过，但工夫长远，现场做的时候还是做了挺久的，边做边想必定去不了本人了，在B站实习也挺好的/(ㄒoㄒ)/~~他说你等十分钟三面吧，我(っ ° °;)っ，竟然还有三面三面HashMap扩容。所以我发现他们真的很爱问之前你没答上来的货色。我说不会。。他说没事你本人设计一个，而后我就本人设计了一个，他指出了有余，我就又接着改，改了好几个版本他说行设计一个调度零碎。我用的多级动静优先级队列+堆，操作系统课刚讲过的他仿佛问了不止两个问题，但我有些记不得了算法：最大子序和。我说之前问过了，换一个吧（过后我好呆啊，万一换一个我不会咋办(╯‵□′)╯︵┻━┻矩阵内的最短门路，只能向下或向右走。这个比较简单，一个DP搞定三面完结HR面HR来势汹汹，语速很快，期间跟我聊了我的项目，性情等等好多货色，劝我如果想工作的话尽早脱离学校的环境等等。。而后说你没有工程开发的教训，咱们北京这边北航和北邮的学生来的时候都有相干开发教训的，他们上手会很快。我一听这不是要把我给拒了吗，连忙说我在B站实习了hhh因为B站的技术栈和字节的技术栈很像(都是Go)我上手也会很快的blabla，她听了很开心，说你等告诉吧！但其实我上手会很慢(●'◡'●)写在最初B站这边还有很多校招hc（以转正为目标的实习应该也是能够的）。字节这边也很缺人。大家如果感兴趣能够私信我哦~我能够把简历间接发给HR 总结另外我这里为大家筹备了一线大厂面试材料和我原创的超硬核PDF技术文档，以及我为大家精心筹备的多套大厂面试题（不断更新中），心愿大家都能找到心仪的工作！有须要的敌人关注：公众号前程有光回复材料下载