一些小题

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）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

设计层面来说；

抽象类是对事物的抽象，即是对类的抽象，而接口是对行为的抽象，抽象是“是不是”的关系，接口是“具不具有”的关系，

如果修改抽象类，那么继承此类的子类可以不用修改，如果修改接口的话，实现接口的类必须全部修改。

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());

2.三者区别 hashMap 原理、

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的注册

ioc 初始化过程

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>

是

猜你喜欢