面试基础内容第一篇

时间 2019-11-09

原文原文链接

1.java 集合实现了什么接口？java

Java API针对集合类型排序提供了两种支持：
java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)

第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。
第二个方法要求实现一个java.util.Comparator接口。

java.lang.Comparable接口和java.util.Comparator接口是Java对排序最提供最基本支持。这两个接口不但能够用于集合元素排序，还能够用于数组排序。

若是数组或集合元素是String类型，则能够利用Java API实现的Comparator<String>对象String.CASE_INSENSITIVE_ORDER为容器元素排序。mysql

方法一：实现Comparable接口排序package collsort.comparable;
package com.cvicse.sort.comparable;

public class Cat implements Comparable<Cat> {
private int age;
private String name;

public Cat(int age, String name) {
this.age = age;
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
......
public int compareTo(Cat o) {
return this.getAge() - o.getAge();
}
......
}jquery

public class TestComparable {
public static void main(String args[]) {
test();
test2();
}
public static void test() {
......
List<Cat> listCat1 = new ArrayList<Cat>();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leizhimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat1.add(cat1);
listCat1.add(cat2);
listCat1.add(cat3);
......
System.out.println("调用Collections.sort(List<T> list)listCat2升序排序：");
Collections.sort(listCat1);
System.out.println("降序排列元素:");
Collections.sort(listCat1, Collections.reverseOrder());
System.out.println("Collections.reverse 从列表中最后一个元素开始输出:");
Collections.reverse(listCat1);
......
}
/**
* 针对数组的排序
*/
public static void test2() {
String[] strArray = new String[] { "z", "a", "C" };
System.out.println("数组转换为列表");
List<String> list = Arrays.asList(strArray);
System.out.println("顺序排序列表");
Collections.sort(list);
System.out
.println("按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println("倒序排序列表");
Collections.sort(list, Collections.reverseOrder());
......
}
}
方法二：实现Comparator接口排序
public class Person {
private int age;
private String name;
......
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
}
实现了Comparator接口，重写了compare方法
import java.util.Comparator;
public class PersonComparator implements Comparator<Person> {angularjs

public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
}
测试方法
public class TestComparator {
public static void main(String args[]) {
test1();
}
public static void test1() {
System.out.println("升序排序测试:");
List<Person> listPerson = new ArrayList<Person>();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leizhimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator<Person> ascComparator = new PersonComparator();
System.out.println("排序后集合为:");
// 利用Collections类静态工具方法对集合List进行排序
Collections.sort(listPerson, ascComparator);
System.out.println("\n降序排序测试:");
// 从升序排序对象产生一个反转(降序)的排序对象
Comparator<Person> descComparator = Collections
.reverseOrder(ascComparator);
System.out.println("利用反转后的排序接口对象对集合List排序并输出:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
}
}web

2.struts1或struts2的工做原理算法

struts1：spring

一、初始化：struts框架的总控制器ActionServlet是一个Servlet，它在web、xml中配置成自动启动的Servlet，在启动时总控制器会读取配置文件（struts-config、xml）的配置信息，为struts中不一样的模块初始化相应的对象。sql

二、发送请求：用户提交表单或经过URL向WEB服务器提交请求，请求的数据用HTTP协议传给web服务器。shell

三、form填充：struts的总控制器ActionServlet在用户提交请求时将数据放到对应的form对象中的成员变量中。编程

四、派发请求：控制器根据配置信息对象ActionConfig将请求派发到具体的Action，对应的formBean一并传给这个Action中的excute()方法。

五、处理业务：Action通常只包含一个excute()方法，它负责执行相应的业务逻辑（调用其它的业务模块）完毕后返回一个ActionForward对象。服务器经过ActionForward对象进行转发工做。

六、返回响应：Action将业务处理的不一样结果返回一个目标响应对象给总控制器。

七、查找响应：总控制器根据Action处理业务返回的目标响应对象，找到对应的资源对象，通常状况下为jsp页面。

八、响应用户：目标响应对象将结果传递给资源对象，将结果展示给用户。

struts2 ：

一、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；

二、这个请求通过一系列的过滤器（Filter）（这些过滤器中有一个叫作ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其余框架的集成颇有帮助，例如：SiteMesh、Plugin）；

三、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否须要调用某个Action；

四、若是ActionMapper决定须要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；

五、ActionProxy经过Configuration Manager询问框架的配置文件，找到须要调用的Action类；

六、ActionProxy建立一个ActionInvocation的实例。

七、ActionInvocation实例使用命名模式来调用，在调用Action的过程先后，涉及到相关拦截器（Intercepter）的调用。

八、一旦Action执行完毕，ActionInvocation负责根据struts、xml中的配置找到对应的返回结果。返回结果一般是（但不老是，也多是另外的一个Action链）一个须要被表示的JSP或者FreeMarker的模版。在表示的过程当中可使用Struts2框架中继承的标签。在这个过程当中须要涉及到ActionMapper。

3.struts1和struts2的核心工做原理

Action 类:
• Struts1要求Action类继承一个抽象基类。Struts1的一个广泛问题是使用抽象类编程而不是接口，而struts2的Action是接口。
• Struts 2 Action类能够实现一个Action接口，也可实现其余接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现经常使用的接口。Action接口不是必须的，任何有execute标识的POJO对象均可以用做Struts2的Action对象。

线程模式:
• Struts1 Action是单例模式而且必须是线程安全的，由于仅有Action的一个实例来处理全部的请求。单例策略限制了Struts1 Action能做的事，而且要在开发时特别当心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每个请求产生一个实例，所以没有线程安全问题。（实际上，servlet容器给每一个请求产生许多可丢弃的对象，而且不会致使性能和垃圾回收问题）

Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,由于当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，容许Action脱离容器单独被测试。若是须要，Struts2 Action仍然能够访问初始的request和response。可是，其余的元素减小或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action能够经过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
• Struts1 使用ActionForm对象捕获输入。全部的ActionForm必须继承一个基类。由于其余JavaBean不能用做ActionForm，开发者常常建立多余的类捕获输入。动态Bean（DynaBeans）能够做为建立传统ActionForm的选择，可是，开发者多是在从新描述(建立)已经存在的JavaBean（仍然会致使有冗余的javabean）。
• Struts 2直接使用Action属性做为输入属性，消除了对第二个输入对象的需求。输入属性多是有本身(子)属性的rich对象类型。Action属性可以经过 web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，可以用做输入/输出对象。这种 ModelDriven 特性简化了taglib对POJO输入对象的引用。

表达式语言：
• Struts1 整合了JSTL，所以使用JSTL EL。这种EL有基本对象图遍历，可是对集合和索引属性的支持很弱。
• Struts2可使用JSTL，可是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).

绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib可以访问值而不须要把你的页面（view）和对象绑定起来。ValueStack策略容许经过一系列名称相同但类型不一样的属性重用页面（view）。

类型转换：
• Struts 1 ActionForm 属性一般都是String类型。Struts1使用Commons-Beanutils进行类型转换。每一个类一个转换器，对每个实例来讲是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和经常使用对象的转换器。

校验：
• Struts 1支持在ActionForm的validate方法中手动校验，或者经过Commons Validator的扩展来校验。同一个类能够有不一样的校验内容，但不能校验子对象。
• Struts2支持经过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性

Action执行的控制：
• Struts1支持每个模块有单独的Request Processors（生命周期），可是模块中的全部Action必须共享相同的生命周期。
• Struts2支持经过拦截器堆栈（Interceptor Stacks）为每个Action建立不一样的生命周期。堆栈可以根据须要和不一样的Action一块儿使用。

4.struts框架的核心内容

Action是整个Struts框架的核心内容。无论是struts1仍是struts2.

5.angularjs的工做原理

angularjs的原理核心是双向数据绑定。AngularJS的工做原理是:HTML模板将会被浏览器解析到DOM中, DOM结构成为AngularJS编译器的输入。AngularJS将会遍历DOM模板, 来生成相应的NG指令,全部的指令都负责针对view(即HTML中的ng-model)来设置数据绑定。

6.快速排序的要求

快速排序采用的思想是分治思想。

快速排序是找出一个元素（理论上能够随便找一个）做为基准(pivot),而后对数组进行分区操做,使基准左边元素的值都不大于基准值,基准右边的元素值都不小于基准值，如此做为基准的元素调整到排序后的正确位置。递归快速排序，将其余n-1个元素也调整到排序后的正确位置。最后每一个元素都是在排序后的正确位置，排序完成。因此快速排序算法的核心算法是分区操做，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

7.jsp原生标签

jsp：attribute / jsp:body /jsp:element / jsp:fallback / jsp:forward / jsp:getProperty / jsp:include / jsp:output /jsp:param / jsp:params/

jsp:plugin / jsp:setProperty / jsp:useBean

8.web.xml在项目中的做用和web.xml有哪些标签

每一个javaEE工程中都有web.xml文件，那么它的做用是什么呢？它是每一个web.xml工程都必须的吗？

一个web中能够没有web.xml文件，也就是说，web.xml文件并非web工程必须的。

web.xml文件是用来初始化配置信息：好比Welcome页面、servlet、servlet-mapping、filter、listener、启动加载级别等。

当你的web工程没用到这些时，你能够不用web.xml文件来配置你的Application。

每一个xml文件都有定义它书写规则的Schema文件，也就是说javaEE的定义web.xml所对应的xml Schema文件中定义了多少种标签元素，web.xml中就能够出现它所定义的标签元素，也就具有哪些特定的功能。web.xml的模式文件是由Sun 公司定义的，每一个web.xml文件的根元素为<web-app>中，必须标明这个web.xml使用的是哪一个模式文件。如：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
</web-app>

    web.xml的模式文件中定义的标签并非定死的，模式文件也是能够改变的，通常来讲，随着web.mxl模式文件的版本升级，里面定义的功能会愈来愈复杂，标签元素的种类确定也会愈来愈多，但有些不是很经常使用的，咱们只需记住一些经常使用的并知道怎么配置就能够了。

下面列出web.xml咱们经常使用的一些标签元素及其功能：

一、指定欢迎页面，例如：
<welcome-file-list>
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>index1.jsp</welcome-file>
</welcome-file-list>
PS：指定了2个欢迎页面，显示时按顺序从第一个找起，若是第一个存在，就显示第一个，后面的不起做用。若是第一个不存在，就找第二个，以此类推。

关于欢迎页面：

    访问一个网站时，默认看到的第一个页面就叫欢迎页，通常状况下是由首页来充当欢迎页的。通常状况下，咱们会在web.xml中指定欢迎页。但 web.xml并非一个Web的必要文件，没有web.xml，网站仍然是能够正常工做的。只不过网站的功能复杂起来后，web.xml的确有很是大用处，因此，默认建立的动态web工程在WEB-INF文件夹下面都有一个web.xml文件。

二、命名与定制URL。咱们能够为Servlet和JSP文件命名并定制URL,其中定制URL是依赖命名的，命名必须在定制URL前。下面拿serlet来举例：
(1)、为Servlet命名：
<servlet>
    <servlet-name>servlet1</servlet-name>
    <servlet-class>org.whatisjava.TestServlet</servlet-class>
</servlet>

(2)、为Servlet定制URL、
<servlet-mapping>
    <servlet-name>servlet1</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

三、定制初始化参数：能够定制servlet、JSP、Context的初始化参数，而后能够再servlet、JSP、Context中获取这些参数值。

下面用servlet来举例：
<servlet>
    <servlet-name>servlet1</servlet-name>
    <servlet-class>org.whatisjava.TestServlet</servlet-class>
    <init-param>
          <param-name>userName</param-name>
          <param-value>Daniel</param-value>
    </init-param>
    <init-param>
          <param-name>E-mail</param-name>
          <param-value>125485762@qq.com</param-value>
    </init-param>
</servlet>
通过上面的配置，在servlet中可以调用getServletConfig().getInitParameter("param1")得到参数名对应的值。

四、指定错误处理页面，能够经过“异常类型”或“错误码”来指定错误处理页面。
<error-page>
    <error-code>404</error-code>
    <location>/error404.jsp</location>
</error-page>
-----------------------------
<error-page>
    <exception-type>java.lang.Exception<exception-type>
    <location>/exception.jsp<location>
</error-page>

五、设置过滤器：好比设置一个编码过滤器，过滤全部资源
<filter>
    <filter-name>XXXCharaSetFilter</filter-name>
    <filter-class>net.test.CharSetFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>XXXCharaSetFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

　　六、设置监听器：
　　<listener>
　　<listener-class>net.test.XXXLisenet</listener-class>
　　</listener>

　　七、设置会话(Session)过时时间，其中时间以分钟为单位，假如设置60分钟超时：
　　<session-config>
　　<session-timeout>60</session-timeout>
　　</session-config>

　　除了这些标签元素以外，还能够往web.xml中添加不少标签元素，因为不经常使用省略。

9.hashMap和hashTable的区别

　　1.可见Hashtable 继承自 Dictiionary 而 HashMap继承自AbstractMap

　　2.HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap容许空（null）键值（key）,因为非线程安全，效率上可能高于Hashtable。

　　3.Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不须要本身为它的方法实现同步，而HashMap 就必须为之提供外同步(Collections.synchronizedMap)。

10.collection集合

List --> AbstractList,ArrayList,LinkedList,Stack,Vector

Map --> HashMap ,Hashtable, Properties, LinkedHashMap, IdentityHashMap, TreeMap, WeakHashMap, ConcurrentHashMap

Set --> HashSet ，TreeSet

11.Set如何遍历

package com.shellway.javase;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import org.junit.Test;

public class TestCollection {

public static void print(Collection<? extends Object> c){

Iterator<? extends Object> it = c.iterator();

while (it.hasNext()) {

Object object = (Object) it.next();

System.out.println(object);

}

@Test

public void demo1(){

Set<String> set = new HashSet<String>();

set.add("AAA");

set.add("BBB");

set.add("CCC");

print(set);

//Set的第一种遍历方式:利用Iterator

Iterator<String> it1 = set.iterator();

for (String ss : set) {

System.out.println(ss);

}

//Set的第一种遍历方式:利用foreach

for (String sss : set) {

System.out.println(sss);

}

List<String> list = new ArrayList<String>();

list.add("DDDDD");

list.add("EEEEE");

list.add("FFFFF");

print(list);

//List的第一种遍历方式:由于list有顺序，利用size()和get()方法获取

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

//List的第二种遍历方式：利用Iterator

Iterator<String> it = list.iterator();

while (it.hasNext()) {

System.out.println(it.next());

}

//List的第三种遍历方式:利用foreach

for (String s2 : list) {

System.out.println(s2);

}

Map<String,String> map = new TreeMap<String, String>();

map.put("Jerry", "10000");

map.put("shellway", "20000");

map.put("Kizi", "30000");

print(map.entrySet());

//Map的第一种遍历方式：先得到key,再得到值value

Set<String> sett = map.keySet();

for (String s : sett) {

System.out.println(s+":"+map.get(s));

}

//Map的第二种遍历方式：得到键值对

for (Map.Entry<String, String> entry : map.entrySet()) {

System.out.println(entry.getKey()+" : "+entry.getValue());

}

12.String 和StringBuffer的区别

（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性从新建立了一个新的对象，释放原String对象，StringBuffer类对象为可修改对象，能够经过append()方法来修改值

（2）String类对象的性能远不如StringBuffer类。

13.线程的启动方法

启动线程确定要用start()方法。当用start()开始一个线程后，线程就进入就绪状态，使线程所表明的虚拟处理机处于可运行状态，这意味着它能够由JVM调度并执行。这并不意味着线程就会当即运行。当cpu分配给它时间时，才开始执行run()方法(若是有的话)。START()是方法,它调用RUN()方法.而RUN()方法是你必须重写的. run()方法中包含的是线程的主体。

继承Thread类的启动方式：

public class ThreadStartTest {

public static void main(String[] args) {

ThreadTest tt = new ThreadTest();// 建立一个线程实例

tt.start(); // 启动线程

}

实现Runnable接口的启动方式：

public class RunnableStartTest {

public static void main(String[] args) {

Thread t = new Thread(new RunnableTest()); // 建立一个线程实例

t.start(); // 启动线程

}

实际上这两种启动线程的方式原理是同样的。首先都是调用本地方法启动一个线程，其次是在这个线程里执行目标对象的run()方法。那么这个目标对象是什么呢？为了弄明白这个问题，咱们来看看Thread类的run()方法的实现：

public void run() {

if (target != null) {

target.run();

}

当咱们采用实现Runnable接口的方式来实现线程的状况下，在调用new Thread(Runnable target)构造器时，将实现Runnable接口的类的实例设置成了线程要执行的主体所属的目标对象target，当线程启动时，这个实例的 run()方法就被执行了。当咱们采用继承Thread的方式实现线程时，线程的这个run()方法被重写了，因此当线程启动时，执行的是这个对象自身的 run()方法。总结起来就一句话，若是咱们采用的是继承Thread类的方式，那么这个target就是线程对象自身，若是咱们采用的是实现Runnable接口的方式，那么这个target就是实现了Runnable接口的类的实例。

而若是直接用Run方法，这只是调用一个方法而已，程序中依然只有主线程--这一个线程，其程序执行路径仍是只有一条，这样就没有达到写线程的目的。

14.讲讲mybatis

SqlSessionFactory是每一个MyBatis应用的核心

SqlSessionFactoryBuilder　是用过即丢，其生命周期只存在于方法体内

SqlSessionFactory　单例，存在于整合应用运行时

15.springmvc和mybatis整合，须要配置些什么

</bean>

<list>

<value>classpath:com/hoo/resultmap/**/*-resultmap.xml</value>

<value>classpath:com/hoo/entity/*-resultmap.xml</value>

<value>classpath:com/hoo/mapper/**/*-mapper.xml</value>

</list>

</property>

</bean>

上面的配置最早配置的是DataSource，这里采用的是jdbc的DataSource；

而后是SqlSessionFactoryBean，这个配置比较关键。SqlSessionFactoryBean须要注入DataSource数据源，其次还要设置configLocation也就是mybatis的xml配置文件路径，完成一些关于mybatis的配置，如settings、mappers、plugin等；

16.jquery的选择器有哪些

不少种，大概概括为9种。
(1)基本
#id
element
.class
*
selector1,selector2,selectorN

(2)层次选择器：
ancestor descendant
parent > child
prev + next
prev ~ siblings

(3)基本过滤器选择器
:first
:last
:not
:even
:odd
:eq
:gt
:lt
:header
:animated

(4)内容过滤器选择器
:contains
:empty
:has
:parent

(5)可见性过滤器选择器
:hidden
:visible

(6)属性过滤器选择器
[attribute]
[attribute=value]
[attribute!=value]
[attribute^=value]
[attribute$=value]
[attribute*=value]
[attrSel1][attrSel2][attrSelN]

(7)子元素过滤器选择器
:nth-child
:first-child
:last-child
:only-child

(8)表单选择器
:input
:text
:password
:radio
:checkbox
:submit
:image
:reset
:button
:file
:hidden

(9)表单过滤器选择器
:enabled
:disabled
:checked
:selected

17.java传值与传引用　　一、对象是按引用传递的　　二、Java 应用程序有且仅有的一种参数传递机制，即按值传递　　三、按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本　　四、按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本

面试 基础内容第一篇

面试基础内容第一篇