常见JAVA面试问题

最新推荐文章于 2022-07-23 16:12:42 发布
置顶 最新推荐文章于 2022-07-23 16:12:42 发布
阅读量688 收藏 7
点赞数 1
分类专栏： Java 文章标签： 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djqtdj/article/details/78491653
版权

J2SE

switch支持的类型

byte、short、char、int、Integer、String、Enum

java中集合的几种形式

java集合简介
常用的集合分为List（有序排放）、Map（以名和值一一对应的存放）、Set（既无序也没名）
在这三者之中其中List和Set是Collection接口的子接口，而Map不是Collection接口的子接口

List

为了学习List，这里介绍List的实现类：ArrayList和LinkedList

  1. ArrayList：索引从0开始，线性存储，有索引，有顺序
    主要方法：add()用于往集合中添加元素，get()用于获取指定索引处的元素，size()获得集合的长度，相当于数组中的length

  2. LinkedList：也是线性存储，有索引，有顺序
    它和ArrayList差不多，它有ArrayList集合中不具备的方法，如：addFirst(Object)这是往list集合的最前边添加元素的方法，相应的还有addLast等

  3. ArrayList和LinkedList的区别和联系：
    linkedlist集合的优势：添加元素时可以指定位置，比ArrayList集合添加元素要快很多。
    但Linkedlist在get获取的时候比Arraylist集合要慢的多，而且获取元素越往后检索的越慢。

  4. 这两种方式各有优缺，为更好的使用可以将这两者进行联合使用，使用Linkedlist集合进行存储和添加元素，使用Arraylist集合进行get获取元素。

Map 名字和值一一对应，是无序的，有名且名字不能重复

为学习Map，先从它的实现类HashMap学起。
Map：给map添加元素是使用put方法进行添加。map.put("名"，值)
给map添加元素是使用put方法进行添加。map.put("名"，值)
获得是get(名)
在map中只要得到全部的名字就能得到所有的值

这就需要用到set来获得所有的名字：
Set keyname=map.keySet();

使用Set中的迭代器:
Iterator it=keyname.iterator();
while(it.hasNext()){
  Object key=it.next(); 名
  Object value=map.get(key); 值
}

Set：既不需要有编号也不需要有名，来了就往里放，存放速度相对较快，但取不好取

这里就常用HashSet（set的实现类）
添加元素为add()
变量获取元素：使用它的iterator()方法是执行迭代器的工具

Iterator it=set.iterator();
it.hashNext();  判断下一个是否有
it.Next();下一个
使用while(it.hasNext()){
  system.out.println(it.next());
}
输出也是无序的。

java集合遍历方式

集合类的通用遍历方式, 用迭代器迭代

Iterator it = list.iterator();
while(it.hasNext()) {
　　Object obj = it.next();
}

Map遍历方式


1、通过获取所有的key按照key来遍历
//Set<Integer> set = map.keySet(); //得到所有key的集合
for (Integer in : map.keySet()) {
    String str = map.get(in);//得到每个key多对用value的值
}

2、通过Map.entrySet使用iterator遍历key和value
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
     Map.Entry<Integer, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

3、通过Map.entrySet遍历key和value，推荐，尤其是容量大时
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
    //entry.getKey() ;entry.getValue(); entry.setValue();
    //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

4、通过Map.values()遍历所有的value，但不能遍历key
for (String v : map.values()) {
    System.out.println("value= " + v);
}

List遍历方式

第一种：
for(Iterator iterator = list.iterator();iterator.hasNext();){
    int i = (Integer) iterator.next();
    System.out.println(i);
}
第二种：
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    int i = (Integer) iterator.next();
    System.out.println(i);
}
第三种：
for (Object object : list) {
    System.out.println(object);
}
第四种：
for(int i = 0 ;i<list.size();i++) {
    int j= (Integer) list.get(i);
    System.out.println(j);
}
数据元素是怎样在内存中存放的？

  1. 顺序存储，Random Access（Direct Access）
    相邻的数据元素存放于相邻的内存地址中，整块内存地址是连续的。可以根据元素的位置直接计算出内存地址，直接进行读取。读取一个特定位置元素的平均时间复杂度为O(1)。正常来说，只有基于数组实现的集合，才有这种特性。Java中以ArrayList为代表。

  2. 链式存储，Sequential Access
    每一个数据元素，在内存中都不要求处于相邻的位置，每个数据元素包含它下一个元素的内存地址。不可以根据元素的位置直接计算出内存地址，只能按顺序读取元素。读取一个特定位置元素的平均时间复杂度为O(n)。主要以链表为代表。Java中以LinkedList为代表。

每个遍历方法的实现原理是什么？

  1. 传统的for循环遍历，基于计数器的
    遍历者自己在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后，停止。主要就是需要按元素的位置来读取元素。

  2. 迭代器遍历，Iterator
    每一个具体实现的数据集合，一般都需要提供相应的Iterator。相比于传统for循环，Iterator取缔了显式的遍历计数器。所以基于顺序存储集合的Iterator可以直接按位置访问数据。而基于链式存储集合的Iterator，正常的实现，都是需要保存当前遍历的位置。然后根据当前位置来向前或者向后移动指针。

  3. foreach循环遍历
    根据反编译的字节码可以发现，foreach内部也是采用了Iterator的方式实现，只不过Java编译器帮我们生成了这些代码。

各遍历方式对于不同的存储方式，性能如何？

  1. 传统的for循环遍历，基于计数器的
    因为是基于元素的位置，按位置读取。所以我们可以知道，对于顺序存储，因为读取特定位置元素的平均时间复杂度是O(1)，所以遍历整个集合的平均时间复杂度为O(n)。而对于链式存储，因为读取特定位置元素的平均时间复杂度是O(n)，所以遍历整个集合的平均时间复杂度为O(n2)（n的平方）。
    ArrayList按位置读取的代码：直接按元素位置读取。

  2. 迭代器遍历，Iterator
    那么对于RandomAccess类型的集合来说，没有太多意义，反而因为一些额外的操作，还会增加额外的运行时间。但是对于Sequential Access的集合来说，就有很重大的意义了，因为Iterator内部维护了当前遍历的位置，所以每次遍历，读取下一个位置并不需要从集合的第一个元素开始查找，只要把指针向后移一位就行了，这样一来，遍历整个集合的时间复杂度就降低为O(n)；

  3. foreach循环遍历
    分析Java字节码可知，foreach内部实现原理，也是通过Iterator实现的，只不过这个Iterator是Java编译器帮我们生成的，所以我们不需要再手动去编写。但是因为每次都要做类型转换检查，所以花费的时间比Iterator略长。时间复杂度和Iterator一样。

各遍历方式的适用于什么场合？

foreach只是让代码更加简洁了，但是他有一些缺点，就是遍历过程中不能操作数据集合（删除等），所以有些场合不使用。而且它本身就是基于Iterator实现的，但是由于类型转换的问题，所以会比直接使用Iterator慢一点，但是还好，时间复杂度都是一样的。所以怎么选择，参考上面两种方式，做一个折中的选择。

循环遍历顺序存储链式存储
for读取性能比较高。适用于遍历顺序存储集合时间复杂度太大，不适用于遍历链式存储的集合
Iterator如果不是太在意时间，推荐选择此方式，毕竟代码更加简洁，也防止了Off-By-One的问题意义就重大了，平均时间复杂度降为O(n)，还是挺诱人的，所以推荐此种遍历方式
foreach
Java的最佳实践是什么？
Java数据集合框架中，提供了一个RandomAccess接口，该接口没有方法，只是一个标记。通常被List接口的实现使用，用来标记该List的实现是否支持Random Access。
一个数据集合实现了该接口，就意味着它支持Random Access，按位置读取元素的平均时间复杂度为O(1)。比如ArrayList。
而没有实现该接口的，就表示不支持Random Access。比如LinkedList。
所以看来JDK开发者也是注意到这个问题的，那么推荐的做法就是，如果想要遍历一个List，那么先判断是否支持Random Access，也就是 list instanceof RandomAccess。
比如：
if (list instanceof RandomAccess) {
    //使用传统的for循环遍历。
} else {
    //使用Iterator或者foreach。
}

HashMap和Hashtable的区别

  1. hashmap不是线程安全的，存放的是键值对，并且不允许重复的键，但可以包含重复的值。允许存放空的键和值
  2. hashtable是线程安全的，不允许存放空的键和值

ArrayList与Vector的区别

  1. Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
  2. ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
  3. 总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。

collection和collections的区别

  1. java.util.Collection 是一个集合接口。
    它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式
  2. java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法，用于实现对各种集合的搜索、排序、线程安全化等操作。此类不能实例化，就像一个工具类，服务于Java的Collection框架

comparable和comparator的区别

Comparable 简介
Comparable 是排序接口。
若一个类实现了Comparable接口，就意味着“该类支持排序”。 即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过
Collections.sort（或 Arrays.sort）进行排序。

Comparable 定义
Comparable 接口仅仅只包括一个函数，它的定义如下：

package java.lang;
import java.util.*;

public interface Comparable<T> {
    public int compareTo(T o);
}
说明：
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

Comparator 简介
Comparator 是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。
也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序

Comparator 定义
Comparator 接口仅仅只包括两个个函数，它的定义如下：

package java.util;

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

  1. 若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。为什么可以不实现 equals(Object obj) 函数呢？ 因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数；所以，其它所有的类也相当于都实现了该函数。

  2. int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”

Comparator 和 Comparable 比较
Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。
而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

import java.util.*;
import java.lang.Comparable;

/**
 * @desc "Comparator"和“Comparable”的比较程序。
 *   (01) "Comparable"
 *   它是一个排序接口，只包含一个函数compareTo()。
 *   一个类实现了Comparable接口，就意味着“该类本身支持排序”，它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。
 *   (02) "Comparator"
 *   它是一个比较器接口，包括两个函数：compare() 和 equals()。
 *   一个类实现了Comparator接口，那么它就是一个“比较器”。其它的类，可以根据该比较器去排序。
 *
 *   综上所述：Comparable是内部比较器，而Comparator是外部比较器。
 *   一个类本身实现了Comparable比较器，就意味着它本身支持排序；若它本身没实现Comparable，也可以通过外部比较器Comparator进行排序。
 */
public class CompareComparatorAndComparableTest{

    public static void main(String[] args) {
        // 新建ArrayList(动态数组)
        ArrayList<Person> list = new ArrayList<Person>();
        // 添加对象到ArrayList中
        list.add(new Person("ccc", 20));
        list.add(new Person("AAA", 30));
        list.add(new Person("bbb", 10));
        list.add(new Person("ddd", 40));

        // 打印list的原始序列
        System.out.printf("Original  sort, list:%s\n", list);

        // 对list进行排序
        // 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序
        Collections.sort(list);
        System.out.printf("Name      sort, list:%s\n", list);

        // 通过“比较器(AscAgeComparator)”，对list进行排序
        // AscAgeComparator的排序方式是：根据“age”的升序排序
        Collections.sort(list, new AscAgeComparator());
        System.out.printf("Asc(age)  sort, list:%s\n", list);

        // 通过“比较器(DescAgeComparator)”，对list进行排序
        // DescAgeComparator的排序方式是：根据“age”的降序排序
        Collections.sort(list, new DescAgeComparator());
        System.out.printf("Desc(age) sort, list:%s\n", list);

        // 判断两个person是否相等
        testEquals();
    }

    /**
     * @desc 测试两个Person比较是否相等。
     *   由于Person实现了equals()函数：若两person的age、name都相等，则认为这两个person相等。
     *   所以，这里的p1和p2相等。
     *
     *   TODO：若去掉Person中的equals()函数，则p1不等于p2
     */
    private static void testEquals() {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        if (p1.equals(p2)) {
            System.out.printf("%s EQUAL %s\n", p1, p2);
        } else {
            System.out.printf("%s NOT EQUAL %s\n", p1, p2);
        }
    }

    /**
     * @desc Person类。
     *       Person实现了Comparable接口，这意味着Person本身支持排序
     */
    private static class Person implements Comparable<Person>{
        int age;
        String name;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public String toString() {
            return name + " - " +age;
        }

        /**
         * 比较两个Person是否相等：若它们的name和age都相等，则认为它们相等
         */
        boolean equals(Person person) {
            if (this.age == person.age && this.name == person.name)
                return true;
            return false;
        }

        /**
         * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。
         *  这里是通过“person的名字”进行比较的
         */
        @Override
        public int compareTo(Person person) {
            return name.compareTo(person.name);
            //return this.name - person.name;
        }
    }

    /**
     * @desc AscAgeComparator比较器
     *       它是“Person的age的升序比较器”
     */
    private static class AscAgeComparator implements Comparator<Person> {

        @Override 
        public int compare(Person p1, Person p2) {
            return p1.getAge() - p2.getAge();
        }
    }

    /**
     * @desc DescAgeComparator比较器
     *       它是“Person的age的升序比较器”
     */
    private static class DescAgeComparator implements Comparator<Person> {

        @Override 
        public int compare(Person p1, Person p2) {
            return p2.getAge() - p1.getAge();
        }
    }

}



private static class Person implements Comparable<Person>{
    int age;
    String name;

        ...

    /** 
     * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。
     *  这里是通过“person的名字”进行比较的
     */
    @Override
    public int compareTo(Person person) {
        return name.compareTo(person.name);
        //return this.name - person.name;
    }   
}

String、StringBuffer、StringBuilder比较

  • String类是不可变类，任何对String的改变都 会引发新的String对象的生成
  • StringBuffer和StringBuilder则是可变类，任何对它所指代的字符串的改变都不会产生新的对象
  • StringBufferd支持并发操作，线性安全的，适 合多线程中使用
  • StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。新引入的StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。
补充：
String str1="hello"
String str2="hello"
String str3=new String("hello");
String str4="he"+"llo";

str1==str2返回true
在字符串实例池中，已经有hello，str2会直接引用池中的hello，而不会去创建对象

str1==str3返回false
new 关键字每次都会产生新的字符串对象

java 多线程

  1. 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
    这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。

  2. 在Java中Lock接口比synchronized块的优势是什么？
    你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
    lock接口在多线程和并发编程中最大的优势是它们为读和写分别提供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。我强烈建议在你去参加多线程的面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。

  3. 在java中wait和sleep方法的不同？
    通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。

  4. 用Java实现阻塞队列。
    这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序；第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait和notify方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。

  5. 用Java写代码来解决生产者——消费者问题。
    与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。

  6. 用Java编程一个会导致死锁的程序，你将怎么解决？
    这是我最喜欢的Java线程面试问题，因为即使死锁问题在写多线程并发程序时非常普遍，但是很多侯选者并不能写deadlock free code（无死锁代码？），他们很挣扎。只要告诉他们，你有N个资源和N个线程，并且你需要所有的资源来完成一个操作。为了简单这里的n可以替换为2，越大的数据会使问题看起来更复杂。通过避免Java中的死锁来得到关于死锁的更多信息。

  7. 什么是原子操作，Java中的原子操作是什么？
    非常简单的java线程面试问题，接下来的问题是你需要同步一个原子操作。

  8. Java中的volatile关键是什么作用？怎样使用它？在Java中它跟synchronized方法有什么不同？
    自从Java 5和Java内存模型改变以后，基于volatile关键字的线程问题越来越流行。应该准备好回答关于volatile变量怎样在并发环境中确保可见性。

  9. 什么是竞争条件？你怎样发现和解决竞争？
    这是一道出现在多线程面试的高级阶段的问题。大多数的面试官会问最近你遇到的竞争条件，以及你是怎么解决的。有些时间他们会写简单的代码，然后让你检测出代码的竞争条件。可以参考我之前发布的关于Java竞争条件的文章。在我看来这是最好的java线程面试问题之一，它可以确切的检测候选者解决竞争条件的经验，or writing code which is free of data race or any other race condition。关于这方面最好的书是《Concurrency practices in Java》。

  10. 你将如何使用thread dump？你将如何分析Thread dump？
    在UNIX中你可以使用kill -3，然后thread dump将会打印日志，在windows中你可以使用”CTRL+Break”。非常简单和专业的线程面试问题，但是如果他问你怎样分析它，就会很棘手。

  11. 为什么我们调用start方法时会执行run方法，为什么我们不能直接调用run方法？
    这是另一个非常经典的java多线程面试问题。这也是我刚开始写线程程序时候的困惑。现在这个问题通常在电话面试或者是在初中级Java面试的第一轮被问到。这个问题的回答应该是这样的，当你调用start方法时你将创建新的线程，并且执行在run方法里的代码。但是如果你直接调用run方法，它不会创建新的线程也不会执行调用线程的代码。阅读我之前写的《start与run方法的区别》这篇文章来获得更多信息。

  12. Java中你怎样唤醒一个阻塞的线程？
    这是个关于线程和阻塞的棘手的问题，它有很多解决方法。如果线程遇到了IO阻塞，我并且不认为有一种方法可以中止线程。如果线程因为调用wait、sleep、或者join方法而导致的阻塞，你可以中断线程，并且通过抛出InterruptedException来唤醒它。我之前写的《How to deal with blocking methods in java》有很多关于处理线程阻塞的信息。

  13. 在Java中CycliBarriar和CountdownLatch有什么区别？
    这个线程问题主要用来检测你是否熟悉JDK5中的并发包。这两个的区别是CyclicBarrier可以重复使用已经通过的障碍，而CountdownLatch不能重复使用。

  14. 什么是不可变对象，它对写并发应用有什么帮助？
    另一个多线程经典面试问题，并不直接跟线程有关，但间接帮助很多。这个java面试问题可以变的非常棘手，如果他要求你写一个不可变对象，或者问你为什么String是不可变的。

  15. 你在多线程环境中遇到的常见的问题是什么？你是怎么解决它的？
    多线程和并发程序中常遇到的有Memory-interface、竞争条件、死锁、活锁和饥饿。问题是没有止境的，如果你弄错了，将很难发现和调试。这是大多数基于面试的，而不是基于实际应用的Java线程问题。

java中实现线程的方式及锁(synchronize)的使用

  • 继承Thread类
public class Mythread extends Thread{
    public void run(){    
    }
}

Mythread t=new Mythread();
t.start();
  • 实现Runnable接口
public class Mythread implements Runnable{
    public void run(){    
    }
}

Thread t=new Thread(new Mythread());
t.start();

锁可作用于方法，也可作用于语句块
public synchronize void test(){
}
public void test(){
    synchronize(this){
    }
}

多线程环境下，一个线程拥有一个对象锁后，
另一个线程必须等待该线程释放对象锁，否则一直处于阻塞状态。
释放对象锁可以通过调用wait（）方法实现

sleep()和wait()的区别

sleep和wait来自不同的类分别是Thread和Object
最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法
wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

jdbc中的preparedstatement

jdbc操作数据库是通过Statement来实现的，preparedstatement是Statement的子接口，相比于Statement，它可以预编译动态sql语句，通过占位符来实现动态拼接
String sql="insert into table values(?,?)";
PreparedStatement pstmt=conn.prepareStatement(sql);
pstmt.setXXX(1,xxx);
pstmt.setXXX(2,xxx);

java中创建一个单例

注意：实现一个单例有两点注意事项
①将构造器私有，不允许外界通过构造器创建对象
②通过公开的静态方法向外界返回类的唯一实例

饿汉式单例
public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}
懒汉式单例
public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static synchronized Singleton getInstance(){
        if (instance == null) instance ＝ new Singleton();
        return instance;
    }
}

SERVLET

servlet的生命周期、工作原理

  • Servlet 生命周期：Servlet 加载—>实例化—>服务—>销毁。
  • init（）：在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，负责初始化Servlet对象。可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。无论有多少客户机访问Servlet，都不会重复执行init（）。
  • service（）：它是Servlet的核心，负责响应客户的请求。每当一个客户请求一个HttpServlet对象，该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求的方法相应的do功能。
  • destroy（）： 仅执行一次，在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时，负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，这些线程已经终止或完成。

Servlet工作原理

  1. 首先简单解释一下Servlet接收和响应客户请求的过程，首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，通过源代码可见，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法，实现对客户的响应。在Servlet接口和GenericServlet中是没有doGet（）、doPost（）等等这些方法的，HttpServlet中定义了这些方法，但是都是返回error信息，所以，我们每次定义一个Servlet的时候，都必须实现doGet或doPost等这些方法
  2. 每一个自定义的Servlet都必须实现Servlet的接口，Servlet接口中定义了五个方法，其中比较重要的三个方法涉及到Servlet的生命周期，分别是上文提到的init(),service(),destroy()方法。GenericServlet是一个通用的，不特定于任何协议的Servlet,它实现了Servlet接口。而HttpServlet继承于GenericServlet，因此HttpServlet也实现了Servlet接口。所以我们定义Servlet的时候只需要继承HttpServlet即可。
  3. Servlet接口和GenericServlet是不特定于任何协议的，而HttpServlet是特定于HTTP协议的类，所以HttpServlet中实现了service()方法，并将请求ServletRequest、ServletResponse 强转为HttpRequest 和 HttpResponse。

servlet与jsp的区别

  1. jsp经编译后就变成了Servlet.(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
  2. jsp更擅长表现于页面显示,servlet更擅长于逻辑控制
  3. Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象,HttpServletResponse对象以及HttpServlet对象得到
  4. Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。

servlet是线程安全的吗

Servlet不是线程安全的。
要解释为什么Servlet为什么不是线程安全的，需要了解Servlet容器（即Tomcat）使如何响应HTTP请求的。
当Tomcat接收到Client的HTTP请求时，Tomcat从线程池中取出一个线程，之后找到该请求对应的Servlet对象。如果该Servlet还未被请求过，那么将进行Servlet初始化并调用Servlet并调用service()方法。否则，直接调用service()方法。要注意的是每一个Servlet对象再Tomcat容器中只有一个实例对象，即是单例模式。如果多个HTTP请求请求的是同一个Servlet，那么着两个HTTP请求对应的线程将并发调用Servlet的service()方法。
这时候，如果在Servlet中定义了实例变量或静态变量，那么可能会发生线程安全问题（因为所有的线程都可能使用这些变量）。

servlet中forward()和redirect()的区别

  1. forward重定向是在容器内部实现的同一个Web应用程序的重定向，所以forward方法只能重定向到同一个Web应用程序中的一个资 源，重定向后浏览器地址栏URL不变，而sendRedirect方法可以重定向到任何URL， 因为这种方法是修改http头来实现的，URL没什么限制，重定向后浏览器地址栏URL改变。

  2. forward重定向将原始的HTTP请求对象 （request）从一个servlet实例传递到另一个实例，而采用sendRedirect方式两者不是同一个application。

  3. 基于第二 点，参数的传递方式不一样。forward的form参数跟着传递，所以在第二个实例中可以取得HTTP请求的参数。sendRedirect只能通过链 接传递参数，response.sendRedirect(“login.jsp?param1=a”)。

WEB前端

cookie机制

Cookies是服务器在本地机器上存储的小段文本并随每一个请求发送至同一个服务器。IETF RFC 2965 HTTP State Management Mechanism 是通用cookie规范。网络服务器用HTTP头向客户端发送cookies，在客户终端，浏览器解析这些cookies并将它们保存为一个本地文件，它会自动将同一服务器的任何请求缚上这些cookies 。

具体来说cookie机制采用的是在客户端保持状态的方案。它是在用户端的会话状态的存贮机制，他需要用户打开客户端的cookie支持。cookie的作用就是为了解决HTTP协议无状态的缺陷所作的努力。
正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript也可以生成cookie。而cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。

cookie的内容主要包括：名字，值，过期时间，路径和域。路径与域一起构成cookie的作用范围。若不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，关闭浏览器窗口，cookie就消失。这种生命期为浏览器会话期的cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。若设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式。

而session机制采用的是一种在服务器端保持状态的解决方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的。而session提供了方便管理全局变量的方式 。

session是针对每一个用户的，变量的值保存在服务器上，用一个sessionID来区分是哪个用户session变量,这个值是通过用户的浏览器在访问的时候返回给服务器，当客户禁用cookie时，这个值也可能设置为由get来返回给服务器。

就安全性来说：当你访问一个使用session 的站点，同时在自己机子上建立一个cookie，建议在服务器端的session机制更安全些，因为它不会任意读取客户存储的信息。

session机制

session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。

当程序需要为某个客户端的请求创建一个session时，服务器首先检查这个客户端的请求里是否已包含了一个session标识（称为session id），如果已包含则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（检索不到，会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。

保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID。但cookie可以被人为的禁止，则必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。
经常被使用的一种技术叫做URL重写，就是把session id直接附加在URL路径的后面。还有一种技术叫做表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时能够把session id传递回服务器。

Cookie与Session都能够进行会话跟踪，但是完成的原理不太一样。普通状况下二者均能够满足需求，但有时分不能够运用Cookie，有时分不能够运用Session。下面经过比拟阐明二者的特性以及适用的场所。

1 .存取方式的不同

Cookie中只能保管ASCII字符串，假如需求存取Unicode字符或者二进制数据，需求先进行编码。Cookie中也不能直接存取Java对象。若要存储略微复杂的信息，运用Cookie是比拟艰难的。
而Session中能够存取任何类型的数据，包括而不限于String、Integer、List、Map等。Session中也能够直接保管Java Bean乃至任何Java类，对象等，运用起来十分便当。能够把Session看做是一个Java容器类。

2 .隐私策略的不同

Cookie存储在客户端阅读器中，对客户端是可见的，客户端的一些程序可能会窥探、复制以至修正Cookie中的内容。而Session存储在服务器上，对客户端是透明的，不存在敏感信息泄露的风险。
假如选用Cookie，比较好的方法是，敏感的信息如账号密码等尽量不要写到Cookie中。最好是像Google、Baidu那样将Cookie信息加密，提交到服务器后再进行解密，保证Cookie中的信息只要本人能读得懂。而假如选择Session就省事多了，反正是放在服务器上，Session里任何隐私都能够有效的保护。
3.有效期上的不同

使用过Google的人都晓得，假如登录过Google，则Google的登录信息长期有效。用户不用每次访问都重新登录，Google会持久地记载该用户的登录信息。要到达这种效果，运用Cookie会是比较好的选择。只需要设置Cookie的过期时间属性为一个很大很大的数字。

由于Session依赖于名为JSESSIONID的Cookie，而Cookie JSESSIONID的过期时间默许为–1，只需关闭了阅读器该Session就会失效，因而Session不能完成信息永世有效的效果。运用URL地址重写也不能完成。而且假如设置Session的超时时间过长，服务器累计的Session就会越多，越容易招致内存溢出。

4.服务器压力的不同

Session是保管在服务器端的，每个用户都会产生一个Session。假如并发访问的用户十分多，会产生十分多的Session，耗费大量的内存。因而像Google、Baidu、Sina这样并发访问量极高的网站，是不太可能运用Session来追踪客户会话的。

而Cookie保管在客户端，不占用服务器资源。假如并发阅读的用户十分多，Cookie是很好的选择。关于Google、Baidu、Sina来说，Cookie或许是唯一的选择。

5 .浏览器支持的不同

Cookie是需要客户端浏览器支持的。假如客户端禁用了Cookie，或者不支持Cookie，则会话跟踪会失效。关于WAP上的应用，常规的Cookie就派不上用场了。

假如客户端浏览器不支持Cookie，需要运用Session以及URL地址重写。需要注意的是一切的用到Session程序的URL都要进行URL地址重写，否则Session会话跟踪还会失效。关于WAP应用来说，Session+URL地址重写或许是它唯一的选择。

假如客户端支持Cookie，则Cookie既能够设为本浏览器窗口以及子窗口内有效（把过期时间设为–1），也能够设为一切阅读器窗口内有效（把过期时间设为某个大于0的整数）。但Session只能在本阅读器窗口以及其子窗口内有效。假如两个浏览器窗口互不相干，它们将运用两个不同的Session。（IE8下不同窗口Session相干）

6.跨域支持上的不同

Cookie支持跨域名访问，例如将domain属性设置为“.biaodianfu.com”，则以“.biaodianfu.com”为后缀的一切域名均能够访问该Cookie。跨域名Cookie如今被普遍用在网络中，例如Google、Baidu、Sina等。
而Session则不会支持跨域名访问。Session仅在他所在的域名内有效。
仅运用Cookie或者仅运用Session可能完成不了理想的效果。这时应该尝试一下同时运用Cookie与Session。Cookie与Session的搭配运用在实践项目中会完成很多意想不到的效果。

jsp内置对象

内置对象所属类
pageContextjavax.servlet.jsp.PageContext
requestjavax.servlet.http.HttpServletRequest
responsejavax.servlet.http.HttpServletResponse
sessionjavax.servlet.http.HttpSession
configjavax.servlet.ServletConfig
applicationjavax.servlet.ServletContext
outjavax.servlet.jsp.JspWriter
pagejava.lang.Object
exceptionjava.lang.Throwable

jsp的四个作用域

名称作用域
application在所有应用程序中有效
session在当前会话中有效
request在当前请求中有效
page在当前页面有效

Ajax的原理

  • Ajax的原理就是:通过javascript的方式，将前台数据通过xmlhttp对象传递到后台，后台在接收到请求后，将需要的结果，再传回到前台，这样就可以实现不需要页面的回发，页是数据实现来回传递，从页实现无刷新。

  • Ajax的原理简单来说，实际上就是通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用javascript来操作DOM而更新页面。

  • 这其中最关键的一步就是从服务器获得请求数据。要清楚这个过程和原理，我们必须对 XMLHttpRequest有所了解。

  • 我们可以看出，XMLHttpRequest对象完全用来向服务器发出一个请求的，它的作用也局限于此，但它的作用是整个ajax实现的关键，我们可以把服务器端看成一个数据接口，它返回的是一个纯文本流，当然，这个文本流可以是XML格式，可以是Html，可以是Javascript代码，也可以只是一个字符串。这时候，XMLHttpRequest向服务器端请求这个页面，服务器端将文本的结果写入页面，这和普通的web开发流程是一样的，不同的是，客户端在异步获取这个结果后，不是直接显示在页面，而是先由javascript来处理，然后再显示在页面。

js原生ajax

"<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Transitional//EN"" ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"">

<html xmlns=""http://www.w3.org/1999/xhtml"">
<head>
    <title>js中的Ajax经典示例</title>
    <script type=""text/javascript"" src=""Scripts/jquery-1.4.1.js""></script>
    <script type=""text/javascript"">

      function ajax() {

          //先声明一个异步请求对象
          var xmlHttpReg = null;
          if (window.ActiveXObject) {//如果是IE

              xmlHttpReg = new ActiveXObject(""Microsoft.XMLHTTP"");

          } else if (window.XMLHttpRequest) {

              xmlHttpReg = new XMLHttpRequest(); //实例化一个xmlHttpReg
          }

          //如果实例化成功,就调用open()方法,就开始准备向服务器发送请求
          if (xmlHttpReg != null) {
              xmlHttpReg.open(""get"", ""About.aspx"", true);1
               xmlHttpReg.send(null);
              xmlHttpReg.onreadystatechange = doResult; //设置回调函数

          }

          //回调函数
          //一旦readyState的值改变,将会调用这个函数,readyState=4表示完成相应

          //设定函数doResult()
          function doResult() {

              if (xmlHttpReg.readyState == 4) {//4代表执行完成


                  if (xmlHttpReg.status == 200) {//200代表执行成功
                      //将xmlHttpReg.responseText的值赋给ID为resText的元素
                      document.getElementById(""resText"").innerHTML = xmlHttpReg.responseText;


                  }
              }

          }


      }
     </script>
</head>
<body>

      <div id=""resText""></div>
      <form method=get action="""">
        <input type=""button"" value=""小胡子""  onclick=""ajax();""/>
      </form>
</body>
</html>"

ajax在jquery中的使用

$.ajax({
             type: ""GET"",
             url: ""test.json"",
             data: {username:$(""#username"").val(), content:$(""#content"").val()},
             dataType: ""json"",
             success: function(data){
                         $('#resText').empty();   //清空resText里面的所有内容
                         var html = ''; 
                         $.each(data, function(commentIndex, comment){
                               html += '<div class=""comment""><h6>' + comment['username']
                                         + ':</h6><p class=""para""' + comment['content']
                                         + '</p></div>';
                         });
                         $('#resText').html(html);
                      }
         });

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：返回纯文本字符串。"

ajax的5中状态

  1. 0 - (未初始化)还没有调用send()方法
  2. 1 - (载入)已调用send()方法，正在发送请求
  3. 2 - (载入完成)send()方法执行完成
  4. 3 - (交互)正在解析响应内容
  5. 4 - (完成)响应内容解析完成，可以在客户端调用了
对于上面的状态，其中“0”状态是在定义后自动具有的状态值，而对于成功访问的状态（得到信息）我们大多数采用“4”进行判断。

框架

sprint依赖注入的几种实现方式

1.Set注入

这是最简单的注入方式，假设有一个SpringAction，类中需要实例化一个SpringDao对象，那么就可以定义一个private的SpringDao成员变量，然后创建SpringDao的set方法（这是ioc的注入入口）

package com.bless.springdemo.action;
    public class SpringAction {
    //注入对象springDao
    private SpringDao springDao;
    //一定要写被注入对象的set方法
    public void setSpringDao(SpringDao springDao) {
        this.springDao = springDao;
    }

    public void ok(){
        springDao.ok();
    }
}

随后编写spring的xml文件，<bean>中的name属性是class属性的一个别名，class属性指类的全名，因为在SpringAction中有一个公共属性Springdao，所以要在<bean>标签中创建一个<property>标签指定SpringDao。<property>标签中的name就是SpringAction类中的SpringDao属性名，ref指下面<bean name="springDao"...>，这样其实是spring将SpringDaoImpl对象实例化并且调用SpringAction的setSpringDao方法将SpringDao注入：

<!--配置bean,配置后该类由spring管理-->
<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<!--(1)依赖注入,配置当前类中相应的属性-->
<property name="springDao" ref="springDao"></property>
</bean>
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

2.构造器注入

这种方式的注入是指带有参数的构造函数注入，看下面的例子，我创建了两个成员变量SpringDao和User，但是并未设置对象的set方法，所以就不能支持第一种注入方式，这里的注入方式是在SpringAction的构造函数中注入，也就是说在创建SpringAction对象时要将SpringDao和User两个参数值传进来

public class SpringAction {
    //注入对象springDao
    private SpringDao springDao;
    private User user;

    public SpringAction(SpringDao springDao,User user){
        this.springDao = springDao;
        this.user = user;
        System.out.println("构造方法调用springDao和user");
    }

    public void save(){
        user.setName("卡卡");
        springDao.save(user);
    }
}

在XML文件中同样不用<property>的形式，而是使用<constructor-arg>标签，ref属性同样指向其它<bean>标签的name属性：

<!--配置bean,配置后该类由spring管理-->
<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置-->
<constructor-arg ref="springDao"></constructor-arg>
<constructor-arg ref="user"></constructor-arg>
</bean>
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>
<bean name="user" class="com.bless.springdemo.vo.User"></bean>

解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：
下面是设置index，就是参数位置：

<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<constructor-arg index="0" ref="springDao"></constructor-arg>
<constructor-arg index="1" ref="user"></constructor-arg>
</bean>

另一种是设置参数类型：
<constructor-arg type="java.lang.String" ref=""/>

3.静态工厂的方法注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过”工程类.静态方法()”来获取对象，而是依然通过spring注入的形式获取

package com.bless.springdemo.factory;
import com.bless.springdemo.dao.FactoryDao;
import com.bless.springdemo.dao.impl.FactoryDaoImpl;
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;

public class DaoFactory {
    //静态工厂
    public static final FactoryDao getStaticFactoryDaoImpl(){
        return new StaticFacotryDaoImpl();
    }
}

同样看关键类，这里我需要注入一个FactoryDao对象，这里看起来跟第一种注入一模一样，但是看随后的xml会发现有很大差别

public class SpringAction {
    //注入对象
    private FactoryDao staticFactoryDao;

    public void staticFactoryOk(){
        staticFactoryDao.saveFactory();
    }
    //注入对象的set方法
    public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
        this.staticFactoryDao = staticFactoryDao;
    }
}

Spring的IOC配置文件，注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类，而是指向静态工厂DaoFactory，并且配置 factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法

<!--配置bean,配置后该类由spring管理-->
<bean name="springAction" class="com.bless.springdemo.action.SpringAction" >
<!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)-->
<property name="staticFactoryDao" ref="staticFactoryDao"></property>
</property>
</bean>
<!--(3)此处获取对象的方式是从工厂类中获取静态方法-->
<bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>

4.实例工厂的方法注入

实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法

public class DaoFactory {
    //实例工厂
    public FactoryDao getFactoryDaoImpl(){
        return new FactoryDaoImpl();
    }
}

public class SpringAction {
    //注入对象
    private FactoryDao factoryDao;

    public void factoryOk(){
    factoryDao.saveFactory();
    }

    public void setFactoryDao(FactoryDao factoryDao) {
    this.factoryDao = factoryDao;
    }
}



<!--配置bean,配置后该类由spring管理-->
<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
<!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)-->
<property name="factoryDao" ref="factoryDao"></property>
</bean>

<!--(4)此处获取对象的方式是从工厂类中获取实例方法-->
<bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>
<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>

5.总结

Spring IOC注入方式用得最多的是(1)(2)种，多写多练就会非常熟练。
另外注意：通过Spring创建的对象默认是单例的，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：
<bean name="..." class="..." scope="prototype">

三种注入方式比较

  • 接口注入：
    接口注入模式因为具备侵入性，它要求组件必须与特定的接口相关联，因此并不被看好，实际使用有限。

  • Setter 注入
    对于习惯了传统 javabean 开发的程序员，通过 setter 方法设定依赖关系更加直观。
    如果依赖关系较为复杂，那么构造子注入模式的构造函数也会相当庞大，而此时设值注入模式则更为简洁。
    如果用到了第三方类库，可能要求我们的组件提供一个默认的构造函数，此时构造子注入模式也不适用。

  • 构造器注入
    在构造期间完成一个完整的、合法的对象。
    所有依赖关系在构造函数中集中呈现。
    依赖关系在构造时由容器一次性设定，组件被创建之后一直处于相对“不变”的稳定状态。
    只有组件的创建者关心其内部依赖关系，对调用者而言，该依赖关系处于“黑盒”之中。

  • 总结
    Spring使用注入方式，为什么使用注入方式，这系列问题实际归结起来就是一句话，Spring的注入和IoC（本人关于IoC的阐述）反转控制是一回事。
    理论上：第三种注入方式（构造函数注入）在符合java使用原则上更加合理，第二种注入方式（setter注入）作为补充。
    实际上：我个人认为第二种注入方式（setter注入）可以取得更加直观的效果，在使用工作上有不可比拟的优势，所以setter注入依赖关系应用更加广泛。

Spring两大特性

反向控制(IoC)和面向切面编程(AOP)是Spring框架的两大特性

Hibernate工作原理及为什么要用？

原理：

  1. 读取并解析配置文件
  2. 读取并解析映射信息，创建SessionFactory
  3. 打开Sesssion
  4. 创建事务Transation
  5. 持久化操作
  6. 提交事务
  7. 关闭Session
  8. 关闭SesstionFactory

为什么要用：

  1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
  2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
  3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
  4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

struts2的执行流程

Struts 2框架本身大致可以分为3个部分：

  1. 核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
  2. 核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。
  3. 业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。

Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。基本简要流程如下：

  1. 客户端浏览器发出HTTP请求。
  2. 根据web.xml配置，该请求被FilterDispatcher接收。
  3. 根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。
  4. Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
  5. Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
  6. 返回HTTP响应到客户端浏览器。

mybatis里面#和$的区别

  1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。如：order by #user_id# ，如果传入的值是111,那么解析成sql时的值为order by ""111"", 如果传入的值是id，则解析成的sql为order by ""id""
  2. $将传入的数据直接显示生成在sql中。如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id, 如果传入的值是id，则解析成的sql为order by id.
  3. #方式能够很大程度防止sql注入。
  4. $方式无法防止Sql注入。
  5. $方式一般用于传入数据库对象，例如传入表名.
  6. 一般能用#的就别用$.MyBatis排序时使用order by 动态参数时需要注意，用$而不是#

数据库

事务的四大特性

  1. 原子性（Atomicity）
    　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，这和前面两篇博客介绍事务的功能是一样的概念，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

  2. 一致性（Consistency）
    　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

    　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

  3. 隔离性（Isolation）
    　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

    　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

    　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。

  4. 持久性（Durability）
    　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

数据库分页

Mysql:
SELECT COUNT(*) FROM foo WHERE b = 1;

SELECT a FROM foo WHERE b = 1 LIMIT 100,10;

oracle:
SELECT * FROM   
(  
SELECT A.*, ROWNUM RN   
FROM (SELECT * FROM TABLE_NAME) A   
WHERE ROWNUM <= 110  
)  
WHERE RN >= 100

ROWNUM只适用于小于或小于等于，如果进行等于判断，那么只能等于1，不能进行大于的比较

存储过程优点

  1. 执行速度更快 – 在数据库中保存的存储过程语句都是编译过的
  2. 允许模块化程序设计 – 类似方法的复用
  3. 提高系统安全性 – 防止SQL注入
  4. 减少网络流通量 – 只要传输存储过程的名称

sql性能优化

1.对查询进行优化，要尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。

2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：

select id from t where num is null
最好不要给数据库留NULL，尽可能的使用 NOT NULL填充数据库.

备注、描述、评论之类的可以设置为 NULL，其他的，最好不要使用NULL。

不要以为 NULL 不需要空间，比如：char(100) 型，在字段建立时，空间就固定了， 不管是否插入值（NULL也包含在内），都是占用 100个字符的空间的，如果是varchar这样的变长字段， null 不占用空间。

可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：

select id from t where num = 0

3.应尽量避免在 where 子句中使用 != 或 <> 操作符，否则将引擎放弃使用索引而进行全表扫描。

4.应尽量避免在 where 子句中使用 or 来连接条件，如果一个字段有索引，一个字段没有索引，将导致引擎放弃使用索引而进行全表扫描，如：

select id from t where num=10 or Name = 'admin'
可以这样查询：

select id from t where num = 10
union all
select id from t where Name = 'admin'

5.in 和 not in 也要慎用，否则会导致全表扫描，如：

select id from t where num in(1,2,3)
对于连续的数值，能用 between 就不要用 in 了：

select id from t where num between 1 and 3
很多时候用 exists 代替 in 是一个好的选择：

select num from a where num in(select num from b)
用下面的语句替换：

select num from a where exists(select 1 from b where num=a.num)

6.下面的查询也将导致全表扫描：

select id from t where name like ‘%abc%’
若要提高效率，可以考虑全文检索。

7.如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然 而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：

select id from t where num = @num
可以改为强制查询使用索引：

select id from t with(index(索引名)) where num = @num
应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：

select id from t where num/2 = 100
应改为:

select id from t where num = 100*2

9.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：

select id from t where substring(name,1,3) = ’abc’       -–name以abc开头的id
select id from t where datediff(day,createdate,’2005-11-30′) = 0    -–‘2005-11-30’    --生成的id
应改为:

select id from t where name like 'abc%'
select id from t where createdate >= '2005-11-30' and createdate < '2005-12-1'

10.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

11.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如需要生成一个空表结构：

select col1,col2 into #t from t where 1=0
这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：

create table #t(…)

13.Update 语句，如果只更改1、2个字段，不要Update全部字段，否则频繁调用会引起明显的性能消耗，同时带来大量日志。

14.对于多张大数据量（这里几百条就算大了）的表JOIN，要先分页再JOIN，否则逻辑读会很高，性能很差。

15.select count(*) from table；这样不带任何条件的count会引起全表扫描，并且没有任何业务意义，是一定要杜绝的。

16.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

17.应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

18.尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连 接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

19.尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

20.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

21.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

22. 避免频繁创建和删除临时表，以减少系统表资源的消耗。临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件， 最好使用导出表。

23.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

24.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

25.尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。

27.与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时 间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

29.尽量避免大事务操作，提高系统并发能力。

30.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

UNION 和UNION ALL的区别

  • UNION ALL是直接连接，取到得是所有值，记录可能有重复 UNION 是取唯一值，记录没有重复效率，UNION和UNION ALL关键字都是将两个结果集合并为一个，但这两者从使用和效率上来说都有所不同。
  • 对重复结果的处理：UNION在进行表链接后会筛选掉重复的记录，UNION All不会去除重复记录。
  • 对排序的处理：UNION 将会按照字段的顺序进行排序；UNION ALL只是简单的将两个结果合并后就返回。
    从效率上说，UNION ALL 要比UNION 快很多，所以，如果可以确认合并的两个结果集中不包含重复数据且不需要排序时的话，那么就使用UNION ALL。
来自日本的AD钙奶
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
日语java面试问题集
07-10
java对日外包面试题
RecyclerView源码解析
黎程雨的博客
10-09 1808
基础 RecyclerView相对于以前的ListView来说，更加灵活。其所拆分出来的各个类的分工更加明确，很好地体现了我们经常所说的职责单一原则。我们这里先对其中使用到的类进行一下讲解 LayoutManager：RecyclerView的布局管理者，主要负责对于RecyclerView子View的测量和布局工作。 RecyclerView.Recycler：缓存的核心类。RecyclerView强大的缓存能力都是基于这个类来实现的。是缓存的核心工具类。 Adapter：Adapter的基类。负责将V
再有人问你MySQL索引原理，就把这篇文章甩给他！
HollisChuang's Blog
02-22 819
△Hollis, 一个对Coding有着独特追求的人△这是Hollis的第335篇原创分享作者 lzyz1992来源 l Hollis（ID：hollischuang）索引，可能让好...
计算机科学中索引值为什么从0开始？
丛晓男
03-03 7020
    计算机科学中的索引一般都从0开始，比如数组等。之所以这样，有这深刻的原因。    通过例子来说明这个问题，假如要存100个人在数组中，如果用最小索引为1，则最大索引为100，如果最小索引为0，则最大索引为99，99为两位数，而100为三位数，这就体现出从0开始的优点。    计算机中要求的是二进制，假如有四个汽车：索引从1开始的十进制为：（1，2，3，4），对应的二进制为（1，
3、JDBC小疑惑
AphroditeLADY的博客
10-31 194
1、为什么使用Class.forName而不是DriverManager.registerDriver加载数据库驱动？2、为什么调用Class.forName()，却不调用newInstance()创建实例？3、为什么使用preparedStament而不是使用Statement？
常见Java面试问题.rar
10-03
以下是一些常见的Java面试问题及其详细解答： 1. **Java内存模型与垃圾回收** - Java内存分为堆内存和栈内存。栈存储方法和基本类型变量，而堆用于存储对象实例。垃圾回收机制自动管理内存，通过可达性分析来判断...
java 面试常见问题整理
04-15
Java 泛型了解么？什么是类型擦除？介绍一下常用的通配符？ 常用的通配符有哪些？ 你的项目中哪里用到了泛型？ 反射 何为反射？ 反射机制优缺点 反射的应用场景 注解 异常 Exception 和 Error 有什么区别？ Checked ...
java 常见面试问题汇总
05-30
1、Iterator 怎么使用？有什么特点？ 2、Servlet生命周期内调用的方法过程？ 3、阐述静态变量和实例变量的区别。
java面试常见问题.docx
最新发布
07-17
Java面试中常见的问题和答案涉及多个方面，包括Java基础、多线程、集合框架、JVM、数据库连接等。以下是一些常见问题及其答案： Java基础 Java的主要特性是什么？ 答案：Java的主要特性包括面向对象、平台无关性...
Java面试常见面试题
03-06
5. **JVM**：Java虚拟机的内存管理、垃圾收集机制、性能优化、类加载过程、类加载器、JVM调优工具等都是面试中常见的问题。理解JVM的工作原理对于优化程序性能至关重要。 6. **MySQL**：数据库相关面试题涵盖SQL...
日本公司java面试问题集
09-22
日本公司java面试问题集。非常实用。适用于日企、软件外包、赴日软件开发。（日文）
跟随小破站学习java SE第十六天
Mars_LJ的博客
10-14 250
/** * 一、集合框架的概述 * * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中） * * 2.1 数组在存储多个数据方面的特点： * > 一旦初始化以后，其长度就确定了。 * > 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。 * 比如：String[] arr;int[] ar.
记一次日本公司的Java面试
m0_67393413的博客
07-23 978
转载于https//www.cnblogs.com/qulingyuan/p/9986458.html。集合有哪几种，具体说一下，ArrayList和List是什么关系。public和private修饰词的区别。讲一下Java的多态。数组的排序函数是什么。
ArrayList和索引位置相关方法
abc1498880402的博客
03-12 5111
import java.util.ArrayList; import java.util.List; public class ArrayList和索引位置相关方法 { public static void main(String[] args) { List&lt;String&gt; l=new ArrayList&lt;&gt;(); l.add("A"); l.add(...
arraylist索引从几开始_Java 问答：用 ArrayList 还是 LinkedList
weixin_39836063的博客
01-18 1349
(给ImportNew加星标，提高Java技能)编译：ImportNew/唐尤华stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist-in-java问题：通常我会这么定义列表：List names = new ArrayList<>();names类型使用List接口，那么具体实现该如...
[HR面试] 65个最常见的面试问题与技巧性答复
chenglinhust的专栏
10-04 3481
[HR面试] 65个最常见的面试问题与技巧性答复 1、请你自我介绍一下你自己？ 回答提示：一般人回答这个问题过于平常，只说姓名、年龄、爱好、工作经验，这些在简历上都有。其实，企业最希望知道的是求职者能否胜任工作，包括：最强的技能、最深入研究的知识领域、个性中最积极的部分、做过的最成功的事，主要的成就等，这些都可以和学习无关，也可以和学习有关，但要突出积极的个性和做事
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值