乐驰测试题

package zhanghaojie;

public class Test04 {
public static void main(String[] args) {
// 第一题，求[1,100]中，奇数的个数。
int s = 0;
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
s = s + 1;
System.out.println(“个数:” + s);
}
continue;

	}
	// 第二题，求偶数的和。
	int b = 0;
	for (int j = 0; j <= 100; j = j + 2) {
		b = b + j;
	}
	System.out.print("偶数的和是：" + b);
	System.out.println();

//第三题，求分子的和，
double c = 0;
for (int i = 1; i <= 10; i = i + 1) {
c = c + (1.0 / i);
}
System.out.println(“分数和：” + c);
// 第四题，打印右直角三角形(空格倒三角+右直角)
// for(int i = 1; i <= 5; i++) {
// for (int j = 1; j <=5; j++) {
// if (i<=5-j) {
// System.out.print(" “);
// } else {
// System.out.print(”");
// }
// }
// System.out.println();
// }
for (int h = 1; h <= 5; h++) {
for (int j = 5; j >= 1; j–) {
if (j > h) {
System.out.print(" “);
} else {
System.out.print(”");
}
}
System.out.println();
}
}

}
1.java 中如何跳出循环？
break会跳出（终止）当前循环。continue是跳出当前循环，开始下一循环

以上两种方法没有办法跳出多层循环，如果需要从多层循环跳出，则需要使用标签，定义一个标签label，然后在需要跳出的地方，用break label就行了，

2.volatile和synchronized的区别?

synchronized关键字解决的是执行控制的问题
volatile关键字解决的是内存可见性的问题

volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化
volatile
多线程环境下，频繁修改的数据应该添加这个关键字
可见性
不同cpu之间监听数据的修改，对数据修改可见
禁用指令重拍
cpu可能会对代码执行进行优化，对代码顺序重新排序
加 volatile 可以禁用指令重排优化

一：synchronized和lock的区别
描述：每个对象都有一个内置锁，这是synchronized锁的基础，内置锁是互斥锁，可以实现同一时间只会有一个线程在执行逻辑代码

1：synchronized是关键字，是JVM层面的，lock是java类（接口）
2：synchronized不能够判断是否获取锁的状态，lock可以判断是否获取到锁
3：synchronized（隐式锁）可以自动释放锁（①：执行完同步代码时释放锁 ②：代码出现异常释放锁），lock（显示锁）需要手动在finally中释放锁（否则容易造成线程死锁）
4：synchronized修饰的线程A和线程B（同一个锁对象），当线程A在使用时，线程B等待，当线程A阻塞时，线程B一直等待，lock锁不一定会一直等待，如果在设置的超时时间内，尝试获取不到锁，线程可以不用等待就结束
5：synchronized是可重入，不可中断，非公平的，lock是可重入，可判断，公平的（也可以是非公平的）
6：synchronized锁适合同步少量代码，lock锁适合同步大量代码
7：使用上的区别：synchronized可以修饰普通方法（锁是当前实例对象），可以修饰静态方法（锁是当前实例的CLASS对象），可以修饰代码块（锁是括号中的实例对象），lock用来同步代码块，需要显示的调用lock()和unlock()方法来加锁和解锁
8：synchronized采用的CPU悲观锁机制，lock用的是乐观锁机制

3.jdk1.8的新特性有哪些?

Lambda表达式
函数式接口
*方法引用和构造器调用
Stream API
接口中的默认方法和静态方法
新时间日期API

啥是枚举？
更通俗的理解就是:你想要的类型和常量,我都给你限定在枚举里了,你只能使用我限定的这些；
枚举是 jdk1.5引入的新特性,枚举是一种规范,它规范了参数的形式.；
枚举值定义在被调用层。
枚举的值采用设定的固定值，后续增加的枚举值不会影响到先前设定的固定值。

4.mybatis和ibatis的配置文件使用>和<的情况

<使用<替代

使用>替代

5.mybatis如何批量插入？

其实就是insert标签加上foreach标签；

1、序列化和反序列化的定义：

(1)Java序列化就是指把Java对象转换为字节序列的过程

 Java反序列化就是指把字节序列恢复为Java对象的过程。

(2)序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

   反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息）。

6.mysql得存储引擎？
InnoDB是事务型数据库的首选引擎，通过上图也看到了，InnoDB是目前MYSQL的默认事务型引擎，是目前最重要、使用最广泛的存储引擎。支持事务安全表（ACID），支持行锁定和外键。InnoDB主要特性有：

场景：由于其支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交（commit）和回滚（rollback）。

MyISAM存储引擎
场景：如果表主要是用于插入新记录和读出记录，那么选择MyISAM能实现处理高效率。

MERGE存储引擎
场景：对于服务器日志这种信息，一般常用的存储策略是将数据分成很多表，每个名称与特定的时间端相关。例如：可以用12个相同的表来存储服务器日志数据，每个表用对应各个月份的名字来命名。当有必要基于所有12个日志表的数据来生成报表，这意味着需要编写并更新多表查询，以反映这些表中的信息。与其编写这些可能出现错误的查询，不如将这些表合并起来使用一条查询，之后再删除Merge表，而不影响原来的数据，删除Merge表只是删除Merge表的定义，对内部的表没有任何影响。

MEMORY存储引擎
场景：如果需要该数据库中一个用于查询的临时表。

ARCHIVE存储引擎

场景：由于高压缩和快速插入的特点Archive非常适合作为日志表的存储引擎，但是前提是不经常对该表进行查询操作。
Collection与Collections的区别？
 Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。实现该接口的类主要有List和Set，该接口的设计目标是为了各种具体的集合提供最大化的统一的操作方式。
  Collections是针对集合类的一个包裹类，它提供了一系列静态方法实现对各种集合的搜索、排序以及线程安全化等操作，其中的大多数方法都是用于处理线性表。Collections类不能实例化，如同一个工具类，服务于Collection框架。如果在使用Collections类的方法时，对应的Collection对象null，则这些方法都会抛出NullPointerException。
  
9.高并发下如何保证修改数据安全？

解决的办法：
第一种：悲观锁的引入，在用户修改数据的时候进行加锁的操作，其他用户想修改数据就必须等待前面的锁被释放他才能拿到，这样会导致线程阻塞
虽然这样的办法可以解决超发的问题，但是同时会带来其他的问题，在并发的情况下，所有的请求都 处于等待获取锁，这样会使得有些请求将无法获取到锁，出现死锁，内存溢出。
第二种：乐观锁（数据的更新通过版本号去更新，版本号不一致，不予更新数据，）这样的话可以增大CPU的计算开销。
最佳办法：对于高发的活动（秒杀、抢购等），采用分布式锁的方式去处理，可以解决超发问题。后面我会详细的说明redis分布式锁的使用。