【Java面试】面试相关准备

1. 线程的安全性？
2. 创建线程的3种方式？
   1. 继承线程类创建线程
      • 线程本质上是实现了可运行的接口的一个实例，代表一个线程的实例。通过实例化一个线程对象，然后执行此对象的开始（）方法，开始是一个本地方法，他将启动一个线程，并执行运行（）方法。
        1. 创建这种多线程，线程继承类，重写运行然后（）方法，就可以了
        2. 的run（）方法是先执行完一个线程后再执行下一个，即为顺序执行，但是开始（）【其实为启动（）。运行（），启动会自动调用运行（）方法】方法为同时开始执行，然后线程抢占
   2. 实现了Runnable接口创建线程
      • 实现Runnable接口创建线程，必须需要新的Thread（）来运行他的run（）或者start（）方法
   3. 通过调用和FutureTask创建线程
      • 创建可调用接口的实现类，并实现调用方法
      • 创建FutureTask实现类的实例，使用FutureTask类包装Callable对象，该FutureTask对象封装了callable对象得调用方法的返回值
      • 使用FutureTask对象做为线程对象的目标创建并启动线程
      • 调用FutureTask对象得的get（）方法来获取子线程的执行结果的返回值
   4. 使用ExcutorService，可赎回，未来实现有返回结果的线程
      • 创建可调用接口的实现类，并实现调用方法
      • 创建FutureTask实现类的实例，使用FutureTask类包装Callable对象，该FutureTask对象封装了callable对象得调用方法的返回值
      • 结合线程池接口ExcutorService实现有返回值的线程
3. 的StringBuffer，StringBuilder的区别？
   1. 字符串：字符串常量，StringBuffer的，StringBuilder的：字符串缓冲区变量
   2. 执行速度：StringBuilder的> StringBuffrt>字符串
   3. StringBuffer的：线程安全的，StringBuilder的：线程非安全的
   4. 使用：
      • 操作少量数据用字符串
      • 单线程操作字符串缓冲区下操作大量数据= StringBuilder
      • 多线程操作字符串缓冲区下操作大量数据 = StringBuffer
4. StringBuilder和StringBuffer的扩容？
   1. StringBuiler和StringBuffer初始容量都是16，当需要扩容的时候，默认会扩容为2倍+2，但是默认扩容依旧不足的时候，会直接扩为需要的大小
5.  项目中做的好的？
6.  IO？
7.  集合？
8.  基本数据类型
   1. 整数值类型：
      • byte
      • short
      • int
      • long
   2. 字符型
      • char
   3. 浮点类型
      • float
      • Double
   4. 布尔型
      • Boolean

整数默认为int，小数默认为double，float和long类型必须加后缀

1. String类的常用方法？
2. post与get的区别？
3. 异常？
4. 基本数据类型和引用数据类型的区别？
5. 基本数据类型和包装数据类型的区别？
   1. 包装类是对象，拥有方法和字段，对象得调用都是通过引用对象的地址，基本数据类型不是
   2. 包装类是引用的传递，基本数据是值传递
   3. 声明方式不同，包装类需要new在堆内存中进行new来分配内存空间，基本数据类型不需要new关键字
   4. 存储方式不同：基本数据类型直接将值存储在栈中，包装类是把new的对象存储在堆中，在栈中通过对象得引用来调它们
   5. 初始值不同，基本数据类型初始值为0、boolean类型的初始值为false，包装类的初始值为null；
   6. 使用方式不同，基本数据类型直接赋值，包装类是在集合collection Map时会用的
6. int与Integer的区别？
7. 字节流与字符流的区别
   1. 字节流是byte类型，一个字节占8bit，字节范围为-128~127，
   2. 字符流无符号，一般来说1个字符占2个字节，范围为0~65535
8. ArrayList与LinkList的区别
   1. Arraylist是以数组的形式存储的，在内存中是连续的，它查询快，但是增加和删除比较缓慢
   2. Linklist是以链表的形式存储的，在内存中不连续，所以它查询慢，LinkList之间用的是引用的方式来“连接”其他内容，所以它增加和删除快
9. String与Stringbuffer的区别
   1. String类是字符串常量，它无法被继承，所以他是一个final类（final类无法被继承），
   2. Stringbuffer是字符串缓冲区，它是线程安全的并且它的速度比Sting快比Stringbuilder慢，因为Stringbuilder是线程不安全的，并且Stringbuffer线程安全，所以它在并发的时候需要锁，会有资源竞争，会有内存切换，所以会导致Stringbuffer的速度比Stringbuilder的慢
10. HashMap的原理？
    1. HashMap是一个数组与链表结合的“链表散列”的数据结构，HashMap底层是一个数组，数组中的每一项都是一个链表。HashMap会在内部维护一个Entry，数组的默认长度为16，每次往HashMap中存放key-value的时候，都会为他们实例化一个Entry对象，通过哈希值hash-->hash(k.hashcode())来得到k对应在数组Entry处的下标，即数组的索引，当hashcode()值相同的时候，就形成了哈希冲突，此时则会在相同hashcode()的数组索引处进行链表存储
    2. Key=null的时候存在第一位，因为key=null时的索引计算为0
11. HashMap中的put与get怎么工作？
    1. Put
       • put(key,value)
         1. 对key=null做判断，为空的时候被存储到数组索引为0的地方
         2. Key的hashcode方法被调用，然后计算出hash值，通过hash值找到对应的Entry对象的数组的索引
         3. 通过indexFor(hash,table.length)用来计算Entry对象在数组中的精确下标，如果有哈希冲突，则会迭代链表，一直到Entry-->next==null，则会存储在首位即当前Entry对象变为链表下一个节点
       • get(key,value)
         1. 对key=null做判断，为空的时候被存储到数组索引为0的地方
         2. Key的hashcode方法被调用，然后计算出hash值，通过hash值找到对应的Entry对象的数组的索引
         3. 通过indexFor(hash,table.length)用来计算Entry对象在数组中的精确下标，调用equals方法比较key
12. HashMap在什么时候会导致死循环？
    1. 在并发线程中，当2个线程同时存储相同的数据，会导致HashMap的Entry链表末尾形成环，下次进行数据存储的时候，会导致在末尾形成环，找不到HashMap的末尾，导致形成死循环，HashTable也会形成死循环，但是ConcurrentHashMap会避免这个问题。
13. 静态修饰和用关键字transient修饰的不能被序列化
    1. 因为序列化是把对象数据进行持久化存储，而静态的属性是属于类加载时的数据，不会被序列化
14. flush()与close()的区别？
15. Properties？
    1. Map集合的一种，Hashtable的子集，它的键值都是String类型，它是唯一能与IO流结合使用的集合
       • Load()将流对应的文件中的数据写入到集合中
       • Store()将集合中的数据写入到流对应的文件中
16. 实现Runnable的原理？
    1. 为什么需要定义一个类去实现Runnable接口？、
       • 实现Runnable接口，为了解决继承Thread类的单继承局限性，定义一个类，去实现Runnable接口，然后重写Runnable接口的run()方法，在run()方法中实现线程任务
    2. 继承Thread类和实现Runnable接口的区别？
       • 创建Thread类，只有new Thread()才可以创建线程
       • 实现Runnable接口，要重写run()，线程任务已经被封装到重写的run()方法中，实现Runnable接口的子类，需要创建Thread类，并将新建的子类作为参数传入new的Thread构造方法中，这样线程对象和线程任务就能很清晰的表现出来，达到一定的解耦目的
17. 实现Runnable接口的好处？
    1. 继承Thread类有单继承的局限性，实现Runnable接口则避免的单继承的局限性
    2. 继承Thread类，多线程需要创建多个new Thread()，表示多个线程每个线程独立的执行run()方法，即多线程分别完成自己的任务；子类实现Runnable接口，然后实例化多个Thread类进行多线程，这些new Thread()线程共同执行重写的run()方法，多个线程执行同一个任务，即资源共享
18. 接口和继承的区别？
    1. 更具体的说，应该是接口和抽象类的区别
       • 修饰符不一样：抽象类--abstract，接口--interface
       • 抽象类是对类的抽象，是自下往上进行抽象，抽象出来的是类的共性，接口是对行为的抽象，无关其他
       • 抽象类可以拥有已经被实现的类，但是必须包含一个抽象方法，接口可以有成员变量，接口是完全由抽象方法组成
19. 创建线程的2种方式？
    1. 继承Thread类
       • 创建继承Thread类的
       • 子类重写run()方法
       • 主函数创建继承Thread类的对象
       • 对象.start()方法启动线程，通过JVM调用线程中的run()方法
    2. 实现Runnable接口
       • 创建实现Runnable接口的子类
       • 子类重写run()方法
       • 主函数中创建实现Runnable接口的子类的对象
       • 将创建的对象作为参数传递给创建的线程对象new Thread()
       • 线程对象.start()方法启动线程，通过JVM调用线程中的run()方法
20. 静态方法与非静态方法的区别？
    1. 静态方法用static修饰符修饰，并且静态方法在类定义的时候就已经被加载和分配，静态方法内部只能有static修饰的类或者变量，静态方法只能调用静态方法或者静态成员变量
    2. 非静态方法在类被实例化成对象得时候才会分配到内存，在类定义的时候并没有占用内存，非静态类可以调用静态或者静态类的方法或变量
21. synchronize锁修饰非静态和静态方法的对象是什么？
    1. 同步方法synchronize（this）
    2. 静态同步方法synchronize（类.class）
22. sleep和wait的区别？
    1. Sleep：不释放锁对象，释放CPU使用权，等待期间无法被唤醒
    2. Wait：释放锁对象，释放CPU使用权，等待期间可以被唤醒

1. 锁对象可以是任意对象
2. JAVA内存分配？
   1. 栈：存放基本数据类型和对象得应用
   2. 堆：存放new创建的对象和数组，在堆中分配的内存，由Java虚拟机的自动垃圾回收来管理
   3. 静态域：存放在对象中用static定义的静态成员
   4. 常量池：存放常量
3. 注解的原理与定义？
   1.  
4. Redis的持久化机制？
5. SpringMVC启动流程？
6. Tomcat加载springMVC启动流程？
7. Redis能干什么？
8. 序列化？
   1. 序列化与反序列化？
      • 用于从流中读取对象的操作流ObjectInputStream称为反序列化流
      • 用于向流中写入对象的操作流ObjectOutputStream称为序列化流
   2. 特点：用于操作对象，可以将对象写入文件中，也可以从从文件中读取对象
   3. 对象序列化流ObjectOutputStream（将对象写入硬盘）
      • ObjectOutputStream将java对象的基本数据和图像写入OutputStream，ObjectinputStream可以读取（重构）对象。
      • 通过在流中使用文件可以实现对象的持久化存储。
      • 只能将支持java.io.Serializable接口的对象写入流中
   4. 对象反序列化流ObjectInputStream
      • ObjectInputStream对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化操作。只能将支持java.io.Serializable接口的对象读取到流中
   5. 序列化接口
      • 当一个对象要被序列化时，这个类必须实现Serializable接口，如果不实现Serializable接口，会出现NoSerializeableException异常
      • 当一个对象所属的class文件在序列化后进行修改，然后进行反序列化的时候对出现InvalidClassException异常
        1. 原因：
           1. 该类的序列版本号与从流中读取的类描述的版本号不一致
           2. 该类包含位置数据类型
           3. 该类没有可访问的无参构造方法
      • Serializable标记接口，该接口给需要实例化的类，提供了一个序列版本号serializableId，该版本号的目的在于验证序列化的对象和对应类是否版本匹配
   6. 无法被序列化的
      • transient:
        1. 用关键字transient修饰的属性，序列化时这个属性不会被序列化
      • 静态属性
        1. 静态修饰也不会被序列化，序列化是把对象数据进行持久化存储，而静态的属于类加载时的数据，不会被序列化
   7. 在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略
9. 为什么要序列化？
   1. https://www.cnblogs.com/lucky-star-star/p/5415610.html
   2. 序列化就是对实例对象的状态进行通用编码并保存，以保证对象的完整性合可传递性，简而言之，序列化就是为了在不同时间或者不同平台的JVM之间共享实例对象
10. 什么时候使用序列化？
    1. 数据持久化存储，将数据储存到文件或者磁盘中
    2. Socket通信过程中使用序列化
    3. RMI远程调用使用序列化
11. 选择性序列化？
    1. Transient关键字修饰
    2. Externalizable接口实现自定义序列化
    3. 通过writeObject和readObject进行自定义序列化，否则会进行默认序列化
12. ConcurrentHashMap与HashTable的区别？
    1. (https://blog.csdn.net/basycia/article/details/51890699)
    2. 它们都可以用于多线程的环境，但是当HashTable的大小增加到一定的时候，性能就会急剧下降，因为迭代需要被锁定很长的时间。
    3. ConcurrentHashMap引入了分割，默认分割为16，不论大小变得多大，仅仅锁定map的一部分，使得其他线程不用等到迭代完成才能访问map；ConcurrentHashMap锁定部分，而HashTable会锁定全部，
13. 能否让HashaMap同步？
    1. HashMap可以通过下面的语句进行同步：
       • Map m = Collections.synchronizeMap(hashMap);
14. Iterator迭代器的fail-fast和其他fail的区别？
15. HashMap与HashTable的区别？
    1. HashMap是非同步，线程不安全的，键值可以为null，迭代器为Iterator，当有其他线程改变了HashMap的结构(增加或者删除)，将会抛出ConcurrentModificationException异常，但是迭代器本身的remove()方法移除元素不会抛出ConcurrentModificationException异常，但是这并不是一个一定发生的行为，要看jvm
    2. HashTable是同步，线程安全的，就是说多线程可以共享资源，键值不能为null，迭代器为enumerator
    3. Sychronized，意味着每次只能有一个线程更改HashTable；任何线程要更新HashTable时首先要获取同步锁，其他线程要等到同步锁被释放后才能更新HashTable
16. 线程安全的2个要素？
    1. 内存可见性（可见性）
       • 当变量被修改，该变量的修改会被刷新到内存中，当一个线程需要读取该变量时，回去内存中读取新值而不是以前的值(synchronized,lock,volatile都可以保证)
    2. 操作一致性（原子性）
       • 指的是操作不可中断
    3. 有序性
17. Synchronized，lock，volatile的区别？
18. Callable可以捕获异常，Runnable不可以捕获异常
19. 为什么要有动态代理？
    1.  
20. 如何实现一个动态代理对象？
    1. Jdk实现动态代理
       • 被代理类需要有统一的实现接口
       • 通过java内部的反射机制来实现的，反射机制在生成类的过程中比较高效
    2. cglib实现动态代理
       • cglib底层是借助asm来实现的，asm在生成类之后的相关执行过程中比较高效
       • 被代理类可以没有统一接口，
21. 实现动态代理对象的3个参数是什么？
    1. 类加载器
    2. 被调用的接口的class对象
    3. 回调
22. 动态代理自我理解？
    1. Jdk实现动态代理
       • 动态代理被代理类是一个接口，需要一个实现该接口的实体类，然后中介类需要实现InvactionHandler接口，并且重写invoke()方法，main函数中，需要创建代理对象：代理类 xx = (代理类)Proxy.newProxyInstance(类加载器，被调用的接口的class对象，回调)
    2. cglib实现动态代理
       • 被代理类没有统一接口的时候，可以使用cglib来实现动态代理
23. 线程的执行过程？
24. 线程池的创建？
    1. newCachedThreadPool:创建一个可缓存的线程池
    2. newSingleExecutor:创建一个单一线程池，用唯一的工作线程来执行任务，按照指定的顺序来执行
    3. newFixedThreadPool:创建一个定长的线程池，控制最大线程，超过最大放入等待队列
    4. newScheduledThreadPool:创建一个定长的线程池，支持定时以及周期性执行任务
25. 怎么停止一个线程？
    1. 使用Thread.stop()暴力停止，但不能保证线程原子性
    2. 使用interrupt()中断线程
    3. 使用标志符号来停止线程
26. 线程池的参数？
    1. 核心线程数
    2. 最大线程数
    3. 阻塞队列
    4. 拒绝策略
    5. 还有保活时间
27. 线程池的执行流程？
    1. 开启一个线程后，判断是否超过核心线程数，没有超过的话创建线程执行，超过了判断阻塞队列
    2. 阻塞队列未满的话，放入阻塞队列，如果线程已经满了的话，判断最大线程数
    3. 如果未达到最大线程数，则立马创建最大线程，如果最大线程满了，进行拒绝策略
    4. 拒绝策略
       • 立即执行
       • 抛出异常
       • 丢弃
28. 数据库连接池的实现？
    1. 自定义连接处
       • 提供容器与初始化
       • 连接连接池
       • 归还连接
    2. C3P0连接池
       • 导入jar包
       • 配置配置文件
       • 常用属性配置
         1. 用户名
         2. 密码
         3. 驱动
         4. Url
         5. 初始化连接数
         6. 最大连接数
         7. 无可用连接池时创建链接数
         8. 超时时间
       • 工具类实现连接
    3. DBCP连接池
       • 导入jar包
       • 配置文件
       • 常用属性配置
       • 工具类实现连接
29. 数据库连接？
    1. 创建驱动：DriveManager
    2. 建立数据库连接：conncetion
    3. 检查连接：statement
30. 线程同步的方法？
    1. 使用同步方法
    2. 使用同步代码块
    3. 使用特殊域变量(volatile)
    4. 使用ReentrantLock类
31. mysql引擎？
    1. innoDB
       • 支持事务表安全，支持行级锁定和外键
       • 处理大容量数据库的
       •  
    2. Memory
    3. MyISAM：锁整个表查询的时候效率高
    4. 
       Archive
32. 数据库事物处理
    1. 原子性：事物没有中间状态，要么是改变前的原始状态，要么是改变后的状态
    2. 一致性：数据状态不会改变
    3. 隔离性：一个线程执行事物时对其他线程不可见
    4. 持久性：事物被修改后是永久修改，即使数据库坏了又恢复也是永久修改后的
33. list、set、map的区别
    1. list、set实现了collection的接口
    2. list：
       • 按序存储，保证了元素的插入顺序
       • 可允许多个重复对象
       • 可允许多个null
       • 常用的为：ArrayList、LinkedList、Vector
         1. ArrayList适用于查询
         2. LinkedList适用于添加和删除
    3. Set
       • 无序存储，不保证元素的插入顺序
       • 不允许重复
       • 只允许一个null
    4. Map
       • Map是一个接口，为key，vaule的形式存储
       • 一般使用HashMap等来实现map接口
       • Map可以有多个value为null，key只能有一个null
    5. 想要对list进行排序，可以是用collection.sort(list)来实现
34. springMVC的原理
35. sleep与wait区别
    1. sleep：不释放锁资源，等待期间无法被唤醒，释放cpu使用权
    2. wait：释放锁资源，等待期间可以被唤醒，释放cpu使用权
36. 字节流字符流是线程安全的么？
37. Hashmap与hashtable的区别？
    1. Hashmap是线程不安全的，hashtable是线程安全的
    2. Hashmap可以为null，但是hashtable不能为空
    3. Hashmap取消了contains方法，只有containsKey和containsValue，hashtable三个全有
    4. Hashmap默认容量为16，扩容为2倍，hashtable默认容量为11，扩容为2倍+1
    5. Hashtable直接使用对象的hashcode，而hashmap需要重新计算hash值
38. http与https的区别
    1. https需要到ca申请证书
    2. http是超文本传输协议，使用明文传输，https是具有安全性和ssl协议的安全传输协议
    3. http和https使用不同的链接方式，使用的端口也不同，http使用的是80端口，https使用的是443端口
    4. http使用无状态的链接方式，https是使用ssl+http协议构建的可进行加密传输，身份认证的网络传输，比http协议安全
39. Synchronized，lock，volatile的区别？

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---------------- 6月25日科软件电话面试-------------------------- --------------

1. 数据库优化
2. Javabean的存在哪里
3. 春天在SSM中起的作用
   1. SpringIOC：控制反转，依赖注入
      • 装载豆，也就是装载的Java中的类，当然也包括服务，DAO中的，有了这个机制，我们就不用在每次使用这个功能的时候为他初始化
4. MyBatis的在SSM中起的作用
   1. MyBatis的是对JDBC的封装，他让数据库底层操作边的透明，MyBatis的都是围绕着一个SqlSessionFactory的实例展开的。
   2. MyBatis的经常通过配置文件关联到各实体类的映射器文件映射器文件配置了每个类对数据库所需的SQL语句映射，每次与数据库交互时，通过的SqlSessionFactory拿到一个SQLSESSION，再执行SQL命令
5. 用SpringMVC的原理
   1. 客户端发送请求到DispacherServlet（前端控制器）
   2. 由DispacherServlet控制器查询的HandlerMapping，找到处理请求的控制器
   3. 控制器调用业务逻辑处理后，返回的ModelAndView
   4. DispacherServlet查询视图解析器，ModelAndView的找到渲染的视图
   5. 视图将结果显示到客户端

 

 

1. SpirngIOC和springaop在哪用怎么用的
   1. https://www.cnblogs.com/best/p/5727935.html
2. 谈一谈的ConcurrentHashMap
3. 项目中集合用的什么（ArrayList的和链表）
4. SSM事物的用法
5. MySQL的调优
   1. 当只要一行数据时使用LIMIT 1 
   2. 为搜索字段建索引 
   3. 避免SELECT * 
   4. 永远为每张表设置一个ID 
   5. 尽可能的使用NOT NULL 
   6. 把IP 地址存成UNSIGNED INT
6. 什么情况下索引会失效
   1. 条件中有或索引会失效
   2. 像查询，使用％开头，索引会失效
   3. 列类型为字符串，如果的sql语句中没有对此字符串加引号也会失效
   4. 索引列加函数也会失效