1:字符串如何倒序输出？
1 toCharArray()
2 StringBuffer的reverse()方法
StringBuffer sb = new StringBuffer();
sb.append(a); //放数据
String rea = sb.reverse().toString();//倒序输出，sb.reverse()是StringBuffer类型
2:StringBuffer,String,StringBulider区别？
3: Map与Hashmap 的关系？ Map是一个接口不能实例化，HashMap是Map的一个实现
4:HashMap与HashTable 的关系？
5：HashMap和TreeMap区别？ http://www.importnew.com/7010.html
6：Hashmap什么时候扩容？ Hashmap在元素达到负载因子对应数的时候就发生扩容
7：Map里如何放list，如何得到list中的值？list 中放Map 呢？
HashMap嵌套ArrayList的代码实现
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>> ();
ArrayList嵌套HashMap
ArrayList<HashMap<String, String>> list = new ArrayList<HashMap<String,String>>();
8：对 Ioc理解
控制反转，存放对象的容器，对象的创建，在jvm启动时通过反射创建。用户想得到对象，通过注入方式取得。
9：Aop的应用 性能检测，访问控制，日志管理，事务等
10:ArrayList 与 LinkedList 的特点
ArrayList:查询快，插入.删除慢 数据结构 :数组, LinkedList 双向链表 查询慢插入.删除快
11:冒泡排序。
12:了解的设计模式，举例
13:hibernate 的一级缓存与二级缓存 ,生命周期?
一级：session 缓存，线程内的缓存，使用一级缓存的目的是为了减少对数据库的访问次数,缓存的生命周期依赖于Session的生命周期，当Session被关闭后，缓存也就结束生命周期 。
二级缓存，sessionFactory 缓存，进程内的缓存。缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围.
14:Mysql的主键自动增长如何设置 CREATE TABLE XXX (ID INT(5) PRIMARY KEY AUTO_INCREMENT
15:linix的常用命令，配环境变量？
a . pwd：用于显示当前工作目录；
b . ls：用于查看当前工作目录内容；
c . cd：用于改变当前工作目录。
16:Spring有几种注入方式 ?
常用的注入方式主要有三种：构造方法注入，setter注入，基于注解的注入。
17:ApplicationContext 与 BeanFactory 的区别 
18:c3p0 如何配置？
c3p0的配置方式分为三种，分别是
1.setters一个个地设置各个配置项(不推荐)
2.类路径src下提供一个c3p0.properties文件
3.类路径src下提供一个c3p0-config.xml文件 (推荐)
1.最常用配置
initialPoolSize:连接池初始化时创建的连接数,default : 3（建议使用）
minPoolSize:连接池保持的最小连接数,default : 3（建议使用）
maxPoolSize:连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大,default : 15（建议使用）
acquireIncrement:连接池在无空闲连接可用时一次性创建的新数据库连接数
2：就是数据源，即数据库连接
注意：
1::配置完c3po.cfg.xml文件后，在spring配置的xml中去读取它。
2：c3po.cfg.xml文件一定要放在src下
19:log4j日志如何配置？
日志级别：
DEBUG:用在任何觉得有利于在调试时更详细的了解系统运行状态的东东
INFO:输出信息：用来反馈系统的当前状态给最终用户的、
WARN:可修复，系统可继续运行下去
ERROR:可修复性，但无法确定系统会正常的工作下去
FATAL:相当严重，可以肯定这种错误已经无法修复，并且如果系统继续运行下去的话后果严重
级别顺序：DEBUG < INFO < WARN < ERROR < FATAL
--------------------------------------------------------------------------------------
log4j 使用步骤：
1：引入log4j的jar 包
2：在src下配置log4j.properties.主要是配置输出路径，输出时间格式，控制台选项
3： 在web.xml中加入：
<context-param>
<param-name>webAppRootKey</param-name>
<param-value>webapp.root</param-value>
</context-param>
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:log4j.properties</param-value>
</context-param>
<context-param>
<param-name>log4jRefreshInterval</param-name>
<param-value>3000</param-value> 容器会每30秒扫描log4j的配置文件
</context-param>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
3.1 在web.xml 配置 log4j.properties。
3.2 在web.xml 配置 log4j的监听
4：在类中
Logger log = Logger.getLogger(TestString2StringArr.class);
log.info("aaaa");
20:SessionFactory 的作用？
SessionFactory在Hibernate中实际上起到了一个缓冲区的作用 他缓冲了HIbernate自动生成SQL语句和其他的映射数据 还缓冲了一些将来有可能重复利用的数据.
SessionFactory用到了工厂模式 用户程序从工程类SessionFactory取得Session实例 设计者的意图就是让它能在整个应用中共享 典型的来说 一个项目通常只需要一个SessionFactory就够了.
21:ajax 的同步与异步？什么是异步？
同步处理就不一样了，说话后在吃饭，吃完饭后在看手机，必须等待上一件事完了，才执行后面的事情
比方说一个人边吃饭，边看手机，边说话，就是异步处理的方式。
AJAX 是一种用于创建快速动态网页的技术。
通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。
传统的网页（不使用 AJAX）如果需要更新内容，必需重载整个网页面。
22:数据如何在后台校验，如：邮箱，手机号，身份证号等？
23:MyBatis 的${} 与 #{} 的区别？MyBatis 如何批量插入？
1: id=111 ,用#{},where id=#{id},转为 where id="111"; 用${}, where id= ${id},转为where id="id";
2: 用#{}方式能够很大程度防止sql注入，$方式无法防止Sql注入。
3：一般能用#的就别用$。
MyBatis批量插入:
1：xml 中 daomapping 文件
<insert id="insertBatch">
INSERT INTO t_user
(id, name, del_flag)
VALUES
<foreach collection ="list" item="user" separator =",">
(#{user.id}, #{user.name}, #{user.delFlag})
</foreach >
</insert>
2：public void testInsertBatch() throws Exception {
long start = System.currentTimeMillis();
List<User> list = new ArrayList<>();
User user;
for (int i = 0; i < 10000; i++) {
user = new User();
user.setId("test" + i);
user.setName("name" + i);
user.setDelFlag("0");
list.add(user);
}
userService.insertBatch(list);
long end = System.currentTimeMillis();
System.out.println("---------------" + (start - end) + "---------------");
}
24:web前后台数据交互的几种方式？ json数据格式怎么验证格式正确？
1.通过eval( ) 方法将字符串直接转化为JSON对象 并获得元素的值。
var json_text = "{'book':{'name':'JAVA编程','author':['Liu','Xu']},'num':222}"; //使用eval()将字符串转换为对象 var json_obj = eval("("+ json_text +")");
注意："()"运算符
2：可以用JSON.parse(str);
var str = '{"a":"1","b":"2"}';
JSON.parse(str);
结果是：Object{a:"1",b:"2"}
注意：可以利用JSON Schema校验JSON数据格式
----------------------------------------------
1 利用session对象 ，当客户访问同一网站的不同网页时，仍处于同一个session中。
（1）后台代码
request.getSession().setAttribute("name", name);
request.getSession().setMaxInactiveInterval(2);
response.sendRedirect("welcome.jsp");
（2）前台代码（jsp页面）
Object user=request.getSession().getAttribute("name");
2 利用request重定向，设置setAttribute
（1）后台代码
request.setAttribute("name", "cute");
request.getRequestDispatcher("welcome.jsp").forward(request, response); //网址不会改变
（2）前台代码
String name=request.getAttribute("name").toString();
3 利用Ajax进行异步数据请求（得到的数据可以以json或xml格式返回，便于处理）
25:try ...catch......与 return ,finally在return前执行还是后？
try{
return.....;
}catch(){
}
finally{
return .....;
} return 3;
若finally{ }存在，执行try 或者catch中的return语句之后，在返回之前执行finally{} ,顺序执行finally{}中的return 方法，finally中的return是一定会被return的，返回值以finally中的retrun返回值为准。注意:若代码中finally{}后还有 return ....; 则程序编译不了，必须删除掉finally{ } 后面的return ...; 程序才能正确编译。
26:垃圾处理器 GC的工作原理，GC什么时候执行 系统自身决定对不使用的对象删除，腾出内存空间。
27:SQL 关键字的执行顺序 
28:SpringMVC 如何搭建环境？ spring？hibernate？ MyBatis？
springmvc 环境基本配置
引入jar》》web-inf/lib
1：配置web.xml 中 前端控制器，初始化配置
2：创建springmvc 的xml文件
2.1 扫描包
2.2 跳转文件的前后缀
-----------------------------------------------------------------
spring 环境基本配置
引入jar》》web-inf/lib
1：在web.xml 中
1.1 配 ContextLoaderListener 监听器
1.2 配 spring的xml文件
2. 创建spring的xml文件。
2.1 开启扫描
2.2 扫描注解Bean,保证@Service @Repository的属性被注入
2.3 配置事物管理
----------------------------------------------------------------
hibernate 环境配置
引入jar》》web-inf/lib
方法一：
1 src 下创建hibernate的核心配置文件 hibernate.cfg.xml。
1.1 配置数据源
1.2 配置sessionFactory
1.3 注册实体类的映射xml 如 user.hbm.xml
2.创建实体类，同一个包下创建实体类的映射xml，在xml中对应映射关系
注意：
1 :方法一的hibernate.cfg.xml 的位置必须是在src下。
2 :实体类的映射xml最好与实体类在一个包下
方法二：
注解方式，hibernate.cfg.xml和实体类映射xml 都不用配置
1:在spring 的配置xml 中
1.1 配置数据源
1.2 配置sessionFactory ,配置属性去扫描实体类。
2:实体类中直接使用hibernate注解就可以了
--------------------------------------------------------------------------------------------
MyBatis的环境配置
配置文件方式
1 .创建Dao接口，定义方法
2：创建实体类
3：创建实体类的mapper.xml 文件 主要是写sql语句，Mapper中select标签的id值与dao中方法名一样
4：mybatis-config.xml
4.1数据源
4.2注册映射用户的mapper.xml 文件
4.3 给实体类起别名。
注意：
1：普通web项目的mybatis-config.xml 的位置放在 src/config 下，mavne项目要配置在src/main/resources下面
2：实体类的mapper.xml 文件放在mavne项目要放在 src/main/resources下
---------------------------------------
MyBatis 传参数如 map 怎么传？https://blog.csdn.net/earthhour/article/details/79635633
mapping:
<update id="publishT00_notice" parameterType="Map">
update test set createdate = #{createdate}, creator = #{creator} where id in
<foreach collection="ids" item="ids" separator="," open="(" close=")">
#{ids}
</foreach>
</update>
-----------------------
HashMap<String,Object> map = new HashMap<String, Object>();
map.put("creator", "creator");
map.put("createdate", "createdate");
String[] ids = {"1","2"};
map.put("ids", ids );
29:spring 的注解有哪些？springMVC的注解，hibernate的注解,mybatis 注解？
Hibernate常用注解
1 类级别注解：
@Entity：表示映射一个实体类
@Table表示实体对应数据库表的信息
2 属性级别注解
@Id：必须的，定义映射到数据库表的主键属性, @Column描述了数据库表中该字段的详细。
@GeneratedValue：@GeneratedValue(strategy=GenerationType,generator=""):可选，用于定义主键生成策略。strategy表示主键生成策略，取值有： GenerationType.AUTO：根据底层数据库自动选择(默认)
@Column描述了数据库表中该字段的详细定义 。
name：可选，表示数据库中该字段的名称
unique：可选，表示该字段是否是唯一标识，默认为false
---------------------------------------------------------------------------------------
Springmvc 常用注解：
@Repository对Dao实现类进行注解 (特殊的@Component)
@Service 用于对业务逻辑层进行注解， (特殊的@Component)
@Controller 用于控制层注解
@RequestMapping：用于处理请求地址映射，可以作用于类和方法上。
1 value：定义request请求的映射地址
2 method：定义地request址请求的方式，包括【GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.】默认接受get请求，如果请求方式和定义的方式不一样则请求无法成功。
3 params：定义request请求中必须包含的参数值。
4 headers：定义request请求中必须包含某些指定的请求头，如：RequestMapping(value = "/something", headers = "content-type=text/*")说明请求中必须要包含"text/html", "text/plain"这中类型的Content-type头，才是一个匹配的请求。
5 consumes：定义请求提交内容的类型。
6 produces：指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回
@RequestParam：用于获取传入参数的值
1 value：参数的名称
2 required：定义该传入参数是否必须，默认为true，（和@RequestMapping的params属性有点类似）
@RequestBody
该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上 ,再把HttpMessageConverter返回的对象数据绑定到 controller中方法的参数上
@ResponseBody
该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区
@ModelAttribute
在方法定义上使用 @ModelAttribute 注解：Spring MVC 在调用目标处理方法前，会先逐个调用在方法级上标注了@ModelAttribute 的方法
在方法的入参前使用 @ModelAttribute 注解：可以从隐含对象中获取隐含的模型数据中获取对象，再将请求参数 –绑定到对象中，再传入入参将方法入参对象添加到模型中
@RequestParam 在处理方法入参处使用 @RequestParam 可以把请求参 数传递给请求方法
@PathVariable 绑定 URL 占位符到入参
@ExceptionHandler 注解到方法上，出现异常时会执行该方法
@ControllerAdvice 使一个Contoller成为全局的异常处理类，类中用@ExceptionHandler方法注解的方法可以处理所有Controller发生的异常
-----------------------------------------------
Spring 常用注解
@Controller只是定义了一个控制器类
@ Service 标注业务层组件
@Repository 标注数据访问DAO组件
@Autowired 按照Type 注入
@Scope 用于指定scope作用域的（用在类上）默认为 singleton
备注：用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。
-------------------------------------------
Mybatis 常用注解
基本注解
@Insert 简单插入
@Update 简单更新
@Delete 简单删除
@Select 简单查询
@Result()实现结果集封装
@Results() 可以与@Result 一起使用，封装多个结果集
高级注解 允许创建动态SQL
@SelectProvider
@InsertProvider
@UpdateProvider
@DeleteProvider
30:线程的几种状态？start（）与 run( ), wart() 与sleep（）区别？如何唤醒 sleep 方法
sleep来自Thread类，和wait来自Object类调用sleep()方法的过程中，线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁 .sleep睡眠后不出让系统资源，wait让出系统资源其他线程可以占用CPU
sleep(milliseconds)需要指定一个睡眠时间，时间一到会自动唤醒
31:Jvm 内存如何划分？分别存储那些数据？ 堆区，方法区，栈区 见51题
32:String s=“abc” 与 String s= new String("abc"); 创建几个对象？
33:java 截取字符串有 substr() 的么？ 没有
34:string 的常用方法有哪些？
length（）：求字符串的长度
indexOf（）：求某个字符在字符串中的位置 str1.indexOf("c")
equals（）：比较两个字符串是否相同
replace（）：将字符串中的某些字符用别的字符替换掉 str3.replace("aa","bb"),bb取代aa
substring（）：输出一个新的字符串，它是此字符串中的子串，形如substring（3,7）；它将字符串中的第四个第五个第六个输出。
trim（）：将字符串开头的空白（空格）和尾部的空白去掉。
toLowerCase（）:将字符串中所有的大写改变成小写
toUpperCase（）：将字符串中所有的小写改变为大写
split（）:根据给定正则表达式的匹配拆分此字符串
charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1
35:怎么定义一个数组？int 或String 类型的？
int anArray2 = new int[10] ；int [] intArr= {1,2,3,4}; int [] inta1= {};String 同int
36:Servlet 的生命周期？
加载 Servlet的 class实例化 Servlet----->调用 Servlet的 init完成初始化---->响应请求（Servlet的 service方法）调用doget()或dopost()方法----->Servlet容器关闭时(Servlet的destory方法)
37:各种类型的转换
38:Jsp 中的@include
39:虚拟机加载类的过程
当java编译器将.java文件编译成.class文件后，需要JVM执行.class文件，将class文件加载到内存中，从而对数据进行校验、解析和初始化
40:TCP协议，通信
41:数据的装箱与拆箱？ int 与Integer 区别？
1 Integer 是 int 包装类，int 是八大基本数据类型之一
2、Integer 是类，默认值为null，int是基本数据类型，默认值为0；
3、Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值
42:JDK和CGLIB生成动态代理类的区别：
JDK动态代理只能针对实现了接口的类生成代理（实例化一个类）。此时代理对象和目标对象实现了相同的接口，目标对象作为代理对象的一个属性，具体接口实现中，可以在调用目标对象相应方法前后加上其他业务处理逻辑
CGLIB是针对类实现代理，主要是对指定的类生成一个子类（没有实例化一个类），覆盖其中的方法 。
43:SpringMVC与Struts2区别与比较总结 https://blog.csdn.net/chenleixing/article/details/44570681
44:post与get的区别 ?
45:Override和Overload的含义以及区别 
46:内存溢出是什么？ 对象有被指向的引用，但是再也用不到它就是内存溢出了
47:class Number{
int i;
};
public class TestCommonClass {
public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();
n1.i=9;
n2.i=47;
System.out.println("n1.i："+n1.i+",n2.i:"+n2.i);
n1=n2;
System.out.println("n1.i："+n1.i+",n2.i:"+n2.i);
n1.i=27;
System.out.println("n1.i："+n1.i+",n2.i:"+n2.i);
}
}
结果：
n1.i：9,n2.i:47
n1.i：47,n2.i:47
n1.i：27,n2.i:27
48:public class TestHelloString {
public static void main(String[] args) {
String s1="Hello";
String s2="Hello";
String s3="Hel"+"lo";
String s4="Hel"+new String("lo");
String s5=new String("Hello");
String s7="H";
String s8="ello";
String s9=s7+s8;
System.out.println(s1==s2);//true
System.out.println("s1.equeals s2:"+s1.equals(s2));//true
System.out.println(s1==s3);//true
System.out.println("s1.equeals s3:"+s1.equals(s3));//true
System.out.println(s1==s4);//false
System.out.println("s1.equeals s4:"+s1.equals(s4));//true
System.out.println(s1==s5);//false
System.out.println("s1.equeals s5:"+s1.equals(s5));//true
System.out.println(s1==s9);//false
System.out.println("s1.equeals s9:"+s1.equals(s9));//true
System.out.println(s4==s5);//false
System.out.println("s4.equeals s5:"+s4.equals(s5));//true
}}
49:public class TestDoWhile {
public static void main(String[] args) {
int x=0;
int y=10;
do{
y--;
x++;
}while(x<5);
System.out.println(x+","+y);
}} 答案： 5,5
50:编译失败 compilation fails
51:Jvm 的内存分布？
栈:数组引用,局部变量，对象的引用。
堆区：存储对象本身的以及数组，实例变量。
方法区：存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等
52:关于静态代码块，实例代码块， 父类构造方法，子类构造方法， 静态变量，变量的加载顺序？
public class TestMethodCiXu extends Test1{
static{
new Print("a");
}
public static Print obj1=new Print("b");
public Print obj2=new Print("c");
public TestMethodCiXu(){
new Print("d");
}
public static Print obj3=new Print("e");
public Print obj4=new Print("f");
public static void main(String[] args) {
TestMethodCiXu obj1 = new TestMethodCiXu();
System.out.println("----------------------");
TestMethodCiXu obj2 = new TestMethodCiXu();
}}
class Test1{
public static Print obj1=new Print("1");
public Print obj2=new Print("2");
public static Print obj3=new Print("3");
static{
new Print("4");
}
public static Print obj4=new Print("5");
public Print obj5=new Print("6");
public Test1(){
new Print("7");
}
}
class Print{
public Print(String s){
System.out.print(s+"");
}}
总结： 加载顺序 第一次创建对象： 1：先父类 ，再子类， 2 父类 静态变量/静态代码块 > 子类 静态变量 / 静态代码块 > 父类 变量 > 父类 无参构造>子类 变量 >子类 无参构造 第二次加载： 1：静态变量与静态代码块不执行。2 父类变量> 父类构造方法 > 子类 变量> 子类构造方法
53:Spring Bean 的生命周期？
54:runtimeException 有哪些？
NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常
55:编译异常：IOException、SQLException
56:Servlet 的生命周期，及servlet 的单实例，只能创建一个对象，用到了单例，模板设计模
57:spirng 有哪些模块？ Aop ORM, DAO,CORE ,WEB,MVC,CONTEXT
58:hibernate 拒绝连接，服务器崩溃的原因有哪些？
1：driver,url, pw 错误，2，db 没开 3.网络问题 4.服务器连接人数有限制
59:hibernate 与 mybatis 的区别？
Mybatis和hibernate不同，它不完全是一个ORM框架，因为MyBatis需要程序员自己编写Sql语句，不过mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。
Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。
Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的缺点是学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。
60:oracle 与 MySQL的区别？ https://www.cnblogs.com/TaoLeonis/p/7043543.html
|
Mysql与Oracle 的对比 |
|||
|
区别点 |
Mysql |
Oracle |
|
|
数据类型 |
CHAR:定长字符串，适合主键 VARCHAR：变长字符串 FLOAT, 数值型 DOUBLE, 数值型 DATE , 日期型 INT 整型 |
字符类型 char 定长字符类型 varchar可变长的字符类型 varchar2 可变长的字符类型 二进制大对象 BLOB 主要用来存储图片,音频,视频.... 文本大对象 CLO主要用来存放大文本 Date 数字类型 number |
|
|
主键自动增长 |
Auto_increment 主键必须是整型才可以自增长 如creat TABLE t1 (tid INT (10) PRIMARY KEY auto_increment, tname varchar (10),tage int(2)); |
Oracle 中给主键设置自增长，先设序列，在设置触发器. |
|
|
单引号的处理 |
MYSQL里可以用双引号包起字符串， |
ORACLE里只可以用单引号包起字符串。在插入和修改字符串前必须做单引号的替换：把所有出现的一个单引号替换成两个单引号 |
|
|
分页 |
limit是mysql的语法 |
Oracle 中用rownum .取前n条数据，oracle中用rownum < m; 1：其中m-1 等于要取的条数 2：rownum 只能有 < ,<= ，没有 > 3: 如m为6，则取得是前5条数据。 |
|
|
日期字段 |
MYSQL日期字段分DATE和TIME两种 |
ORACLE日期字段只有DATE，包含年月日时分秒信息 |
|
|
空字符的处理 |
MYSQL的非空字段也有空的内容 如：name != ""这样在mysql下不会报错 |
ORACLE里定义了非空字段就不容许有空的内容 。 如果为NULL或空字符，需要把它改成一个空格的字符串。如：在oracle下的要换成name is not null |
|
|
Sql语句group by |
Mysql不要求group by 后的字段 一定要出现在select 后面。 |
oracle中sql 的group by 后的字段 一定要出现在select 后面 |
|
|
开源项目 |
MySQL是开源的项目 |
付费 |
|
|
SQL语法的不同 |
MySQL较为灵活 |
Oracle较为严格 |
|
|
事务 |
事务的提交 |
MySQL默认是自动提交
|
Oracle默认不自动提交，需要用户手动提交
|
|
事务隔离级别 |
MySQL是可重复读
|
读已提交 |
|
|
对事务的支持 |
MySQL在innodb存储引擎的行级锁的情况下才可支持事务 |
Oracle则完全支持事务
|
|
|
保存数据的持久性 |
MySQL是在数据库更新或者重启，则会丢失数据 |
Oracle把提交的sql操作线写入了在线联机日志文件中，保持到了磁盘上，可以随时恢复 |
|
|
用户权限 |
放在mysql 自己的mysql 库中 |
oracle 的权限是跟着表空间走的 |
|
61:& 与&& 的区别？
首先记住&是位操作，而&&是逻辑运算符。另外需要记住逻辑运算符具有短路特性，而&不具备短路特性
62:springmvc 的工作流程？
1用户发起请求到前端控制器（DispatcherServlet）
2 前端控制器会找到处理器映射器（HandlerMapping），通过HandlerMapping完成url到controller映射的组件，找到handler，返回给dis。
3 前端控制器 找到 处理适配器HandlerAdapter，访问处理器，并执行，
4 执行处理器得到mv,最终返回给 前端控制器。
5 前端控制器 请求 视图解析器vr,得到视图对象，vr根据名称得到页面， 返回给前端控制器
6 前端控制器 进行视图渲染，返回给用户
63:struts2 的mvc 模式？
64:hibernate的并发模式？怎么去处理并发问题？
Hibernate的Session对象是非线程安全的, 即单个事务 ,它通常只使用一次, 然后就丢弃。当多个事物并发访问同一个资源会引发一系列的问题。
解决方法:
1 设置事务隔离级别。
2 Serializable：串行化。隔离级别最高
3 设置锁：乐观锁和悲观锁
65:sql 的怎么优化？
1 对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。
2: 应尽量避免在 where 子句中对字段进行
2.1 null 值判断
2.2 使用!=或<>操作符
2.3用 or 来连接条件
2.4 like '%abc%'
2.5 表达式操作 如：where num/2=100
2.6 函数操作 如： where substring(name,1,3)='abc'
2.7 in 和 not in，否则将导致引擎放弃使用索引而进行全表扫描.
3.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致.
4.很多时候用 exists 代替 in 是一个好的选择
5.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率
6.尽可能的使用 varchar 代替 char,尽量使用数字型字段.
7.任何地方都不要使用 select *
8.避免频繁创建和删除临时表，以减少系统表资源的消耗
9.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表
10 在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，
以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert
11 如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定
12.尽量避免使用游标，因为游标的效率较差, 尽量避免大事务操作，提高系统并发能力
13.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理
66:hibernate 自带的分页是什么？，若不用它，采用什么分页？
67:session 与cooker的区别，原理？
1）cookie 是一种发送到客户浏览器的文本串句柄，并保存在客户机硬盘上，可以用来在某个WEB站点会话间持久的保持数据
2）session其实指的就是访问者从到达某个特定主页到离开为止的那段时间。 Session其实是利用Cookie进行信息处理的，当用户首先进行了请求后，服务端就在用户浏览器上创建了一个Cookie，当这个Session结束时，其实就是意味着这个Cookie就过期了。
3）cookie和session的共同之处在于：cookie和session都是用来跟踪浏览器用户身份的会话方式。
4）cookie 和session的区别是：cookie数据保存在客户端，session数据保存在服务器端。
5）session工作原理：session技术中所有的数据都保存在服务器上，客户端每次请求服务器的时候会发送当前会话的sessionid，服务器根据当前sessionid判断相应的用户数据标志，以确定用户是否登录或具有某种权限。
68:web 项目下- web app libraries 怎么来的？ lib 下的jar 包引进了后，自动生成的。
69:关于java 中的 值传递。
public class Example {
String str = new String("good");
char[] ch = { 'a', 'b', 'c' };
public static void main(String args[]) {
Example ex = new Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.print(ex.ch);
}
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'g';
}
}
答案： good and gbc
因为在java里没有引用传递，只有值传递
这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递
70: 抽象类与抽象方法关系？
抽象类中的抽象方法没有方法体。1.抽象类与抽象方法的关系是：抽象方法必须在抽象类中，如果抽象方法不在抽象类中，则会编译报错，这个是规定的。2.抽象类中的方法不一定要必须是抽象方法，可以有抽象方法，和非抽象方法。其中非抽象方法，往往都是抽象类的所有子类所具有的，而抽象方法则由具体的不同子类实现不同的方法
71：抽象类和接口的区别，做个总结吧：
72： notify() 与notifyAll()的区别
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争
73：如何建立索引。mysql，Oracle中呢？
什么样的字段应该创建索引呢?
1.该字段中存储的数据库量比较大
2.该字段的数据很少执行DML操作( update,insert)
3.该字段经常出现在查询条件中(也就是WHERE子句)
---------------------------------------------------------------
Mysql
为什么使用索引？
如果未使用索引,不得不首先以第一条记录开始，然后读完整个表直到它找出相关的行.
索引分类？
PRIMARY：主键索引。索引列唯一且不能为空；一张表只能有一个主键索引（主键索引通常在建表的时候就指定）
NORMAL：普通索引。索引列没有任何限制；
UNIQUE：唯一索引。索引列的值必须是唯一的，但允许有空;
怎么创建.指定,删除索引?
create index 索引名 on 表名(列名);
ALTER TABLE 表名 ADD 索引名(列名)
DROP INDEX 索引名 ON 表名
注意事项
只要列中包含NULL值将不会被包含在索引中，组合索引只要有一列含有NULL值，那么这一列对于组合索引就是无效的
oracle
创建索引:create index 索引名 on 表名(列名);
删除索引:DROP INDEX 索引名
74：java与js中字符串截取substring() 与substr（）方法区别
|
substring 与substr 区别 |
|||||
|
JAVA |
JS |
例如： var str=“Olive”； 1 Str.substring(3,4); 2 Str.substr(3,4); |
总结 |
||
|
JAVA |
JS |
||||
|
substring(start,end) 下标
|
1:参数:1或2 2:第一个参数表示从第几位下标开始, 第二位代表下标 |
1:参数:1或2 2:第一个参数表示从第几位下标开始, 第二位代表下标 |
“v” |
“v” |
1：JS与JAVA的截取字符串substring()使用方法一样 2：java没有substr()的使用方法 3：注意:2个方法的下标开始位置都是0. 4：方法只有一个参数时，两个方法用法一致，即从该下标开始截取到字符串尾。java与js中都一样 |
|
Substr(a,b) 长度 |
无该方法 |
1:参数 1或2 2:第一个参数表示从第几位下标开始,第二位代表长度 |
无 |
“ve” |
|
76：char型变量中能不能存贮一个中文汉字?为什么?
char型占两个字节16位，一个汉字占用两个字节，java默认采用unicode编码，一个Unicode码是16位，所以java中能char类型能存一个汉字。
77:使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。
78：请说出作用域public，private，protected，以及不写时的区别
private< friendly < protected < public
79:线程的几种状态：
新建、就绪、运行、阻塞、死亡
80:多线程都有哪些常用方法？如何使用？
sleep() 使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。
yield() 该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。
wait() 方法使当前线程暂停执行并释放对象锁标示 ,让其他线程可以进入synchronized数据块
notify()方法 notifyAll()
Run()和start() 把需要处理的代码放到run()方法中 start()方法启动线程将自动调用run()方法，这个由java的内存机制规定的。并且run()方法必需是public访问权限，返回值类型为void。
wait()和notify(),notifyAll()是Object类的方法，sleep()和yield()是Thread类的方法
interrupt() 中断线程。
isAlive() 测试线程是否处于活动状态。
81：String s1 = "Programming";
String s2 = new String("Programming");
String s3 = "Program" + "ming";
System.out.println(s1 == s2); //false
System.out.println(s1 == s3); //true
82： int i = 1; int j; j = i++; j++; int m=++i;
System.out.println("i: "+i);//3
System.out.println("j: "+j);//2
System.out.println("m: "+m);//3
83：将 两个字符串数组放到一个新字符串数组中。
String[] str1 = {"Hello","world","java"};
String[] str2 = {"Veriable","syntax","interator"};
String[] both = (String[]) ArrayUtils.addAll(str1, str2);
System.out.print(both);
84：实体类书写规范
85 代码中如何实现多态
实现多态主要有以下三种方式：
1. 接口实现
2. 继承父类重写方法
3. 同一类中进行方法重载
86 多态的好处
-
可替换性：多态对已存在代码具有可替换性
-
可扩充性：增加新的子类不影响已经存在的类结构
-
接口性：多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。
-
灵活性
-
简化性
87 java 创建对象有几种方式？
1:采用new
2:通过反射
3:采用clone
4:通过序列化机制
88 final, finalize和finally的不同之处
final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。finalize 方法是在对象被回收之前调用的方法，给对象自己最后一个复活的机会，但是什么时候调用 finalize 没有保证。finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常
89 如何判断一个对象是否应该被回收? 对象可达性分析
90 调用System.gc()会发生什么? 通知GC开始工作，但是GC真正开始的时间不确定。
91 为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用
这是JDK强制的，wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁
92：@Autowired 与@Resource 的区别？
1：autowired spring提供，按类型进行装配，2 resource j2ee 提供，按名称装配。
93:如何解决hibernate中，懒加载load方法出现，no session的错误?
解决：web.xml中配置一个OpenSessionInViewFilter过滤器,注意，这个一定要配置在strus2/springMVC 的核心过滤器前面
94:如何解决Hibernate中出现并发所引起的数据库内容读取问题，如何进行解决？
采取悲观锁与乐观锁的机制来解决这个问题 ,悲观锁---------锁的粒度为数据库 sql 后+ for update , 乐观锁---锁的粒度为表
95:Hibernate有哪几种查询数据的方式?
3种，hql、条件查询QBC(QueryBy Criteria)、原生sql （通过createSQLQuery建立）
96：hibernate中get和load方法区别?
1）get如果没有找到会返回null， load如果没有找到会抛出异常。
2）get会先查一级缓存， 再查二级缓存，然后查数据库；load会先查一级缓存，如果没有找到，就创建代理对象， 等需要的时候去查询二级缓存和数据库。
97：如何解决servlet单例问题造成的线程不安全
把这个成员变量改成局部变量，那么所有的线程都会有一份，不会造成线程安全
98:分布式通信Webservies？Webservies(=wsdl+soap)
异构系统间的通信。客户端存根与服务端骨架的通信,使用axis 等服务。
Wsdl Webservies描述语言
Soap 面向对象的通信协议。(Http+xml)
Uddi: 目录(用不上)
Webservices 静态调用 (在客户端生成存根文件)项目应用步骤：
1：将axis的jar包 放到 tomcat/webapps/下
2：将wsdl服务保存成xml文件，保存到包中
3：可以使用批处理命令，将axis的jar 加到环境变量classpath 中。将wsdl2java。放到src下
4：cmd 执行批处理命令。刷新项目。生成存根文件
5：根据存根文件，调用接口，即可实现异构系统的通信
99:jsp和servlet 的区别，共同点，使用场景?
JSP在本质上就是SERVLET，Servlet完全是JAVA程序代码构成，采用Servlet来控制业务流程，而采用JSP来生成动态网页，JSP侧重于视图，Servlet主要用于控制逻辑。
100 springboot 怎么用 ？
一：Spring Boot 整合了所有的框架.
二：Spring Boot的基础结构共三个文件:
1:src/main/java 程序开发以及主程序入口
2:src/main/resources 配置文件
3:src/test/java 测试程序
spingboot建议的目录结果如下:
project
Application.java
+ - domain
+- Customer.java
+- CustomerRepository.java
+- service
+- CustomerService.java
+- controller
+- CustomerController.java
1、Application.java 建议放到跟目录下面,主要用于做一些框架配置
2、domain目录主要用于实体（Entity）与数据访问层（Repository）
3、service 层主要是业务类代码
4、controller 负责页面访问控
--------------------------------------------------------------------------------------
三：使用环境：
1:若使用的是eclipse ,需安装插件Spring tool suite(sts),若使用的是idea旗舰版,idea 自带了springboot 插件。
2: 推荐使用maven3+,java8
使用的问题：
注意：
1：在idea中创建springboot 项目时，一定要配置maven 的安装路径，
setting 的覆盖路径，本地maven 路径。否则注解引不进来。
2：springboot的 ***Application.java 文件要与controller，service,domain
的包在同一级下，因为启动***application的main方法后，要扫描注解。
@SpringBootApplication springboot 的核心注解，开启spring自动配置。
-----------------------------------
四：springboot 开发web项目的pom.xml 配置
<modelVersion>4.0.0</modelVersion>
<!--项目说明-->
<groupId>com.bj.boot2</groupId>
<artifactId>boot2</artifactId>
<version>1.0.0</version>
<!--继承父级项目的依赖-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.6.BUILD-SNAPSHOT</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!--项目描述-->
<name>boot2</name>
<description>Demo project for Spring Boot</description>
<!--项目配置的jdk-->
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--springboot开发web项目的起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--springboot开发web项目测试的起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--springboot 提供的项目打包编译插件-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
--------------------------------------
五：springboot 核心配置文件：(配置端口，上下文等 )
配置位置：src/main/resources/
方式：两种：application.propertis，或 application.yml .
注意：application.yml 配置时的空格问题。两个格式同时用时 application.propertis 优先.
多环境配置：
如：resources下有 application.propertis application-test.propertis application-dev.propertis 多环境下使用时，可以在application中激活用哪个，spring.profiles.active=dev/test 就可以了。
-------------------------------------------------------------------------------------
六：springboot 下的springmvc 常用注解：
@Controller
@ResponseBody
@GetMapping: get请求+requestMapping
@PostMapping: Post请求+requestMapping
@RestController: 返回的一定是字符串或json数据,是@Controller和 @ResponseBody 注解的组合注解.
-------------------------------------------------------------------------------
七：idea 中Jsp 的开发配置：
1：pom.xml 引jsp的依赖，4个。
2：application.properties 下配置jsp 的前后缀。
3：在main下创建webapp 文件夹，webapp下放jsp.
4:在pom.xml >build> 添加 resources 标签依赖，用于webapp/jsp 的路径指引，idea 中需要配，eclipse 中不需要配(注意)
5：正常开发JspController .
---------------------------------------------------------------------------------------
八：idea 中对事物的管理。
1：在springboot 的入口***application.java 上加 @EnableTransactionManagement，开启事物。
2： 在具体的业务层service层的方法上加上@Transactional.
注意：springboot中service层的方法上若不加事物（如update方法），则方法中若存在运行时异常，数据照样commit。加上事物后，则数据库数据不会更新
----------------------------------
九：springboot 的热部署
热部署指的是修改代码后，服务器自动加载修改的代码，提高开发效率。
在pom.xml 添加 spring-boot-devtools 的插件。
注意：使用中出现明明已启动，没生效，这时手动启动程序。
------------------------------------------------------------------------------------------
十：springboot 中的servlet使用。
1：在servlet类上加上@webservlet("urlPatterns="servlet 映射路径"")、
2：在****application的类上加servlet的扫描注解。@ServletConpentScan(basePackages="servlet的路径")。
-----------------------------------------------------------------------
十一：springBoot 中开发非web项目。
Java项目 步骤：new project/module> springboot> core>finish.
启动java项目：springbootContext.getBean("类");得到类对象，再调方法，启动run
注意：java项目创建时不要选web,则pom.xml 中的starter-web的web就没有了，就成了springboot开发java项目的依赖。
---------------------------------------------------------------------------------------------
十二：springboot中web项目打war/jar 包。
打war包：
1： ***application.java 继承 springbootServletInitializer, 覆盖 一个方法。
2：pom.xml 中的打包方式改为war
3.pom.xml 配置maven的打包插件。
4.运行maven install，成功后在pom.xml 的打包路径下看到 ...........war 文件.
打jar包：
1：pom.xml 中的打包方式改为jar.
2.pom.xml 配置maven的打包插件。
3:运行maven install，成功后在pom.xml 的打包路径下看到 ...........jar 文件
注意：打 jar包时，maven的打包插件使用 1.4.2 的版本 。其他的版本暂时打 jar包都有点问题。
-----------------------------------------------------------------------------------------
十三：jar/war 包上线部署
1：可以将jar/war 放到tomcat的webapps 下部署。
2：可以将war 放到Linux 下的shell 脚本下执行。
101 ngnix？
1、请解释一下什么是Nginx
Nginx是一个web服务器和方向代理服务器，用于HTTP、HTTPS、SMTP、POP3和IMAP协议。
2请解释Nginx如何处理HTTP请求。
Nginx使用反应器模式。主事件循环等待操作系统发出准备事件的信号，这样数据就可以从套接字读取，在该实例中读取到缓冲区并进行处理。单个线程可以提供数万个并发连接。
3 使用“反向代理服务器”的优点是什么?
反向代理服务器可以隐藏源服务器的存在和特征。它充当互联网云和web服务器之间的中间层。这对于安全方面来说是很好的，特别是当您使用web托管服务时。
4请列举Nginx服务器的最佳用途。
Nginx服务器的最佳用法是在网络上部署动态HTTP内容，使用SCGI、WSGI应用程序服务器、用于脚本的FastCGI处理程序。它还可以作为负载均衡器。
5 请解释Nginx服务器上的Master和Worker进程分别是什么?
Master进程：读取及评估配置和维持
Worker进程：处理请求
6请解释是否有可能将Nginx的错误替换为502错误、503?
502 =错误网关
503 =服务器超载
7 nginx常用命令
启动nginx ./sbin/nginx
停止nginx ./sbin/nginx -s stop ./sbin/nginx -s quit
重载配置 ./sbin/nginx -s reload(平滑重启) service nginx reload
重载指定配置文件 ./sbin/nginx -c /usr/local/nginx/conf/nginx.conf
查看nginx版本 ./sbin/nginx -v
检查配置文件是否正确 ./sbin/nginx -t
显示帮助信息 ./sbin/nginx -h
8 nginx状态码
轻量级，同样起web 服务，比apache 占用更少的内存及资源
抗并发，nginx 处理请求是异步非阻塞的，而apache 则是阻塞型的，在高并发下nginx 能保持低资源低消耗高性能
高度模块化的设计，编写模块相对简单
最核心的区别在于apache是同步多进程模型，一个连接对应一个进程；nginx是异步的，多个连接（万级别）可以对应一个进程
13 【试题1】缺省安装的 nginx + php-fpm 环境，假设用户浏览一个耗时的网页，但是却在服务端渲染页面的中途关闭了浏览器，那么请问服务端的 php 脚本是继续执行还是退出执行？
【解答】正常情况下，如果客户端client异常退出了，服务端的程序还是会继续执行，直到与IO进行了两次交互操作。服务端发现客户端已经断开连接，这个时候会触发一个user_abort，如果这个没有设置ignore_user_abort，那么这个php-fpm的程序才会被中断。
14【试题2】首先，Nginx 日志格式中的 $time_local 表示的是什么时间？请求开始的时间？请求结束的时间？其次，当我们从前到后观察日志中的 $time_local 时间时，有时候会发现时间顺序前后错乱的现象，请说明原因。
【解答】$time_local：在服务器里请求开始写入本地的时间，因为请求发生时间有前有后，所以会时间顺序前后错乱
102 jquery 有哪些选择器?
一.基本选择器
$("#test") 选择id值为test的元素，id值是唯一的所以返回单个元素。
$("div") 选择所有的div标签元素，返回div元素数组
$(".myclass") 选择使用myclass类的css的所有元素
$("*") 选取所有元素。
$("#test,div,.myclass") 选取多个元素
----------------------------------------------------------------------
二 .层次选择器
$("div span") 选取<div>里的所有<span>元素
$("div >span") 选取<div>元素下元素名是<span>的子元素
$("#one +div") 选取id为one的元素的下一个<div>同辈元素等同于$("#one").next("div")
$("#one~div") 选取id为one的元素的元素后面的所有<div>同辈元素等同于$("#one").nextAll("div")
$("#one").siblings("div") 获取id为one的元素的所有<div>同辈元素（不管前后）
$("#one").prev("div") 获取id为one的元素的前面紧邻的同辈<div>元素
所以 获取元素范围大小顺序依次为：
$("#one").siblings("div")>$("#one~div")>$("#one +div") 或是$("#one").siblings("div")>$("#one").nextAll("div")>$("#one").next("div")
----------------------------------------------------------------------
3.1.基本过滤选择器
$("div:first") 选取所有<div>元素中第1个<div>元素
$("div:last") 选取所有<div>元素中最后一个<div>元素
$("input:not(.myClass)") 选取class不是myClass的<input>元素
$("input:even") 选取索引是偶数的<input>元素(索引从0开始)
$("input:odd") 选取索引是基数的<input>元素(索引从0开始)
$("input:eq(2)") 选取索引等于2的<input>元素
$("input:gt(4)") 选取索引大于4的<input>元素
$("input:lt(4)") 选取索引小于4的<input>元素
$(":header") 过滤掉所有标题元素，例如：h1、h2、h3等
$("div:animated") 选取正在执行动画的<div>元素
$(":focus") 选取当前获取焦点的元素
---------------------------------------------------------------------
3.2.内容过滤选择器
$("div:contains('Name')") 选取所有<div>中含有'Name'文本的元素
$("div:empty") 选取不包含子元素（包括文本元素）的<div>空元素
$("div:has(p)") 选取所有含有<p>元素的<div>元素
$("div:parent") 选取拥有子元素的（包括文本元素）<div>元素
----------------------------------------------------------------------------------------
3.3.可见性过滤选择器
$("div:hidden") 选取所有不可见的<div>元素
$("div:visible") 选取所有可见的<div>元素
----------------------------------------------------------------------------------------
3.4 属性过滤选择器
$("div[id]") 选取所有拥有属性id的元素
$("input[name='test']") 选取所有的name属性等于'test'的<input>元素
$("input[name!='test']") 选取所有的name属性不等于'test'的<input>元素
$("input[name^='news']") 选取所有的name属性以'news'开头的<input>元素
$("input[name$='news']") 选取所有的name属性以'news'结尾的<input>元素
$("input[name*='news']") 选取所有的name属性包含'news'的<input>元素
$("div[title|='en']") 选取属性title等于'en'或以'en'为前缀(该字符串后跟一个连字符'-')的<div>元素
$("div[title~='en']") 选取属性title用空格分隔的值中包含字符en的<div>元素
$("div[id][title$='test']") 选取拥有属性id,并且属性title以'test'结束的<div>元素
-------------------------------------------------------------------------------------------
3.5.子元素过滤选择器
$("div .one:nth-child(2)") 选取class为'one'的<div>父元素下的第2个子元素
$("div span:first-child") 选取每个<div>中的第1个<span>元素
$("div span:last-child") 选取每个<div>中的最后一个<span>元素
$("div button:only-child") 在<div>中选取是唯一子元素的<button>元素
-------------------------------------------------------------------------------------
3.6.表单对象属性过滤选择器
$("#form1 :enabled") 选取id为'form1'的表单内所有可用元素
$("#form2 :disabled") 选取id为'form2'的表单内所有不可用元素
$("input :checked") 选取所有被选中的<input>元素
$("select option:selected") 选取所有的select 的子元素中被选中的元素
------------------------------------------------------------------
四.表单选择器
$(":input") 选取所有<input>,<textarea>,<select> 和 <button>元素
$(":text") 选取所有的单行文本框
$(":password") 选取所有的密码框
$(":radio") 选取所有单的选框
$(":checkbox") 选取所有的多选框
$(":submit") 选取所有的提交按钮
$(":image") 选取所有的图像按钮
$(":reset") 选取所有的重置按钮
$(":button") 选取所有的按钮
$(":file") 选取所有的上传域
$(":hidden") 选取所有不可见元素
103 ajax 有哪些参数?
1.url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。
2.type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和delete也可以使用，但仅部分浏览器支持。
3.timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局设置。
4.async: 要求为Boolean类型的参数，默认设置为true，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为false。注意，同步请求将锁住浏览器，用户其他操作必须等待请求完成才可以执行。
5.cache: 要求为Boolean类型的参数，默认为true（当dataType为script时，默认为false），设置为false将不会从浏览器缓存中加载请求信息。
6.data: 要求为Object或String类型的参数，发送到服务器的数据。如果已经不是字符串，将自动转换为字符串格式。get请求中将附加在url后。防止这种自动转换，可以查看 processData（防止自动转换）选项。对象必须为key/value格式，例如{foo1:"bar1",foo2:"bar2"}转换为&foo1=bar1&foo2=bar2。如果是数组，JQuery将自动为不同值对应同一个名称。例如{foo:["bar1","bar2"]}转换为&foo=bar1&foo=bar2。
7.dataType: 要求为String类型的参数，预期服务器返回的数据类型。如果不指定，JQuery将自动根据http包mime信息返回responseXML或responseText，并作为回调函数参数传递。可用的类型如下：
xml：返回XML文档，可用JQuery处理。
html：返回纯文本HTML信息；包含的script标签会在插入DOM时执行。
script：返回纯文本JavaScript代码。不会自动缓存结果。除非设置了cache参数。注意在远程请求时（不在同一个域下），所有post请求都将转为get请求。
json：返回JSON数据。
jsonp：JSONP格式。使用SONP形式调用函数时，例如myurl?callback=?，JQuery将自动替换后一个“?”为正确的函数名，以执行回调函数。
text：返回纯文本字符串。
8.beforeSend：这个参数主要是为了在向服务器发送请求前，执行一些操作。要求为Function类型的参数，发送请求前可以修改XMLHttpRequest对象的函数，例如添加自定义HTTP头。在beforeSend中如果返回false可以取消本次ajax请求。XMLHttpRequest对象是惟一的参数。
function(XMLHttpRequest){
this; //调用本次ajax请求时传递的options参数
}
10.success：要求为Function类型的参数，请求成功后调用的回调函数，有两个参数。
(1)由服务器返回，并根据dataType参数进行处理后的数据。
(2)描述状态的字符串。
function(data, textStatus){
//data可能是xmlDoc、jsonObj、html、text等等
this; //调用本次ajax请求时传递的options参数
}
error:
要求为Function类型的参数，请求失败时被调用的函数。该函数有3个参数，即XMLHttpRequest对象、错误信息、捕获的错误对象(可选)。
12.contentType：
要求为String类型的参数，当发送信息至服务器时，内容编码类型默认为"application/x-www-form-urlencoded"。该默认值适合大多数应用场合。
18.username：要求为String类型的参数，用于响应HTTP访问认证请求的用户名。
19.password：要求为String类型的参数，用于响应HTTP访问认证请求的密码。
20.processData：要求为Boolean类型的参数，默认为true。默认情况下，发送的数据将被转换为对象（从技术角度来讲并非字符串）以配合默认内容类型"application/x-www-form-urlencoded"。如果要发送DOM树信息或者其他不希望转换的信息，请设置为false。
104 :eacharts 动态数据加载？
https://www.cnblogs.com/zhaoyingjie/p/5963056.html
1：<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="zh-CN">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>ECharts</title>
<!-- 引入 echarts.js -->
<script type="text/javascript" src="echarts.min.js"></script>
<!-- 引入jquery.js -->
<script type="text/javascript" src="jquery-1.12.3.js"></script>
</head>
<body>
<!-- 为ECharts准备一个具备大小（宽高）的Dom -->
<div id="main" style=" 600px;height:400px;"></div>
<script type="text/javascript">
var myChart = echarts.init(document.getElementById('main'));
// 显示标题，图例和空的坐标轴
myChart.setOption({
title: {
text: '异步数据加载示例'
},
tooltip: {},
legend: {
data:['销量']
},
xAxis: {
data: []
},
yAxis: {},
series: [{
name: '销量',
type: 'bar',
data: []
}]
});
myChart.showLoading(); //数据加载完之前先显示一段简单的loading动画
var names=[]; //类别数组（实际用来盛放X轴坐标值）
var nums=[]; //销量数组（实际用来盛放Y坐标值）
$.ajax({
type : "post",
async : true, //异步请求（同步请求将会锁住浏览器，用户其他操作必须等待请求完成才可以执行）
url : "TestServlet", //请求发送到TestServlet处
data : {},
dataType : "json", //返回数据形式为json
success : function(result) {
//请求成功时执行该函数内容，result即为服务器返回的json对象
if (result) {
for(var i=0;i<result.length;i++){
names.push(result[i].name); //挨个取出类别并填入类别数组
}
for(var i=0;i<result.length;i++){
nums.push(result[i].num); //挨个取出销量并填入销量数组
}
myChart.hideLoading(); //隐藏加载动画
myChart.setOption({ //加载数据图表
xAxis: {
data: names
},
series: [{
// 根据名字对应到相应的系列
name: '销量',
data: nums
}]
});
}
},
error : function(errorMsg) {
//请求失败时执行该函数
alert("图表请求数据失败!");
myChart.hideLoading();
}
})
</script>
</body>
</html>
2：后台返回json数据
105：js 中循环怎么写？
let len = myArray.Length
for (let index = 0; index < len; index++) {
console.log(myArray[index])
}
-------------------
$.each(result,function(index,obj){ //result :数组， obj 当前对象，index 当前index.
});
106：easy-ui？
介绍一下easyui的布局
分为上，中，下，左，右面板 一般在工作中使用上（企业logo,登录,退出） 左（菜单）中（展示数据）
easyui如何实现表单验证
提供了一个validatebox插件来验证一个表单 input表单根据validType属性来应用验证 validType="email"邮箱验证 required="true"必填项
<input class="easyui-validatebox" type="text" name="name" validType="email" required="true"></input>
easyui如何实现表格分页
将pagination《陪觉诶寻》属性设为true 在数据网格下生成一个分页工具栏 工具栏会发送连个参数到服务器 page当前页 默认1 rows：每页显示行
问题1
同时打开的标签页共享id，导致id冲突
解决方法：抛弃直接使用tab的href属性，使用content，并让content的内容为iframe，iframe再指向对应的href
问题2：form表单中的reset无效
由于上述div放在form表单内，导致resetSearchForm方法无效，具体表现为点击reset按钮后确实清空了，但此时鼠标点进去某个控件，则控件之前的值会重新出现，说明重置无效，具体原因不详（不知道是不是form表单缓存了？），解决方法是将上述html代码拿到form表单外部
问题3：combobox远程获取数据默认显示第一条数据，且无法清除
原因：该条数据的value应该是0造成的，如
数据库中存在这样一条数据
1，无状态，0（id,name,value）
将这一条数据加载到前端后直接显示无状态，而不是空数据，将value改为非0即可
问题：https://blog.csdn.net/mafan121/article/details/70174418
easy-ui 学习：https://www.cnblogs.com/xdp-gacl/category/571424.html
107：json 中的JSON.stringify（），json.parse()是干嘛的?
JSON.stringify() 从一个对象中解析出字符串
JSON.stringify({"a":"1","b":"2"})
结果是："{"a":"1","b":"2"}"
JSON.parse()从一个字符串中解析出JSON对象
var str = '{"a":"1","b":"2"}';
JSON.parse(str);
结果是：Object{a:"1",b:"2"}
108: json 数据的格式是怎么样的?，怎么取值？
1.数组方式：
[
{"key1": "value1"},
{"key2": "value2"}
]
2. 对象方式：
{
“key1: "value1",
"key2": "value2",
"key3": [
{"key31": "value31"},
{"key32": "value32"}
]
}
取值： json.parse(json 字符串); 解析成对象，用对象去. 属性去得到值
109: json 中 list 转 json?
可以用 jsonArray放数据，再讲jsonarray.toString()
110: 如何调大jvm 内存?
Tomcat 进入tomcat的bin目录，使用文本编辑工具打开catalina.bat文件，在“rem ----- Execute The Requested Command”之后加上 set JAVA_OPTS=-Xms512m -Xmx512m。
Xms 初始值，Xmx 最大值。
注意：在设置tomcat内存的时候，不是越大越好，要结合实际情况来设置，物理内存大小和自身应用所需要的内存，取一个合适的值。很难一次就设置合适，需要通过检测工具多次观察内存的使用情况和回收情况。
111 :java用什么定时任务框架? 怎么配置? JS 怎么定时?settimeout 和 setintvor
使用的是spring3自带的spring task。
xml 配置：
第一步：新建一个spring-task.xml配置文件。
<!-- 定义调用对象-->
<bean id="springTaskXml1" class="com.zhh.test.controller.SpringTaskXmlController"> </bean>
<!-- 开启任务 -->
<!-- 配置相关类中方法的执行时间-->
<task:scheduled-tasks scheduler="taskScheduler" >
<!-- 每隔 2秒执行一次 -->
<task:scheduled ref="springTaskXml1" method="teskTest1" cron="*/2 * * * * ?"/>
<!-- 每天凌晨 01:00 执行一次 -->
<task:scheduled ref="springTaskXml1" method="teskTest2" cron="0 0 1 * * *"/>
</task:scheduled-tasks>
<!-- 线程个数（默认为1个，多个任务同一时间内只能串行执行，设置多个则可以并行执行） -->
<task:scheduler id="taskScheduler" pool-size="5"/>
第二步：建一个定时任务类
public class SpringTaskXmlController {
private static final Logger logger = Logger .getLogger(SpringTaskXmlController.class);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* 定时任务方法1
*/
public void teskTest1() {
//logger.info("定时任务开始执行。。。");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(sdf.format(new Date())+"执行定时任务1执行");
//logger.info("定时任务执行结束。");
}
/**
* 定时任务方法2
*/
public void teskTest2() {
System.out.println(sdf.format(new Date())+"执行定时任务2执行");
}
}
第三步：在spring的配置文件里引入spring-task.xml配置文件
<!-- 引入spring-task.xml配置文件 -->
<import resource="spring-task.xml"/>
---------------------------------------------------------------------------------
JS 中的setTimeout()和setInterval 定时方法。
setTimeout方法是定时程序，也就是在什么时间以后干什么。干完了就拉倒。
setInterval方法则是表示间隔一定时间反复执行某操作。
setTimeout (表达式,延时时间)//切记表达式是要加引号的；
setInterval(表达式,交互时间)
延时时间/交互时间是以豪秒为单位的(1000ms=1s)
例子：setInterval("showTime()",1000);
112 :Junit 怎么用？
113：webservices 中怎么网FTP 服务器上传东西?
114 java 怎么实现并发控制?
115: excel 大数据量下载? 500w条数据？
https://blog.csdn.net/u013488171/article/details/78184545
方法：
1：异步生成Excel，非实时，完成后使用某种方式通知用户，每次刷新页面获取最新状态、长连接方式实时通知
2： POI 改用 SXSSFWorkbook，循环中减少使用new，尽量复用；String改为StringBuffer就不说
3：生成多个excel文件，并打包成zip文件。
4：后台使用多线程去下载，分别生成excel文件，然后再合并。
5：调整JVM 相关的参数 -Xmx....
116：共享线程存在jvm 的哪一块?生命周期呢？
其中Method Area 和 Heap 是线程共享的，生命周期与JAVA程序运行的生命周期相 同。VM Stack，Native Method Stack 和Program Counter Register 是非线程共享的,生命周期与所属线程相同。Gc 回收场所只发生在堆区。
117：事物的隔离级别，传播特性?
事务的隔离级别：
事务的隔离级别也分为四种，由低到高依次分别为：read uncommited（读未提交）、read commited（读提交）、read repeatable（读重复）、serializable（序列化），这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题
- read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。
- read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。
- repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。
- serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读。
spring事务传播特性：
事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：
propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作
Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。
118: 反射怎么用?怎么创建class 对象?
1:将类路径加载到内存中，得到class对象。Class clz = Class.forName("com.zhenai.api.Apple");
2：通过class 对像得到构造器对象。Constructor appleConstructor = clz.getConstructor();
3：根据构造器对象的newInstance()得到反射类实例。Object appleObj = appleConstructor.newInstance();
4：通过class 对象getMethod() 得到方法对象。Method setPriceMethod = clz.getMethod("setPrice", int.class);
5：通过方法对象调invoke ()方法，参数是反射类对象，执行该方法。setPriceMethod.invoke(appleObj, 14);
获取 Class 类对象有三种方法：
第一种，使用 Class.forName 静态方法。当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象。
Class clz = Class.forName("java.lang.String");第二种，使用 .class 方法。
这种方法只适合在编译前就知道操作的 Class。
Class clz = String.class;第三种，使用类对象的 getClass() 方法。
String str = new String("Hello");
Class clz = str.getClass();119: springMVC 的单例，多例区别？怎么配置？怎么使用？
Springmvc默认是单例模式.spring bean作用域有以下5个,
1.singleton:单例模式，当spring创建applicationContext容器的时候，spring会欲初始化所有的该作用域实例，加上lazy-init就可以避免预处理；
2.prototype：原型模式，每次通过getBean获取该bean就会新产生一个实例，创建后spring将不再对其管理,
3.request：搞web的大家都应该明白request的域了吧，就是每次请求都新产生一个实例，和prototype不同就是创建后，接下来的管理，spring依然在监听
4.session:每次会话，同上
5.global session:全局的web域，类似于servlet中的application
------------------------------------------------------
例子：
@RestController
@RequestMapping(value = "hello")
@Scope("prototype")
public class HelloController {
private int i = 0;
@RequestMapping(value = "test1")
public int testSingle1() {
++i;
return i;
}
@RequestMapping(value = "test2")
public int testSingle2() {
++i;
return i;
}
}
http://localhost:8080/hello/test1
http://localhost:8080/hello/test2
http://localhost:8080/hello/test1
@Scope("prototype") 。结果：1,1,1
Scope 不写默认或@Scope("singleton")，则结果：1,2,3
-----------------------------------------------------------------------------
注意：
1、不要在controller中定义成员变量。
2、万一必须要定义一个非静态成员变量时候，则通过注解@Scope(“prototype”)，将其设置为多例模式
120:怎么创建视图? 存储过程? 约束有哪些？
约束的具体分类
1.非空约束(NOT NULL)
2.唯一约束(UNIQUE)
3.主键约束(PRIMARY KEY)
4.外键约束(FROEIGN KEY)
---------------------------------------------------
视图：实际上视图就是一个命名的查询;也就是把一个查询语句的查询结果做成一个临时表,然后从这个临时表中查询相关的数据; 注意:视图都是和一个有效的查询语句绑定在一起的!
创建视图 CREATE VIEW 视图名称 AS 有效的查询语句;
删除视图： drop view 视图名称 ; (注意：删除视图时 delete 无效)
视图的作用:
1.可以加快开发的速度,但是并不能提高查询的速度 ，如果一个查询结果经常被使用到,我们就应该把这个查询语句做成一个视图,加快开发的速度。
2.可以隐藏数据的真实来源;
注意：Mysql 中创建视图的注意事项:视图绑定的查询语句中,不能有出现在FROM后面的子查询! oracle对此不要求
比如：
CREATE VIEW V_EMP
AS
SELECT E.EMPNO,E.ENAME,E.DEPTNO,E.DNAME,E.LOC
FROM( SELECT E.*, D.DNAME,D.LOC
FROM EMP E
JOIN DEPT D ON (E.DEPTNO = D.DEPTNO)) E 在mysql 中创建视图时有误，oracle则不会。
---------------------------------------------------------------
Mysql存储过程
1:使用存储过程可以极大的提高数据的处理能力;
2:存储过程的缺点:在不同的数据库中,存储过程的语法都是不同的!也就是是,只要使用了存储过程,会导致我的程序无法移植;
创建存储过程的语法
CREATE PROCEDURE 存储过程的名称( [参数列表])
BEGIN
-- SQL 语句
END;
参数列表的规范:
参数的输入/输出类型 参数名称 参数的数据类型; 多个参数之间使用逗号分隔
参数的输入/输出类型分为三类
(1)IN类型:可以把外界的数据传递给过程,这是默认的类型
(2)OUT类型:可以把过程中的计算机结果返回给外界
(3)INOUT类型:既可以传入数据,也可以穿出计算结果
在声明参数的数据类的时候,不需要指明数据的长度,只需要声明类型即可
例1：创建一个存储过程,查询EMP表的数据总数并且返回查询结果
第一步：
CREATE PROCEDURE PROC1 ( OUT RES INT)
BEGIN
-- 把查询结果赋值给OUT类型的参数,通过OUT类型的参数将结果返回给调用者
SELECT COUNT(*) INTO RES FROM EMP;
END;
第二步：CALL PROC1(@num) 调用proc1这个存储过程,通过@num这种格式传递out类型的参数
第三步：SELECT @num; 我们调用存储过程之后,过程中的计算结果会通过OUT类型参数返回,查询out类型的参数的结果
---------------------------------------------------------------------
例2：创建一个存储过程,完成把两个参数相加并且返回结果的功能
// NUM1,NUM2没有声明输入/输出类型,默认的就是IN类型
CREATE PROCEDURE PROC2(NUM1 INT,NUM2 INT , OUT RES INT)
BEGIN
// 把NUM1 + NUM2的结果赋值给RES,通过RES返回计算结果
SET RES = NUM1 + NUM2;
END;
-- 调用存储过程
CALL PROC2(10,20,@RES);
SELECT @RES;
121 :oracle 取得 6-10条数据?rownum 怎么用?
oracle 中rownum 只有<= 用法，要取得 6-10条数据，要将rownum 转成实例，才能使用 >= 的比较。select * from (select a.*,rownum rn from aa a) a1 where a1.rn between 6 and 10，
或 SELECT name FROM (SELECT name, ROWNUM rn FROM member ) WHERE rn >= 6 AND rn <= 10。
122: git 怎么用?
123:Redios 缓存怎么用?
124:微服务 springCood 怎么用？
125：优化？数据库优化？
数据库优化
1.考虑使用视图View
第一次多张表连接查询之后将查询结果当作视图对象创建,下一次再查询的时候不需要进行表连接查询,直接查询视图.
2.给某些字段添加索引index,什么时候考虑添加索引呢?
1：大数据量
2 很少的DML操作,很少的insert update delete
3 经常出现在where子句中的字段
126：并发开发?
127: Socket 网络编程？
在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。
socket 的典型应用就是 Web 服务器和浏览器：浏览器获取用户输入的URL，向服务器发起请求，服务器分析接收到的URL，将对应的网页内容返回给浏览器，浏览器再经过解析和渲染，就将文字、图片、视频等元素呈现给用户。
128:系统重构？
129：java 中判断空? !=null 或isEmpty()。
130：变量分类？都存在哪个区？
1.以数据类型为依据划分
1：8种基本数据类型 byte,short,int,long,float,doule,boolean,char.
2：3种引用类型 (类class+接口interface+数组array)
2 以声明的位置为依据划分
2.1 -实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false,引用类型变量的默认值是null
2.1.1 实例变量 保存在堆区
作用域与对应实例的生存范围相同
访问修饰符可以修饰实例变量。
2.1.2 类变量 保存于方法区
作用域与这个类的生存范围相同。
静态变量可以通过：className.VariableName 的方式访问。
2.2 局部变量 —— 方法、构造方法或语句块里定义的变量 (保存在栈区)
-访问修饰符不能用于局部变量 -局部变量是在栈上分配的
-局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用
131 mysql 优化？
http://www.cnblogs.com/ggjucheng/archive/2012/11/07/2758058.html
132 : 引用传递与值传递区别？
值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。
引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。
而在JAVA中只有值传递，基本类型传递的是值的副本，引用类型传递（不是上面说的引用传递）的是引用的副本
引用传递例子：
public class TestValue {
public static void main(String[] args) {
Student a = new Student(0);
Student b = new Student(100);
System.out.print("交换前：");
System.out.println("a的分数：" + a.getScore() + "--- b的分数：" + b.getScore());
swap(a, b);
System.out.print("交换后：");
System.out.println("a的分数：" + a.getScore() + "--- b的分数：" + b.getScore());
}
public static void swap(Student x, Student y) {
Student temp = x;
x = y;
y = temp;
System.out.println("swap 中 的 x ：" + x + "--- y：" + y);
}
}
public class Student {
private float score;
public Student(float score) {
this.score = score;
}
public void setScore(float score) {
this.score = score;
}
public float getScore() {
return score;
}
}
结果：
交换前：a的分数：0.0--- b的分数：100.0
swap 中 的 x ：com.bjpowernode.test.Student@1540e19d--- y：com.bjpowernode.test.Student@677327b6
交换后：a的分数：0.0--- b的分数：100.0
-------------------------------------------------------------------------------------------------------------------------------
值传递例子：
public class TestValue {
public static void main(String[] args) {
int i = 3;
int j = 4;
change(i,j);
System.out.println("main i:"+i+",j:"+j);
}
public static void change(int i,int j){
int temp = i;
i = j;
j = temp;
System.out.println("change i:"+i+",j:"+j);
}
}
结果：
change i:4,j:3
main i:3,j:4
133: 多线程之间的通信机制?
多线程间的通信一般采取等待/通知机制进行实现,Java中在使用synchronized关键字实现的同步方法或同步代码块中，由被上锁的对象调用其自身的wait()方法和notify()方法以及notifyAll()方法，进行实现等待/通知机制.
注意以下事项：
一、wait()方法和notify()方法以及notifyAll()方法的使用必须在同步方法或者同步代码块中，因为这三个方法需要获得监视器对象的对象级别的锁；
二：wait()方法的调用有两个作用：1、使当前线程由运行状态变为等待状态；2、释放当前线程持有的锁；
三、notify()方法调用只有一个作用：唤醒因为wait()或await()而处于等待状态的线程；
134:ibatis mybatis 区别?
135：java 基本数据的长度？
|
字节 |
数据位 |
取值范围 |
|
|
byte |
1 |
8 |
-128~127 |
|
short |
2 |
16 |
-32768 ~32767 |
|
int |
4 |
32 |
-2147 483 648~2147 483 647 |
|
long |
8 |
64 |
|
|
folat |
4 |
32 |
|
|
doule |
8 |
64 |
|
|
boolean |
1 |
8 |
|
|
char |
2 |
16 |
136：jsp内置对象，范围?
1、HttpServletRequest的 request对象 作用：代表请求对象，用来接收客户端通过http协议连接传输到服务器端的数据。
2、HttpServletResponse的response对象 作用：代表响应对象，用来向客户端发送数据。
3、JspWriter的 out 对象 作用：主要用于向客户端发送数据。其中JspWriter是out的基类。
4、HttpSession 的session 对象 作用：主要用于来分别保存每个用户的个人信息，与请求关联的对话。会话状态的维持是每个web应用开发者都必须面对的问题。
5、ServletContext的application对象 作用：主要用于保存用户信息，代码片断的运行环境。它是一个共享的内置对象。即一个容器中多个用户共享一个application对象，故其保存的信息被所有的用户所共享。
6、PageContext的PageContext对象 作用：管理网页的属性，为jsp页面包装页面的上下文，管理对属于jsp中特殊可见部分中已经命名对象的访问。它的创建和初始化的工作都是由容器来自动完成的。
7、ServletConfig的Config对象 作用：代码片断配置对象，表示对servlet的配置。
8、Object 的page（相当于this） 对象 作用：处理jsp网页，是object类的一个实例。即它也是jsp的本身，只有在jsp的页面范围之内它才是合法的。
9、Exception 作用：处理jsp页面执行时，发生的错误和异常
在JSP中提供了四种属性保存范围
page：在一个页面内保存属性，跳转之后无效
request：在一次服务请求范围内，服务器跳转后依然有效
session：-在一次会话范围内，无论何种跳转都可以使用，但是新开浏览器无法使用
application：在整个服务器上保存，所有用户都可以使用
137 ：java 单例：
public class Singleton {
private static final Singleton singleton = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return singleton;
}
}
public class Singleton {
private static Singleton singleton = null;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
若对并发操作不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性(脏读，不可重复读，幻读等)，可能产生死锁。
锁包括行级锁、表级锁、悲观锁、乐观锁
139：异常
140 线程池原理
https://blog.csdn.net/weixin_28760063/article/details/81266152
141 复合索引
142 HashMap的底层，数据结构
143 HashMap与CurrentHashMap区别
144 数据库 oracle 设计三范式
145 GC Java虚拟机中进行垃圾回收的场所有两个，一个是堆，一个是方法区。
146： Arraylist 的排序？Collections.sort(al);//针对一个ArrayList内部的数据排序。
147 内存泄漏与溢出的区别 ?何时产生内存泄漏，JVM原理？
1. 内存泄漏是指分配出去的内存无法回收了。
2. 内存溢出是指程序要求的内存，超出了系统所能分配的范围，从而发生溢出。比如用byte类型的变量存储10000这个数据，就属于内存溢出。
3. 内存溢出是提供的内存不够；内存泄漏是无法再提供内存资源。
-----------------------------------------------------
引起内存溢出的原因有很多种,常见的有以下几种：
1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；
2.集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；
3.代码中存在死循环或循环产生过多重复的对象实体；
4.使用的第三方软件中的BUG；
5.启动参数内存值设定的过小
148 Hashmap的几个方法 ?排序？
Set<String> keySet = map.keySet();
System.out.println("keySet:"+keySet);// keySet:[李四, 张三, 王五]
System.out.println("------------------------");
Collection<String> values = map.values();
System.out.println("values:"+values); //values:[俄罗斯, 美国, 中国]
System.out.println("------------------------");
String zs = map.get("张三");
System.out.println("zs:"+zs); //zs:美国
System.out.println("------------------------");
Set<Map.Entry<String, String>> entries = map.entrySet();
System.out.println("entries:"+entries); //entries:[李四=俄罗斯, 张三=美国, 王五=中国]
排序：获取key,或value后，放到ArrayList中，用Collections.sort(al)；
149 tomcat 最多支持并发多少用户？
Tomcat 默认配置的最大请求数是 150，也可以将其改大。当某个应用拥有 250 个以上并发的时候，应考虑应用服务器的集群。具体能承载多少并发，需要看硬件的配置，CPU 越多性能越高，分配给 JVM 的内存越多性能也就越高，但也会加重 GC 的负担。Tomcat的最大并发数是可以配置的，
150 map原理，它是如何快速查找key的？
Set<String> keySet = map.keySet(); keySet 再循环，得到key.
151 array与arraylist的区别？
1、存储内容比较：
Array 数组可以包含基本类型和对象类型，
ArrayList 却只能包含对象类型。
Array 数组在存放的时候一定是同种类型的元素。ArrayList 就不一定了 。
2、空间大小比较：
Array 数组的空间大小是固定的,所以需要事前确定合适的空间大小。
ArrayList 的空间是动态增长的,而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。
3.方法上的比较：
ArrayList 方法上比 Array 更多样化，比如添加全部 addAll()、删除全部 removeAll()、返回迭代器 iterator() 等
152 在1亿条用户记录里，如何快速查询统计出看了5个电影以上的用户?
1，对userId建立所以索引。
2.使用jdbc的批处理方式
153 mysql支持事务吗？DB存储引擎有哪些？
MYSQL的事务处理主要有两种方法
1.用begin,rollback,commit来实现
begin开始一个事务
rollback事务回滚
commit 事务确认
2.直接用set来改变mysql的自动提交模式
mysql默认是自动提交的，也就是你提交一个query，就直接执行！可以通过
set autocommit = 0 禁止自动提交
set autocommit = 1 开启自动提交
来实现事务的处理
154 用java怎么实现有每天有1亿条记录的DB存储？mysql上亿记录数据量的数据库如何设计?
采用分区的方式创建表，并存储，分区后，索引文件也是分区的，每个区有自己独立的索引文件。
155 循环中删除元素。
用ArrayList 的 迭代器 iterator();
Iterator<String> iter = list.iterator();循环
while (iterator.hasNext()) {
iterator.next();再判断，
用 iter 的remove()方法删除。}
---------------------------------------
注意：
不能用fori循环，fori 结果值不对，for(String s:list){} ,结果是 java.util.ConcurrentModificationException
--------------------------------------------------------------------------
156 Thread 类中的start() 和 run() 方法有什么区别？
这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部 调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启 动，start()方法才会启动新线程。
157 Java中的volatile 变量是什么？
volatile是一个特殊的修饰符，只有成员变量才能使用它。在Java并发程序缺少同步类的情况下，多线程对成员变量的操作对其它线程是透明的。volatile变量可以保证下一个读取操作会在前一个写操作之后发生。
----------------------------------------------------
158 Java中如何停止一个线程？
Java提供了很丰富的API但没有为停止线程提供API。JDK 1.0本来有一些像stop(), suspend() 和 resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中他们被弃用了，之后Java API的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当run() 或者 call() 方法执行完的时候线程会自动结束,如果要手动结束一个线程，你可以用volatile 布尔变量来退出run()方法的循环或者是取消任务来中断线程。
159 如何在两个线程间共享数据？
你可以通过共享对象来实现这个目的，或者是使用像阻塞队列这样并发的数据结构。这篇教程《Java线程间通信》(涉及到在两个线程间共享对象)用wait和notify方法实现了生产者消费者模型。
---------------------------------------------------------------------------------------------
160 多线程问题？
什么是线程安全? 如果你的代码在多线程下执行和在单线程下执行永远都能获得一样的结果，那么你的代码就是线程安全的.
有三个线程T1，T2，T3，怎么确保它们按顺序执行？
在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3最后完成。
Thread类中的yield方法有什么作用？
Yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行。
volatile 变量和 atomic 变量有什么不同？
使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到volatile变量，一定是最新的数据。
这是个有趣的问题。首先，volatile 变量和 atomic 变量看起来很像，但功能却不一样。Volatile变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用volatile修饰count变量那么 count++ 操作就不是原子性的。而AtomicInteger类提供的atomic方法可以让这种操作具有原子性如getAndIncrement()方法会原子性 的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。
如果同步块内的线程抛出异常会发生什么？
这个问题坑了很多Java程序员，若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的，里面的线程都会释放锁，所以对比锁接口我更喜欢同步块，因为它不用我花费精力去释放锁，该功能可以在finally block里释放锁实现
Java中的同步集合与并发集合有什么区别？
同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合，不过并发集合的可扩展性更高。在Java1.5之前程序员们只有同步集合来用且在 多线程并发的时候会导致争用，阻碍了系统的扩展性。Java5介绍了并发集合像ConcurrentHashMap，不仅提供线程安全还用锁分离和内部分 区等现代技术提高了可扩展性。
Java中堆和栈有什么不同？
为什么把这个问题归类在多线程和并发面试题里？因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈 调用，一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己 的栈，如果多个线程使用该变量就可能引发问题，这时volatile 变量就可以发挥作用了，它要求线程从主存中读取变量的值。
什么是线程池？ 为什么要使用它？
创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。为了避免这些问题，在程序启动的时 候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程。从JDK1.5开始，Java API提供了Executor框架让你可以创建不同的线程池。比如单线程池，每次处理一个任务；数目固定的线程池或者是缓存线程池（一个适合很多生存期短 的任务的程序的可扩展线程池）。
多线程有什么用？
1）发挥多核CPU的优势
2）防止阻塞
3）便于建模
Java 中volatile关键字是什么？你如何使用它？它和 Java 中的同步方法有什么区别？
自从 Java 5 中调整 volatile 关键字和 Java 内存模型后，有关 volatile 关键字的线程问题越来越常见。掌握 volatile变量在并发环境中如何确保可见性、有序性和一致性非常重要。
你在多线程环境中遇到的最多的问题是什么？你如何解决的？
内存干扰、竞态条件、死锁、活锁、线程饥饿是多线程和并发编程中比较有代表性的问题。这类问题无休无止，而且难于定位和调试。
线程和进程有什么区别？
线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。
Java 中线程调度是什么？
ThreadLoal的作用是什么?
简单说ThreadLocal就是一种以空间换时间的做法在每个Thread里面维护了一个ThreadLocal.
ThreadLocalMap把数据进行隔离，数据不共享，自然就没有线程安全方面的问题了
你有哪些多线程开发良好的实践?
给线程命名
最小化同步范围
优先使用volatile
尽可能使用更高层次的并发工具而非wait和notify()来实现线程通信,如BlockingQueue,Semeaphore
优先使用并发容器而非同步容器.
考虑使用线程池
可以创建Volatile数组吗?
Java 中可以创建 volatile类型数组，不过只是一个指向数组的引用，而不是整个数组。如果改变引用指向的数组，将会受到volatile 的保护，但是如果多个线程同时改变数组的元素，volatile标示符就不能起到之前的保护作用了
线程怎样拿到返回结果?
怎么终止一个线程？如何优雅地终止线程？
多线程同步有哪几种方法？五种。
同步方法
即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
同步代码块
即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
使用特殊域变量(volatile)实现线程同步
（1）volatile关键字为域变量的访问提供了一种免锁机制；
（2）使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新；
（3）因此每次使用该域就要重新计算，而不是使用寄存器中的值；
（4）volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。
volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不使用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是从缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。
使用重入锁实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和块具有相同的基本行为和语义，并且扩展了其能力。
如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁。
使用局部变量实现线程同步 ThreadLocal 修饰。
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，只是名字相同而已。所以就会发生上面的效果
-----------------------------------
多线程之间如何进行通信？
常用的几种线程池并讲讲其中的工作原理?
线程池启动线程submit()和execute()方法有什么不同？
什么是守护线程？有什么用？
怎么中断一个线程？如何保证中断业务不影响？
一个线程运行时发生异常会怎样？
Synchronized有哪几种用法？
线程数过多会造成什么异常？
说说线程安全的和不安全的集合。
怎么检测一个线程是否拥有锁？
线程同步需要注意什么？
线程之间如何传递数据？
多线程上下文切换是什么意思？
同步方法和同步块，哪种更好？
如何在Java中获取线程堆栈？
如何创建线程安全的单例模式？
提交任务时线程池队列已满会时发会生什么？
如何解决线程安全问题？
-尽量使用局部变量
-如果使用了实例变量，让对象变成多例
-如果使用了实例变量，加synchronized关键字进行修饰
---------------------------------------------------------------
161 排序 二分法？冒泡排序？
162 隔离级别的理解？
163 tomcat 的线程池设置位置
164 表被锁后，怎么处理？
165 事物的transation注解什么时候用
166 count(*)与count(id)区别？
Count（*）表示取得所有记录，忽略null，为null值也会取得。
采用count(字段名称)，不会取得为null的纪录。
注意：在mysql和oracle中都适用
167 非法登录
168 权限 角色 用户
169 spring mvc 的 注解
170 负载均衡
171 Mybatis 的标签
172 windows 远程桌面默认端口。
173 tomcat 开机自启动 Windows中。
174Linux 中的定时任务在哪设置
175 maven 命令
176 extjs