面试准备

最新推荐文章于 2023-03-18 17:40:17 发布

BIBOBALA

最新推荐文章于 2023-03-18 17:40:17 发布

阅读量634

点赞数 2

本文链接：https://blog.csdn.net/yimzncy/article/details/49745361

版权

1，jvm工作原理？

java虚拟机，java编译器将.java文件编译成.class文件，也就是字节码文件，java解释器将字节码解释成机器码运行。

jvm主要包括：类加载器classloader（类运行时将.class文件加载到jvm）、运行时数据区（内存区）、执行引擎（执行.class文件中的指令）、。。。

内存区包括：方法区（存储类的结构信息：常量、静态变量、构造函数等）、java堆（存放java实例/对象，gc只发生在这里）、java栈（每创建一个线程，jvm创建一个java栈，一个java栈中有多个栈帧，没运行一个方法创建一个栈帧，用于存储局部变量、操作栈、返回值等，每一个方法从调用到完成就对应一个栈帧的入栈到出栈的过程）、程序计数器（保存程序当前指令的地址）、本地方法栈（类似java栈，为jvm的native方法服务）

方法区和java堆为所有线程共享，java栈和程序计数器为线程私有。

java垃圾回收？

JVM在空闲时不定时回收无任何引用的对象的内存空间。

System.gc()　显式请求JVM进行一次垃圾回收，但不是立即发生。

finalize()方法在垃圾回收之前被调用。用于回收非java资源。

2，反射？

反射是指运行时能查看查看类的状态及特征，并能进行动态管理的功能。

Class cls = Class.forName("packageName.className");
Object obj = cls.newInstance();
Method m = cls.getDeclaredMethod("methodName", new Class[]{}); //第二个参数是被调方法的参数类型们
m.invoke(obj, new Object[]{});  //第二个参数是被调方法的参数们

3，值传递和引用传递？

值传递传递的是值的拷贝，引用传递传递的是地址。

ps: ==比较的是引用，equals比较的是值。

多态、重载、重写？

多态指同一请求根据对象的不同采取不同行为。

重载指一个类中名字相同、参数不同的方法。

重写指子类重新实现父类的方法。

4，final, finally, finalize?

final类无法继承，final方法无法重写，final变量初始化后无法修改。

finally异常处理中无论是否捕获异常都执行。

finalize()方法在对象销毁被调用来垃圾回收。

5，String, StringBuffer, StringBuilder?

String是不可变对象，每次操作都创建一个新的String对象。为什么不可变？因此String被声明为一个final类。

后两者是对类对象操作，速度快。StringBuffer线程安全，故比StringBuilder慢。

6，ArrayList, Vector, LinkedList?

ArrayList和Vector都是数组方式存储数据，因此查找快，插入慢，两者区别是Vector线程安全，性能相对差些。ArrayList数组满后增加50%容量，Vector增加100%，因此前者节省空间。

LinkedList使用双链表实现，查找满，插入快。

Set：不允许重复元素。无序

7，HashMap, HashTable, LinkedHashMap, TreeMap, IdentityHashMap?

HashMap允许key为null，HashTable不允许，HashTable线程安全。

IdentityHashMap的key可以重复。

LinkedHashMap保留了键值对的插入顺序。

TreeMap实现了SortedMap接口，默认按key升序排列。

ConcurrentHashMap如何实现线程安全？

它把hash表分成很短Segment，每个segment有自己的锁。只要多个操作发生在不同的段上，就可以并发进行。

支持完全并发的读，和部分并发的写。

HashMap实现原理？　　http://beyond99.blog.51cto.com/1469451/429789/

HashMap是一个链表散列结构，即数组和链表的结合体。

底层是一个Entry<K,V>数组，数组每一项又是一个链表，每个Entry持有一个指向下一个元素的引用。

根据key算出的hashcode找到数组下标位置，同一位置上的多个entry以链表形式存储。

hashmap又一个capacity概念，默认初始容量是1<<4=16，key的数量到达极限时，会自动调用resize()方法夸大容量。

8，Iterator, Enumeration?

Iterator是Enumeration的替代者，后者速度更快，但线程不安全。

Iterator允许从集合中移除元素，Enumeration不允许。

9，抽象类和接口的区别？

抽象类不可以创建对象，里面可以有非抽象方法，里面的抽象方法必须被子类实现。

接口中的方法默认为public abstract的，接口中的变量默认是public static final的。

10，进程和线程的关系？

进程时程序执行的一个实例，每个进程都有独立的内存空间和系统资源。

一个进程可以包含多个线程，一个线程是进程的一个顺序执行流。

线程、多线程相关？

start()/run()：start启动一个新线程；run只是当做普通方法调用，依然只有一个主线程。

ThreadLocal：线程级别的局部变量。必须初始化，否则为null。

private static ThreadLocal<Integer> numberContainer = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {

<span style="white-space:pre">	</span>return 0;

<span style="font-family: Arial, Helvetica, sans-serif;"><span style="white-space:pre">	</span>}</span>

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">};</span>

sleep()/wait()：sleep是Thread类的方法，是个静态方法，所以只对当前线程有效；wait是Object类的方法，需先获得对象的同步锁，也使当前线程可不运行。wait会释放对象的锁，线程挂起，直到被notify()才进入runnac=

同步静态方法，线程会获取该类的Class对象的锁。

死锁：多个线程无限阻塞，互相等待所需资源。

线程池？

线程池为了限制系统中线程的数量。

减少了线程创建和销毁的次数，每个线程都可以重复使用。

根据系统承受能力，调整线程池里线程的数目，减轻服务器压力。

ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.execute(new RunnableClass());

线程同步和线程锁？

线程同步是多个线程访问同一个数据对象时防止数据对象被破坏。

同步加锁的时对象，不是代码。

每个java对象都有一个内置锁，当程序运行到synchronized方法或代码块的时候该对象的锁才起作用，叫做在对象上同步。

同步方法可以改写成非同步方法（同步方法力的代码块），功能不变。

静态方法同步需要同步整个类（类的Class对象）。

public static xxx() {

synchronized(Xxx.class) {

...

}

volatile修饰的变量在各个线程中是一致的，对volatile变量的修改会立刻反应到其他线程中。

主要用来修饰基本类型的变量，基本类型是原子操作，不是对象没有锁

不安全例：i++实际是读取-修改-写入的组合操作，多线程下各个线程的读写操作可能重叠，volatile不能保证同步性。

悲观锁和乐观锁？

悲观锁：每次拿数据都上锁，开销大；适用于经常冲突（多写少读）的情形。

乐观锁：每次拿数据都不上锁，但更新时会根据版本号等判断在此期间数据是否变更；适用于多读少写的情形。

java.util.concurrent包？

提供了一系列并发工具

Executor                ：具体Runnable任务的执行者。
ExecutorService          ：一个线程池管理者，其实现类有多种，我会介绍一部分。我们能把Runnable,Callable提交到池中让其调度。
Semaphore                ：一个计数信号量
ReentrantLock          ：一个可重入的互斥锁定 Lock，功能类似synchronized，但要强大的多。
Future                   ：是与Runnable,Callable进行交互的接口，比如一个线程执行结束后取返回的结果等等，还提供了cancel终止线程。
BlockingQueue          ：阻塞队列。
CompletionService       : ExecutorService的扩展，可以获得线程执行结果的
CountDownLatch          ：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
CyclicBarrier          ：一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点
Future                   ：Future 表示异步计算的结果。
ScheduledExecutorService ：一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

11，构造函数，静态代码块执行顺序？

父类静态代码块》子类静态代码块》父类非静态代码块》父类构造函数》子类非静态代码块》子类构造函数

12，b/s, c/s？

browser/server, client/server

13，mvc？

model（模型）：数据模型，包含数据和行为

view（视图）：数据模型的展示

controller（控制器）：接受用户请求，调用model处理，再把结果返回view

耦合度低、重用性高、可维护性高、开发快

14，tcp/ip的三次握手？

OSI体系七层接口，TCP/IP协议五层接口：应用层、运输层、网络层、数据链路层、物理层

TCP：面向连接，数据传输单位是报文段，可靠

UDP：无连接的，数据传输单位是用户数据包，不可靠

建立连接三次握手：

client发送SYN报文，变成SYN-SEND状态；server接收到请求后返回ACK报文

client收到ACK报文后也向server发送ACK报文，变成ESTABLISHED状态；server收到ACK报文后也变成ESTABLISHED状态

断开连接四次握手：

client发送FIN报文，变成FIN-WAIT1状态；server收到FIN报文后返回ACK报文（此时socket连接未断，可继续传数据）

client收到ACK报文后变成FIN-WAIT2状态；server端确认数据传送完毕后向client发送FIN报文

client收到FIN报文后向server发送ACK报文，并进入TIME-WAIT状态；server收到ACK后断开连接

client等待2MSL（数据包单向发送到确认丢失的时间）后没收到回复，证明server已关闭连接，client关闭连接

15，socket理解？

socket是对TCP/IP的封装，是一个调用接口。

简历socket连接需要一对socket，一个clientSocket，一个serverSocket。

三步连接：服务端监听、客户端请求、连接确认。

web使用http包装数据（没有应用层包装数据，数据便无法识别），tcp/ip传输数据。

客户端发送的每次http请求都需要服务端响应，请求结束后，自动释放连接。

HTTP

Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Encoding:gzip,deflate,sdch
Accept-Language:zh-CN,zh;q=0.8,en;q=0.6
Cache-Control:max-age=0
Connection:keep-alive
Cookie:bdshare_firstime=1394693898320; Hm_lvt_2f2ac530df20294f718580cea710780e=1396330354,1396332063,1396332065,1396402453; Hm_lpvt_2f2ac530df20294f718580cea710780e=1396404308
Host:jcodecraeer.com
User-Agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.154 Safari/537.36

GET和POST区别？

GET：从服务端获取数据；通过url提交数据；服务端用Request.QueryString获取数据；提交的数据最多1024字节；地址栏显示提交的参数，不安全

POST：向服务端发送数据；通过header提交数据；服务端用Request.Form获取数据；提交的数据大小无限制；

Session和Cookie? http://www.tuicool.com/articles/N7VZva

Session由服务端维护，记录了一个请求从开始到结束的过程

Cookie保存在客户端，主要用于标识用户

Cookie可以跟踪每个客户端的访问，但每次访问都必须传回这些Cookie，如果Cookie信息很多就增大了C/S间的传输量。Session可以解决这个问题，每次C/S交互时，不需要传Cookie的数据，只需要一个ID，这个ID是客户端第一次请求服务端时产生的，每个客户端唯一。这个ID通常是NAME为JSESSIONID的一个Cookie。

使用session是因为服务器保存了很多数据，访问量大时服务器负担大，因此部分信息保存在Cookie里。

16，servlet生命周期？

servlet不是单例，但web容器只让它实例化一次，所以展现单例效果。servlet配置在web.xml中。*tomcat是web容器也是servlet容器

sevlet是单实例多线程的，init方法只在web容器启动或第一次请求（取决于load-on-startup属性）时调用，只初始化一次。servlet处理请求是调用service方法，servlet容器通过调度线程并发访问同一个servlet时，servlet容器会使用线程池创建多个线程同时调动service方法。

如果给service方法加上synchronized，则请求依次调用service方法。

如果servlet实现SingleThreadModel接口，则servlet容器会根据请求的数量创建多个servlet的实例。

servlet是个特殊的Java类，必须继承HttpServlet，重写doGet()、doPost()等方法。

生命周期：

1、Web Client向Servlet容器(Tomcat)发出Http请求。

2、Servlet容器接收Client端的请求。

3、Servlet容器创建一个HttpRequest对象，将Client的请求信息封装到这个对象中。

4、Servlet创建一个HttpResponse对象。

5、Servlet调用HttpServlet对象的service方法，把HttpRequest对象和HttpResponse对象作为参数传递给HttpServlet对象中。

6、HttpServlet调用HttpRequest对象的方法，获取Http请求，并进行相应处理。

7、处理完成HttpServlet调用HttpResponse对象的方法，返回响应数据。

8、Servlet容器把HttpServlet的响应结果传回客户端。

其中的3个方法说明了Servlet的生命周期：

1、init()：负责初始化Servlet对象。

2、service()：负责响应客户端请求。

3、destroy()：当Servlet对象推出时，负责释放占用资源。

1、初始化（调用init()方法），2、响应客户请求（调用service()方法），3、终止（调用destroy()方法）。

servlet容器（如tomcat）启动后自动加载配置了（<load-on-startip>1</load-on-startup>）的servlet，其他servlet在用户请求时初始化。

17，NoSQL数据库与关系型数据库？

关系型数据库：事务性处理，具备ACID特性（原子性、一致性、隔离性、持久性）

１为了维持一致性，并发读写能力差　２固定的表结构，扩展性差　３数据存储在硬盘上，查询慢

MongoDB:面向文档的数据库，不定义表结构，可以使用复杂的查询语句，可以在海量数据中快速查询。

MongoClient client = new MongoClient(host, port);
MongoDatabase database = client.getDatabase(dbname);
MongoCollection<Document> coll = database.getCollection("collname");
coll.count()/insertOne()/deleteOne()/find()/updateOne()

Morphia morphia = new Morphia();
DataStore ds = morphia.createDataStore(client, dbname);
ds.createQuery(XX.class).filter("id =/>/<", ?).asList()/countAll()
ds.update/updateFirst(query, ?, createIfMissing)

18，设计模式？

工厂模式

一个抽象产品类派生出多个具体产品类，一个抽象工厂类派生出多个具体工厂类，每个具体产品类只有一个具体工厂类一一对应

抽象工厂

多个抽象产品类派生出多个具体产品类，一个抽象工厂类派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类，一对多

代理模式

为其他对象提供一种代理，控制对该对象的访问

代理类和被代理类需要实现同一个接口，代理类里有被代理类的实例，用来实现方法

观察者模式

多个观察者监听一个主题对象，主题对象改变时通知所有观察者，让观察者们更新自己

主题对象里存放观察者们的集合，做改变操作时通知所有观察者更新

Thrift？

跨语言通信，传输数据格式相比json体积小，传输效率高；数据结构更改需要重新生成代码

find . -name '*thrift' | thrift -r gen java {} \;

创建一个handler实现service的IFace接口，实现定义的函数

创建一个handler类型的service的processor对象

创建一个TServerSocket连接

用processor对象和socket连接作为args参数创建一个TServer

各种传输协议，各种Socket方式和各种Server；

http://blog.csdn.net/heavendai/article/details/9282967

<listener>
    <listener-class>com.travelzen.farerule.jpecker.server.contextloader.JpeckerContextLoaderListener</listener-class>
</listener>

public class JpeckerContextLoaderListener extends ContextLoaderListener{

    @Override
    public void contextInitialized(ServletContextEvent event) {
        super.contextInitialized(event);
        new Thread() {
            public void run() {
                JpeckerServiceServer.start();
            }
        }.start();
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        JpeckerServiceServer.stop();
        super.contextDestroyed(event);
    }
}

阻塞与非阻塞？

阻塞式IO：一个线程处理一个连接，连接未完成线程不能退出。

非阻塞式IO：事件来了就处理，处理完了就归还线程，可用线程池实现。

同步与异步？

同步：调用发出，不得到结果，调用就不返回。

异步：调用发出，不立刻得到结果，通过其他方式确认是否得到结果。

Spring

Spring生命周期

容器启动，实例化bean；

根据依赖注入设置bean的属性；

调用bean的前置处理方法（@PostConstruct　或　实现BeanPostProcessor接口）；

调用bean中的afterPropertiesSet方法（实现InitializingBean接口）；

调用bean的初始化方法init-method（<bean id="..." class="..." init-method="init" />）；

调用bean的后置初始化方法（@PostConstruct　或　实现BeanPostProcessor接口）；

使用bean；

@PreDestroy???

容器关闭，调用destroy方法（实现DisposableBean接口）

销毁bean

spring ioc原理？

控制反转，也叫dependency injection依赖注入，用以解耦

以配置文件管理java实例的协作关系

依赖注入分构造注入（构造方法）和设值注入（setter方法）

BeanFactory, ApplicationContext?

前者无法支持很多插件（aop，web等），后者由前者派生而来，不仅还提供其他功能。

BeanFactory采用延迟加载注入Bean，用到哪个bean时才加载实例化；ApplicationContext在启动时一次性加载所有bean。

对web的支持：

ApplicationContext能以声明方式创建，如使用ContextLoader（两个实现ContextLoaderListener和ContextLoaderServlet）

ContextLoaderListener在web应用启动后初始化。

Spring中bean的五种作用域（scope）？

singleton：SpringIoC容器中只有一个bean实例，以单例形式存在（线程不安全）

prototype：bean可以定义多个实例

request：一个request定义一个bean

session：一个HTTP session定义一个bean

globalSession：一个全局HTTP session定义一个bean

bean默认singleton，singleton线程不安全

bean生命周期？

创建实例时调用setup方法，销毁时调用tearDown方法

bean自动装配？

Spring容器自动配置相互协作的beans间的关系。

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    JdbcTemplate jdbcTemplate;
    ...
}

@AutoWired和@Resource区别？前者Spring提供，后者J2EE提供

Autowired默认按类型装配，若要允许null值，设置required属性为null，若想使用名称装配，可配合使用@Qualifier注解

@Autowired(required=false) 
@Qualifier("baseDao")
private BaseDao baseDao;

Resource默认按名称装配，设置name属性为名称

@Resource(name="baseDao")
private BaseDao baseDao;

Spring Interceptor VS Servlet Filter?

功能差不多，都针对url规则进行处理。

Filter执行在前，Interceptor执行在后。

servlet， filter， listener加载顺序？

context-param -> listener -> filter -> servlet

Filter：

在请求到达servlet之前，拦截请求并做一些预处理，处理完后转发给servlet或把不和规则的请求抛弃

servlet处理好请求后，返回响应，filter拦截响应，做一些后处理后返回请求方

多个filter按照web.xml里出现的顺序加载

Listener:

对时间进行监听和处理，采用观察者模式，只有listener上注册的事件发生时，才会调用处理方法

例如：context加载、session创建和销毁、容器/session/request的属性设置或销毁

servlet2.4规范中提供了8个listener接口，可以将其分为三类，分别如下：

第一类：与servletContext(Application)有关的listner接口。包括：ServletContextListener、ServletContextAttributeListener

第二类：与HttpSession有关的Listener接口。包括：HttpSessionListner、HttpSessionAttributeListener、HttpSessionBindingListener、HttpSessionActivationListener；

第三类：与ServletRequest有关的Listener接口，包括：ServletRequestListener、ServletRequestAttributeListener

Interceptor:

属于SpringMVC，是AOP的一种实现，通过HandlerInterceptor实现对请求的拦截。

两种实现：一是实现HandlerIntercepter接口，二是实现WebRequestInterceptor接口

HandlerInterceptor定义了三个方法：

preHandle方法：请求处理之前调用

postHandle方法：controller处理之后、视图返回渲染之前调用，对controller返回的ModelAndView进行处理

afterCompletion方法：视图渲染之后调用，主要用于资源清理

多个Interceptor按照声明顺序链式调用。‘

<mvc:interceptors>  
    <!-- 使用bean定义一个Interceptor，直接定义在mvc:interceptors根下面的Interceptor将拦截所有的请求 -->  
    <bean class="com.host.app.web.interceptor.AllInterceptor"/>  
    <mvc:interceptor>  
        <mvc:mapping path="/test/number.do"/>  
        <!-- 定义在mvc:interceptor下面的表示是对特定的请求才进行拦截的 -->  
        <bean class="com.host.app.web.interceptor.LoginInterceptor"/>  
    </mvc:interceptor>  
</mvc:interceptors>

基于注解？

<mvc:annotation-driven />

@Component @Controller @Service @Repository @Autowired

@RequestMapping("映射的url")

aop？

面向切面编程

切入点（pointcut）：在哪里做

增强（advice）：做什么

切面（aspect）：将多个类的通用行为封装为可重用的模块

aspectJ?

*实现了接口的目标对象优先用JDK代理，没实现接口的目标对象只能用CGLib代理（CGLib代理是对类实现了代理）*
<aop:aspectj-autoproxy proxy-target-class="true" />

// Aspect注解表示Aspect(Advisor)类
@Aspect
@Component
/*
* JoinPoint对象指AOP中的连接点，可通过该对象获取方法任何信息
* 环绕增强用ProceedingJoinPoint，JoinPoint的子类
* 
* execution() 表示拦截方法
* 第一个*表示方法返回任意值，第二个*表示匹配类中所有方法，(..)表示方法参数任意
*/
@Around("execution(* com.ykb.proto.service.impl.TestServiceImpl.*(..))")
public void around(ProceedingJoinPoint pjp) throws Throwable {
    before();
    pjp.proceed();
    after();
}

@Pointcut("execution(* com.ykb.proto.service.impl.TestServiceImpl.*(..))")
public void pointcut() {
}
@AfterReturning("pointcut()")
public void afterReturning() {
    System.out.println("---END---");
}

/*
* 引入增强
* 对方法的增强叫织入(weaving)，对类的增强叫引入(Introduction)
* 
* value:目标类　　defaultImpl:引入接口的默认实现类
*/
@DeclareParents(value = "com.ykb.proto.service.impl.TestServiceImpl", defaultImpl = CestServiceImpl.class)
private CestService cestService;

CestService cestService = (CestService) testService;
cestService.cest();

SpringMVC

http://676744379-qq-com.iteye.com/blog/1530911

SringMVC VS Struts2?

springMVC入口是servlet，struts2入口是filter

SpringMVC基于方法设计，struts2基于类，每次请求都会实例化一个action

SpringMVC HandlerMapping, HandlerAdapter?

HandlerMapping：SpringMVC使用HandlerMapping来找到并保存url和处理函数之间的映射关系。扫描当前所有已注册的beans的@RequestMapping注解，以找出url和handle method之间的关系并进行关联。

HandlerAdapter：SpringMVC使用HandlerAdapter实际调用处理函数。

j = j++ : j值不变

ALI

http://www.mianwww.com/html/2014/03/20390.html

http://blog.csdn.net/natian306/article/details/10858097

BIBOBALA

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
2
评论
面试准备

1，jvm工作原理？java虚拟机，java编译器将.java文件编译成.class文件，也就是字节码文件，java解释器将字节码解释成机器码运行。jvm主要包括：类加载器classloader（类运行时将.class文件加载到jvm）、运行时数据区（内存区）、执行引擎（执行.class文件中的指令）、。。。内存区包括：方法区（存储类的结构信息：常量、静态变量、构造函数等）、java堆
复制链接

扫一扫