java相关
6.String 的常用方法
length() 求长度
equals()
trim()
substring(int beginIndex,int endIndex)
split()
6.浅谈session实现原理(阿里面试题)
1.服务器端的产生Session ID
2.服务器端和客户端存储Session ID
3.从HTTP Header中提取Session ID(发送的是一个COOKIC值)
4.根据Session ID从服务器端的Hash中获取请求者身份信息
5接口和抽象类的区别;
语法层面上的区别
1)抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;
2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;
3)接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;
4)一个类只能继承一个抽象类,而一个类却可以实现多个接口。
设计层面来说;
抽象类是对事物的抽象,即是对类的抽象,而接口是对行为的抽象,抽象是“是不是”的关系,接口是“具不具有”的关系,
如果修改抽象类,那么继承此类的子类可以不用修改,如果修改接口的话,实现接口的类必须全部修改。
4.
- java.lang:包含一些Java语言的核心类,如String、Math、Integer、System和Thread,提供常用功能。
- java.awt:包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。
- java.applet:包含applet运行所需的一些类。
- java.net:包含执行与网络相关的操作的类。
- java.io:包含能提供多种输入/输出功能的类。
- java.util:包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数。
3.Model,封装了应用程序的数据和有他们组成的pojo
View,负责把模型数据放到视图上,将数据以一定形式展现给用户
Controller,负责处理用户请求,并建立适当的模型把他传递给视图渲染
2。 java home:是指jdk所在目录,
path:是使得系统在任何目录下都能能识别java命令
classPath:是让编辑器知道去哪里加载编译java文件的时候 其所需的包和类,
1.java面试题之collection与collections区别:
collection是一个接口接口接口。他抽取出各种集合<继承List和Set>的主要功能,并做出统一行为规范。
他是很多集合的祖辈接口,没错父辈接口是List和Set。
Collections是一个工具类。工具类是工具,就像Math,Arrays类一样,他是一种工具,集成了很多特定的功能。
比如排序,拷贝,替换,反转等等等功能。工具类不能被实例化。 工具类使用方式:类名.方法名()
总体来说:collection是接口 , collections是工具类
eg:Collections.sort(list); //把list按从小到大排序
补充一点:为什么工具类不能被实例化?
工具类构造方法被private修饰了,所以不能new出来一个对象。
其中方法都是静态方法,所以可以被直接用类名调用。
2.Java中==号与equals()方法的区别
== : 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不是同一个对象。(基本数据类型==比较的是值,引用数据类型==比较的是内存地址)
hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况:
- 情况1:类没有覆盖equals()方法。则通过equals()比较该类的两个对象时,等价于通过“==”比较这两个对象。
- 情况2:类覆盖了equals()方法。一般,我们都覆盖equals()方法来两个对象的内容相等;若它们的内容相等,则返回true(即,认为这两个对象相等)。
eg:
public static void main(String[] args) {
String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
if (aa == bb) // true
System.out.println("aa==bb");
if (a == b) // false,非同一对象
System.out.println("a==b");
if (a.equals(b)) // true
System.out.println("aEQb");
if (42 == 42.0) { // true
System.out.println("true");
}
}
String s1="a"
String s2="b"
String s4="ab";
String s3=a1+s2相当于String s3=new String("ab");
所以 s3==s4//false
String 中intern()方法,该方法会先从常量池中查找是否有该常量值,如果没有则在常量池中创建,有则直接返回
eg:String s1="aa" String s2=s1.intern(); s1==s2//true;
3.值传递(基本数据类型eg:整形,浮点型,布尔型,字符型),引用传递(接口,类,数组)
值传递是指对象被值传递,意味着传递了对象的一个副本,即使副本被改变,也不会影响源对象。(因为值传递的时候,实际上是将实参的值复制一份给形参。)
引用传递是指对象被引用传递,意味着传递的并不是实际的对象,而是对象的引用。因此,外部对引用对象的改变会反映到所有的对象上。(因为引用传递的时候,实际上是将实参的地址值复制一份给形参。)
public class yinyong {
public static void main(String[] args){
Person person = new Person();
person.name="张三";
System.out.println(person.name);
change(person);
System.out.println(person.name);
}
public static void change(Person person){
//person=new Person();
person.name="李四";
}
}
class Person{
public String name;
Person(){
this.name=name;
}
}
集合相关
1.vector,ArrayList,LinkList
(1)
vector | ArrayList | LinkList |
线程安全 | 线程非安全 | 线程非安全 |
基于动态数组实现的 | 基于动态数组实现的 | 基于双向链表实现的 |
长度超过默认值会增加100% | 长度超过默认值会增加50%(默认长度是10) | ....................................... |
在多线程情况下使用 | 在随机访问多的时候用 | 在插入删除多的时候用 |
list怎么解决线程安全问题
List list = Collections.synchronizedList(new ArrayList());
HashMap | Hashtable | TreeMap |
一般用于单线程(拉链法) | 一般用于单线程(拉链法) | 一般用于多线程(红黑树) |
线程非安全 | 线程安全 | |
key、value都可以为null | key、value都不可以为null(Hashtable的key或value,都不能为null!否则,会抛出异常NullPointerException) | |
16 | 11 | |
开始学HashTable,HashMap和TreeMap的时候比较晕,觉得作用差不多,但是到实际运用的时候又发现有许多差别的。需要大家注意,在实际开发中以需求而定。
java为数据结构中的映射定义了一个接口java.util.Map,而HashMap Hashtable和TreeMap就是它的实现类。Map是将键映射到值的对象,一个映射不能包含重复的键;每个键最多只能映射一个一个值。
Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为Null;HashMap不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用Collections的synchronizedMap方法使HashMap具有同步的能力.
Hashtable 与 HashMap类似,但是主要有6点不同。
1.HashTable的方法是同步的,HashMap未经同步,所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。
2.HashTable不允许null值,key和value都不可以,HashMap允许null值,key和value都可以。HashMap允许key值只能由一个null值,因为hashmap如果key值相同,新的key, value将替代旧的。
3.HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。
4.HashTable使用Enumeration,HashMap使用Iterator。
5.HashTable中hash数组默认大小是11,增加的方式是 old*2+1。HashMap中hash数组的默认大小是16,而且一定是2的指数。
6.哈希值的使用不同,HashTable直接使用对象的hashCode。
TreeMap能够把它保存的记录根据键排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。
线程相关
1.启动线程的方式:调用start()方法
2.start()和run() 的区别:
总结:Thread和Runnable是实现java多线程的2种方式,runable是接口,thread是类,建议使用runable实现 java多线程,不管如何,最终都需要通过thread.start()来使线程处于可运行状态。
下面我们来谈谈本文重点,start()和run()方法的区别
1) start:
通过t.start()启动线程,JVM会自动调用该线程的run()方法
用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法,这里方法 run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束,此线程随即终止。
2) run:
run()方法只是类的一个普通方法而已,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。
总结:调用start方法方可启动线程,而run方法只是thread的一个普通方法调用,还是在主线程里执行。
这两个方法应该都比较熟悉,把需要并行处理的代码放在run()方法中,start()方法启动线程将自动调用 run()方法,这是由jvm的内存机制规定的。并且run()方法必须是public访问权限,返回值类型为void。
- 从运行结果肯明显可以看出,使用start()方法具有异步执行的效果,而使用run()方法是同步执行的效果,运行结果中规中矩。
- 使用start()方法,是真的启动了相应的线程0-9,而使用run()方法并没有真的启动线程,而是由一个叫main的主线程去调用的run()方法。
- 所以,正确启动线程的方式是使用start()方法。
==============================================================================
3.项目中涉及多线程的地方
转载于云栖社区
多线程是为了同步完成多项任务,不是为了提高运行效率,而是为了提高资源使用效率来提高系统的效率。线程是在同一时间需要完成多项任务的时候实现的。
问:能不能简单描述一下你在java web开发中需要用到多线程编程的场景?
对多线程有些了解,但是不太清楚具体的应用场景,能简单说一下你遇到的多线程编程的场景吗?
回答一:
最典型的如:
1、用户注册完成送大礼包/积分之类,且积分等比较耗时;且这类任务即使失败也不是特别重要的。
2、后台线程:比如定期执行一些特殊任务,如定期更新配置文件,任务调度(如quartz),一些监控用于定期信息采集等。
回答二:
最典型的应用比如tomcat,tomcat内部采用的就是多线程,上百个客户端访问同一个web应用,tomcat接入后都是把后续的处理扔给一个新的线程来处理,这个新的线程最后调用到我们的servlet程序,比如doGet或者doPost方法。
如果不采用多线程机制,上百个人同时访问一个web应用的时候,tomcat就得排队串行处理了,那样客户端根本是无法忍受那种访问速度的。
还有就是需要异步处理的时候,需要使用多线程。比如task a和task b要并行处理,单个线程只能串行处理,先做完task a然后再做task b。如果想要多个task同时执行的话,就必须为每个task分配一个线程,然后通过java虚拟机的线程调度,来同时执行多个任务。比如你的CPU是多核心的话,就可以让一个CPU执行一个线程。如果只有一个CPU的话,底层是按照分时复用的原则,各个线程按照时间片来获得CPU资源。
回答三:
特别耗时的操作,如备份数据库,可以开个线程执行备份,然后执行返回,前台不断向后台询问线程执行状态
问:JAVA项目中哪些场景需要用到多线程,深感迷茫,请使用过的高手指点。
答:
场景一:一个业务逻辑有很多次的循环,每次循环之间没有影响,比如验证1万条url路径是否存在,正常情况要循环1万次,逐个去验证每一条URL,这样效率会很低,假设验证一条需要1分钟,总共就需要1万分钟,有点恐怖。这时可以用多线程,将1万条URL分成50等份,开50个线程,没个线程只需验证200条,这样所有的线程执行完是远小于1万分钟的。
场景二:需要知道一个任务的执行进度,比如我们常看到的进度条,实现方式可以是在任务中加入一个整型属性变量(这样不同方法可以共享),任务执行一定程度就给变量值加1,另外开一个线程按时间间隔不断去访问这个变量,并反馈给用户。
总之使用多线程就是为了充分利用cpu的资源,提高程序执行效率,当你发现一个业务逻辑执行效率特别低,耗时特别长,就可以考虑使用多线程。不过CPU执行哪个线程的时间和顺序是不确定的,即使设置了线程的优先级,因此使用多线程的风险也是比较大的,会出现很多预料不到的问题.这时候就牵扯到了多线程的并发问题.
wait and sleep 区别
sleep,是Thread中的方法,调用sleep方法时不会释放锁,
wait ,是Object 中的方法,调用wait方法时会释放锁,会把线程放到等待队列当中,直到其他线程调用此对象的notify或notifyAll方法,
wait通常用于线程交互,sleep通常用于线程暂停
原子操作
原子操作是不可分割的操作,一个原子操作中是不会被其他线程所打断的,所以不需要对原子操作同步,i++ 不是原子操作,因为他包含了对数据的读取,修改,写入,等
volatile
换句话说,被volatile修饰的变量,能保证该变量的 单次读或者单次写 操作是原子的。
但是线程安全是两方面需要的 原子性(指的是多条操作)和可见性。volatile只能保证可见性,synchronized是两个均保证的。
volatile轻量级,只能修饰变量;synchronized重量级,还可修饰方法。
volatile不会造成线程的阻塞,而synchronized可能会造成线程的阻塞。
start() and run()
调用start()方法会新建一个线程,并且执行run里面的方法,而直接调用run()方法,不会创建一个新的线程,只会当做一个普通方法
ThreadLocal
ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单,就是为每一个使用该变量的线程都提供一个变量值的副本,是Java中一种较为特殊的线程绑定机制,是每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突。
========================================================================================
框架相关:
1.spring ioc:spring可以把对象之间的依赖关系转而用配置文件来管理,这就是其依赖注入机制,而这个注入关系在一个叫ioc容器中来管理,ioc就是可以动态的将一个对象所需的依赖注入给这个对象,而不用对象自己去new 一个自己所需的依赖,这就是我所理解的ioc
aop
2spring ioc初始化过程
(1)Resource定位,(2)BeanDefinition的载入,(3)BeanDefinition的注册
3.BeanFactory applicationcontext区别?
1. BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能:
a. 国际化支持
b. 资源访问:Resource rs = ctx. getResource(“classpath:config.properties”), “file:c:/config.properties”
c. 事件传递:通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext
1.BeanFactroy采用的是延迟加载形式来注入Bean的,即只有在使用到某个Bean时(调用getBean()),才对该Bean进行加载实例化,这样,我们就不能发现一些存在的Spring的配置问题。而ApplicationContext则相反,它是在容器启动时,一次性创建了所有的Bean。这样,在容器启动时,我们就可以发现Spring中存在的配置错误。 相对于基本的BeanFactory,ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时,程序启动较慢。
BeanFacotry延迟加载,如果Bean的某一个属性没有注入,BeanFacotry加载后,直至第一次使用调用getBean方法才会抛出异常;而ApplicationContext则在初始化自身是检验,这样有利于检查所依赖属性是否注入;所以通常情况下我们选择使用 ApplicationContext。
应用上下文则会在上下文启动后预载入所有的单实例Bean。通过预载入单实例bean ,确保当你需要的时候,你就不用等待,因为它们已经创建好了。
2.BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用,但两者之间的区别是:BeanFactory需要手动注册,而ApplicationContext则是自动注册。(Applicationcontext比 beanFactory 加入了一些更好使用的功能。而且 beanFactory 的许多功能需要通过编程实现而 Applicationcontext 可以通过配置实现。比如后处理 bean , Applicationcontext 直接配置在配置文件即可而 beanFactory 这要在代码中显示的写出来才可以被容器识别。 )
3.beanFactory主要是面对与 spring 框架的基础设施,面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 。
@Before @After @Around @AfterReturning @AfterThrowing 的执行顺序
=============================================================================================
mybatis相关
1. mybatis 优缺点:
Mybatis的优点:
1、易于上手和掌握,提供了数据库查询的自动对象绑定功能,而且延续了很好的SQL使用经验,对于没有那么高的对象模型要求的项目来说,相当完美。
2、sql写在xml里,便于统一管理和优化, 解除sql与程序代码的耦合。
3、提供映射标签,支持对象与数据库的orm字段关系映射
4、 提供对象关系映射标签,支持对象关系组建维护
5、提供xml标签,支持编写动态sql。
6、速度相对于Hibernate的速度较快
Mybatis的缺点:
1. SQL语句的编写工作量较大,尤其是字段多、关联表多时,更是如此,对开发人员编写SQL语句的功底有一定要求。
2. SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库。
3、由于xml里标签id必须唯一,导致DAO中方法不支持方法重载。
4、对象关系映射标签和字段映射标签仅仅是对映射关系的描述,具体实现仍然依赖于sql。
5、DAO层过于简单,对象组装的工作量较大。
6、不支持级联更新、级联删除。
7、Mybatis的日志除了基本记录功能外,其它功能薄弱很多。
8、编写动态sql时,不方便调试,尤其逻辑复杂时。
9、提供的写动态sql的xml标签功能简单,编写动态sql仍然受限,且可读性低。
2.mybatis 怎么实现关联表查询
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的
例如namespace="me.gacl.mapping.classMapper"就是me.gacl.mapping(包名)+classMapper(classMapper.xml文件去除后缀)
-->
<mapper namespace="me.gacl.mapping.classMapper">
<!--
根据班级id查询班级信息(带老师的信息)
##1. 联表查询
SELECT * FROM class c,teacher t WHERE c.teacher_id=t.t_id AND c.c_id=1;
##2. 执行两次查询
SELECT * FROM class WHERE c_id=1; //teacher_id=1
SELECT * FROM teacher WHERE t_id=1;//使用上面得到的teacher_id
-->
<!--
方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集
封装联表查询的数据(去除重复的数据)
select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1
-->
<select id="getClass" parameterType="int" resultMap="ClassResultMap">
select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
</select>
<!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
<resultMap type="me.gacl.domain.Classes" id="ClassResultMap">
<id property="id" column="c_id"/>
<result property="name" column="c_name"/>
<association property="teacher" javaType="me.gacl.domain.Teacher">
<id property="id" column="t_id"/>
<result property="name" column="t_name"/>
</association>
</resultMap>
<!--
方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型
SELECT * FROM class WHERE c_id=1;
SELECT * FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id的值
-->
<select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
select * from class where c_id=#{id}
</select>
<!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
<resultMap type="me.gacl.domain.Classes" id="ClassResultMap2">
<id property="id" column="c_id"/>
<result property="name" column="c_name"/>
<association property="teacher" column="teacher_id" select="getTeacher"/>
</resultMap>
<select id="getTeacher" parameterType="int" resultType="me.gacl.domain.Teacher">
SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
</select>
</mapper>
是