Java必备知识

***************Java必备知识***************

 

1、java的基本数据类型

char、byte、short、int、long、float、double、boolean

 

 

2、作用域public,private,protected,以及不写时的区别？

 

public：

具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。

protected：

主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西

default：

有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。

private：

访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

 

3、Static Nested Class 和 Inner Class的不同

 

Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

 

/**

 * 扑克类（一副扑克）

 * @author 骆昊

 *

 */public class Poker {private static String[] suites = {"黑桃", "红桃", "草花", "方块"};

    private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

 

    private Card[] cards;

 

    /**

     * 构造器

     *

     */public Poker() {

        cards = new Card[52];

        for(int i = 0; i < suites.length; i++) {

            for(int j = 0; j < faces.length; j++) {

                cards[i * 13 + j] = new Card(suites[i], faces[j]);

            }

        }

    }

 

    /**

     * 洗牌 （随机乱序）

     *

     */public void shuffle() {

        for(int i = 0, len = cards.length; i < len; i++) {

            int index = (int) (Math.random() * len);

            Card temp = cards[index];

            cards[index] = cards[i];

            cards[i] = temp;

        }

    }

 

    /**

     * 发牌

     * @param index 发牌的位置

     *

     */public Card deal(int index) {

        return cards[index];

    }

 

    /**

     * 卡片类（一张扑克）

     * [内部类]

     * @author 骆昊

     *

     */public class Card {private String suite;   // 花色private int face;       // 点数public Card(String suite, int face) {

            this.suite = suite;

            this.face = face;

        }

 

        @Overridepublic String toString() {

            String faceStr = "";

            switch(face) {

            case 1: faceStr = "A"; break;

            case 11: faceStr = "J"; break;

            case 12: faceStr = "Q"; break;

            case 13: faceStr = "K"; break;

            default: faceStr = String.valueOf(face);

            }

            return suite + faceStr;

        }

    }

}

 

测试代码：

 

class PokerTest {

 

    public static void main(String[] args) {

        Poker poker = new Poker();

        poker.shuffle();                // 洗牌

        Poker.Card c1 = poker.deal(0);  // 发第一张牌// 对于非静态内部类Card// 只有通过其外部类Poker对象才能创建Card对象

        Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌

 

        System.out.println(c1);     // 洗牌后的第一张

        System.out.println(c2);     // 打印: 红心A

    }

}

 

面试题 - 下面的代码哪些地方会产生编译错误？

 

class Outer {

 

    class Inner {}

 

    public static void foo() { new Inner(); }

 

    public void bar() { new Inner(); }

 

    public static void main(String[] args) {

        new Inner();

    }

}

 

注意：Java中非静态内部类对象的创建要依赖其外部类对象，上面的面试题中foo和main方法都是静态方法，静态方法中没有this，也就是说没有所谓的外部类对象，因此无法创建内部类对象，如果要在静态方法中创建内部类对象，可以这样做：

 

    new Outer().new Inner();

---------------------------静态内部类的用法------------------------------------------------------------------

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import net.sf.json.JsonConfig;

import net.sf.json.processors.JsonValueProcessor;

public class JsonUtil {

 

    public static final String obj2Json(Object obj, String formatStr) {

        String jsonStr = "[]";

        if (CommonUtil.isEmpty(obj)) {

            LoggerHelper.warn("传入的Java对象为空,不能将其序列化为Json格式");

        } else {

            JsonConfig cfg = new JsonConfig();

            cfg.registerJsonValueProcessor(java.sql.Timestamp.class, new JsonValueProcessorImp(formatStr));

            cfg.registerJsonValueProcessor(java.util.Date.class, new JsonValueProcessorImp(formatStr));

            cfg.registerJsonValueProcessor(java.sql.Date.class, new JsonValueProcessorImp(formatStr));

            if (obj instanceof ArrayList) {

                JSONArray jsonArray = JSONArray.fromObject(obj, cfg);

                jsonStr = jsonArray.toString();

            } else {

                JSONObject jsonObject = JSONObject.fromObject(obj, cfg);

                jsonStr = jsonObject.toString();

            }

        }

        

        return jsonStr;

    }

    

     static class JsonValueProcessorImp implements JsonValueProcessor {

 

        /**

         * 默认的格式

         */

        private String format = "yyyy-MM-dd HH:mm:ss";

 

        public JsonValueProcessorImp() {

        };

 

        public JsonValueProcessorImp(String format) {

            this.format = format;

        }

 

        /**

         * 格式化数组

         */

        public Object processArrayValue(Object value, JsonConfig jsonConfig) {

            String[] obj = {};

            if (value instanceof java.util.Date[]) {

                SimpleDateFormat sf = new SimpleDateFormat(format);

                java.util.Date[] dates = (java.util.Date[]) value;

                obj = new String[dates.length];

                for (int i = 0; i < dates.length; i++) {

                    obj[i] = sf.format(dates[i]);

                }

            }

            if (value instanceof Timestamp[]) {

                SimpleDateFormat sf = new SimpleDateFormat(format);

                Timestamp[] dates = (Timestamp[]) value;

                obj = new String[dates.length];

                for (int i = 0; i < dates.length; i++) {

                    obj[i] = sf.format(dates[i]);

                }

            }

            if (value instanceof java.sql.Date[]) {

                SimpleDateFormat sf = new SimpleDateFormat(format);

                java.sql.Date[] dates = (java.sql.Date[]) value;

                obj = new String[dates.length];

                for (int i = 0; i < dates.length; i++) {

                    obj[i] = sf.format(dates[i]);

                }

            }

            return obj;

        }

 

        /**

         * 格式化单一对象

         */

        public Object processObjectValue(String key, Object value,

                JsonConfig jsonConfig) {

            if(CommonUtil.isEmpty(value))

                return "";

            if (value instanceof Timestamp) {

                String str = new SimpleDateFormat(format).format((Timestamp) value);

                return str;

            } else if (value instanceof java.util.Date) {

                String str = new SimpleDateFormat(format).format((java.util.Date) value);

                return str;

            } else if (value instanceof java.sql.Date) {

                String str = new SimpleDateFormat(format).format((java.sql.Date) value);

                return str;

            }

            return value.toString();

        }

 

        public String getFormat() {

            return format;

        }

 

        public void setFormat(String format) {

            this.format = format;

        }

 

    }

}

 

4、接口与抽象类的区别？

 

很多常见的面试题都会出诸如抽象类和接口有什么区别，什么情况下会使用抽象类和什么情况你会使用接口这样的问题。本文我们将仔细讨论这些话题。

在讨论它们之间的不同点之前，我们先看看抽象类、接口各自的特性。

抽象类

抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例：

1 2 3 4 5 6 7 8 9

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {     // abstract method     abstract void service(ServletRequest req, ServletResponse res);       void init() {         // Its implementation     }     // other method related to Servlet }

当HttpServlet类继承GenericServlet时，它提供了service方法的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class HttpServlet extends GenericServlet {     void service(ServletRequest req, ServletResponse res) {         // implementation     }       protected void doGet(HttpServletRequest req, HttpServletResponse resp) {         // Implementation     }       protected void doPost(HttpServletRequest req, HttpServletResponse resp) {         // Implementation     }       // some other methods related to HttpServlet }

接口

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。以Externalizable接口为例：

1 2 3 4 5 6

public interface Externalizable extends Serializable {       void writeExternal(ObjectOutput out) throws IOException;       void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; }

当你实现这个接口时，你就需要实现上面的两个方法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Employee implements Externalizable {       int employeeId;     String employeeName;       @Override     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {         employeeId = in.readInt();         employeeName = (String) in.readObject();       }       @Override     public void writeExternal(ObjectOutput out) throws IOException {           out.writeInt(employeeId);         out.writeObject(employeeName);     } }

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

 

 

5、Java中的异常有哪几类？分别怎么使用？

 

Throwable包含了错误(Error)和异常(Excetion两类)

Exception又包含了运行时异常(RuntimeException, 又叫非检查异常)和非运行时异常(又叫检查异常)

(1) Error是程序无法处理了, 如果OutOfMemoryError、OutOfMemoryError等等, 这些异常发生时, java虚拟机一般会终止线程 .

(2) 运行时异常都是RuntimeException类及其子类,如 NullPointerException、IndexOutOfBoundsException等, 这些异常是不检查的异常, 是在程序运行的时候可能会发生的, 所以程序可以捕捉, 也可以不捕捉. 这些错误一般是由程序的逻辑错误引起的, 程序应该从逻辑角度去尽量避免.

(3) 检查异常是运行时异常以外的异常, 也是Exception及其子类, 这些异常从程序的角度来说是必须经过捕捉检查处理的, 否则不能通过编译. 如IOException、SQLException等

 

两者的区别

        非检查异常表示无法让程序恢复运行的异常，导致这种异常的原因通常是由于执行了错误的操作。一旦出现错误，建议让程序终止。

受检查异常表示程序可以处理的异常。如果抛出异常的方法本身不处理或者不能处理它，那么方法的调用者就必须去处理该异常，否则调用会出错，连编译也无法通过。

对于运行异常，建议不要用 try...catch...捕获处理，应该在程序开发调试的过程中尽量的避免，当然有一些必须要处理的，自己知道了那个部分会出现异常，而这种异常你要把它处理的你想要的结果，例如：空值处理

 

6、常用的集合类有哪些？比如List如何排序？

 

Set、List、Map.png

Java中常用的集合类

 

 

对于集合，大家都不陌生了，常见的集合接口Set、List、Map等，其中Set和List继承自Collection。

 

 

Collection是一组对象的集合，而Map存储的方式不一样，他是以键值对的形式存放多个对象的。

 

 

Set和List又有区别，Set中的元素无序且不重复，而List中的元素则是有序且允许重复的。

 

 

Set、List、Map都是接口类，定义的是规范，具体使用时，还是需要其实现类的实例。一般我们见得比较多的就是HashSet、TreeSet、ArrayList、LinkedList、HashMap等，另外还有Vector、HashTable什么的，这个涉及了多线程中的线程安全以及性能问题，现在出场率比较低了。

 

 

Set：HashSet、TreeSet

 

 

说实话，就个人经历而言，Set的使用比较少，仅在对Map使用Entry的方式进行遍历的时候，用到过Set的实现类。

 

 

关于去重：Set的中判断放入元素是否重复，都是基于对象的equals()方法的返回值来实现的。

 

 

关于顺序和排序：其实作为无序的Set，本身应该是不具备排序功能的，因为根本就没有顺序。

HashSet对于元素的存储位置是取决放入对象的HashCode，是散列形式的；另外，还有一个名叫LinkedHashSet的实现类，除了使用HashCode来决定元素位置之外，同时还是用了链表来维护元素的次序(Linked)，因此对其插入元素时，看起来是有序的；

TreeSet，这个实现类没有接触过，以下资料为网络摘抄：

 

 

TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。

向TreeSet中加入的应该是同一个类的对象。TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0

自然排序

自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0。

定制排序

自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。

比较大小的2个接口.jpg

从上面的引文可以看出，对于集合的排序可以使用元素本身比较大小的方法(前提是实现了Comparable接口的对象)；或者去实现Comparator接口的compare()方法来自定义一套比较大小的逻辑。

 

 

List：ArrayList、LinkedList

 

 

这2个应该是很常见的集合实现类了，一个是基于数组的原理存储元素，一个是使用链表的形式存储元素，具体的区别不在赘述。

总之，List是有顺序的，因此List肯定是可以排序的。考虑到这一点，Java创造者们早就给我们准备好了趁手的工具——Collections，长得有点像Set和List的お父さん(父亲)，其实根本不是一个世界的人(类)；

 

 

关于Collections

这是官方提供的一个处理集合的工具方法的集合，本人最熟悉的就是他的sort()方法，对，就是这个排序用的方法，下面我们就来仔细看看这个便利的方法吧。

 

 

sort()方法排序的本质其实也是借助Comparable接口和Comparator接口的实现，一般有2种用法：

1、直接将需要排序的list作为参数传入，此时list中的对象必须实现了Comparable接口，然后sort会按升序的形式对元素进行排序；

2、传入list作为第一个参数，同时追加一个Comparator的实现类作为第二个参数，然后sort方法会根据Comparator接口的实现类的逻辑，按升序进行排序；

这里可能有朋友会问，为什么都是升序没有降序。

其实所谓升或者降都是你自己规定的，sort()方法只是将比较结果为-1的放前面，0的放中间，1的放后面；如果你想实现降序排列，那就在Comparator方法的实现类中，逆转compare的返回结果就行了。

 

 

Map：HashMap

 

 

看到前面的Set和List的实现类里面前缀都有Array(数组实现)，Hash(哈希)，Linked(链表)这几种存储方式的实现，我脑洞了一下Map是不是也有ArrayMap呢？

 

 

没有直接百度，而是直接在IDE中去new ArrayMap<K,V>()，发现编译通不过，看来1.7的JDK是不支持了。

 

 

然后开启度娘模式发现，居然Android里面有提到，看来我也不算脑洞了。

 

 

HashMap算是开发中使用得最多的了，很方法的键值对形式(内在是一个一个散列分布的Entry<K，V>，因此可是使用Set<Entry<K，V>>的方式遍历)；

 

 

本人对于HashMap基本上遍历多，排序少，从其前缀的Hash可以看出，其键值对的存放应该也是根据key的HashCode进行存放；因此，HashMap本身应该是无法排序的，所以跟Set一样，官方也没有提供对应的排序方法。

 

 

不过，我们可以进行DIY，譬如把HashMap中的key存入可排序的list，进行排序，然后遍历的时候，通过list或许到key之后，再从Map获取值这样就按照key进行排序了。

如果要按照value进行排序就复杂一点，可以把Entry对象放进list，然后自己实现比较器，根据value进行排序。

嗯，还有更多更快更优的方法，大家都可以发散思维。

 

 

另外提一嘴，Map中还有TreeMap和LinkedHashMap，其特点就跟Set中的那两位一样一样的。

 

 

写在文尾的体会

 

 

不管是Set、List还是Map，根据其不同的特性，有不同的应用场景。

 

 

对于排序的问题，根据各种实现类的前缀，了解实现中的元素存储方式，可以知道是有序还是无序。由此，可以知道排序是使用官方工具，还是需要自行实现对应的方法。

 

 

不论官方还是DIY，总之要继续排序的基本原理都是借助Comparable接口和Comparator接口的实现，那么不论待处理的集合是怎样的，我们都有办法应对了。

 

 

7、ArrayList和LinkedList内部实现、区别、使用场景

 

 

ArrayList：内部使用数组的形式实现了存储，实现了RandomAccess接口，利用数组的下面进行元素的访问，因此对元素的随机访问速度非常快。

因为是数组，所以ArrayList在初始化的时候，有初始大小10，插入新元素的时候，会判断是否需要扩容，扩容的步长是0.5倍原容量，扩容方式是利用数组的复制，因此有一定的开销；

另外，ArrayList在进行元素插入的时候，需要移动插入位置之后的所有元素，位置越靠前，需要位移的元素越多，开销越大，相反，插入位置越靠后的话，开销就越小了，如果在最后面进行插入，那就不需要进行位移；

 

LinkedList：内部使用双向链表的结构实现存储，LinkedList有一个内部类作为存放元素的单元，里面有三个属性，用来存放元素本身以及前后2个单元的引用，另外LinkedList内部还有一个header属性，用来标识起始位置，LinkedList的第一个单元和最后一个单元都会指向header，因此形成了一个双向的链表结构。

LinkedList的元素并不需要连续存放，但是每个存放元素的单元比元素本身需要更大的空间，因为LinkedList对空间的要求比较大，但是扩容的时候不需要进行数组复制，因此没有这一环节的开销。

 

但是，是的，就是但是，也正因为这样，LinkedList的随机访问速度惨不忍睹，因为无论你要访问哪一个元素，都需要从header起步正向或反向(根据元素的位置进行的优化)的进行元素遍历；

由此可见，ArrayList适合需要大量进行随机访问的场景；而LinkedList则适合需要在集合首尾进行增删的场景。

 

8、内存溢出是怎么回事？请举一个例子？

 

Java内存溢出（内存泄漏）

内存溢出（out of memory）通俗理解就是内存不够，在计算机程序中通俗的理解就是开辟的内存空间得不到释放。Java虽然提供了垃圾回收机制，但是并没有保证我们所写的代码就不存在没存溢出的可能。下面使用一个小案例作为演示，这也是我们新手开发过程中可能遇见的问题啦，好记性不如烂笔头。

class MyList{

 

/*

* 此处只为掩饰效果，并没有进行封装之类的操作

*

* 将List集合用关键字 static 声明，这时这个集合将不属于任何  MyList 对象，而是一个类成员变量

*

*/

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

 

}

 

class Demmo{

public static void main(String[] args) {

MyList list = new MyList();

list.list.add("123456");

// 此时即便我们将 list指向null，仍然存在内存泄漏，因为MyList中的list是静态的，它属于类所有而不属于任何特定的实例

list = null;

}

}

上面的情况如果想要防止内存溢出，那么我们应该做的是，在每次使用完后调用List集合中的remove方法，将集合中无用的元素清除。

还有就是，既然是static变量就别要使用类对象去调用啦，使用实例对象调用static变量可能引发一些意想不到的后果哦！新手一定要注意啦！

 

9、==和equals的区别？

 

在java程序设计中，经常需要比较两个变量值是否相等。例如

1、简单数据类型比较

a = 10;

b = 10;

if(a == b){

   //写要执行的代码

}

2、引用数据类型比较

ClassA a = new ClassA("abc");

ClassB b = new ClassB("abc");

if(a == b){

//写要执行的代码

}

显然在例1中 a == b的值为true，例2中a == b值为false

你应该有一些java基础吧，下面我用int类型和它的封装类Integer来说明简单类型和封装类型进行比较时的区别：

==和equals()的用法

先看一段代码：

public class TestEqual{

      public static void main(String [ ] args){

            //简单类型比较

       int a = 100;

            int b = 100;

 

            System.out.println("a == b?" + (a == b));

           //引用类型比较

       Integer c = new Integer(100);

            Integer d = new Integer(100);

 

           System.out.println("c == d?" + (c == d));           

   }

}

运行该程序，会打印出以下信息：

a == b? true

c == b? false

可以看出，在引用类型比较中，虽然用了同一个参数“100”来构造两个变量，但他们仍然不同。

why??

要知道，对于这两个引用类型变量c和d，他们指向的是两个不同的对象（只不过两个对象的值都是100），因为是指向两个对象，所以比较这两个变量会得到false的值。

注意啦，重要结论：

对于引用类型变量，运算符“==”比较的是两个变量是否引用同一对象。

 

那么如何比较对象的值是否相等呢？

在java中提供了equals()方法用于比较对象的值。我们把上面引用类型部分的程序稍作修改：

 

Integer c = new Interger(100);

Integer d = new Interger(100);

System.out.println("c equals d?" + (c.equals(d) ));

 

运行后可得一个true，这是因为，方法equals()进行的是“深层比较”，他会去比较两个对象的值是否相等。

 

如果你想多学一点，一定会问：“这个可爱的equals()方法是由谁来实现的呢？”

我们知道，java中所有类的父类是Object类，在Object中，已经定义了一个equals()方法，但是这个默认的equals()方法实际上也只是测试两个变量引用是否指向同一对象（即与那个可爱的 == 功能一样）。所以它并不一定能得到你所期望的效果。所以我们还经常需要自己将定义的类（就是上面的TestEqual）中的equals()进行覆盖。像Integer封装类就已经覆盖了Object中的equals()方法，直接可以拿来比较引用类型c和d指向的对象的值。

 

好了，相信你一定耐心地看到了这里，我们来总结一下

== 和equals()两种比较方法，在使用时要注意：

1、如果测试两个简单类型的数值是否相等，则一定要用“==”来比较；

2、如果要比较两个引用变量对象的值是否相等，则要用对象的equals()方法进行比较；

3、如果需要比较两个引用变量是否指向同一对象，则使用“==”来进行比较；

还有，对于自定义的类，应该根据情况覆盖其父类或Object类中的equals()方法，否则默认的equals()方法功能与“==”相同。

 

10、hashCode方法的作用？

 

有许多人学了很长时间的Java，但一直不明白hashCode方法的作用，

我来解释一下吧。首先，想要明白hashCode的作用，你必须要先知道Java中的集合。　　

总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。

你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。

那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？

这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。

也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。   

于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。

哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法，那需要更多的文章篇幅，我在这里就不介绍了。

初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。  

这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。

如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，

就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。

所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。  

所以，Java对于eqauls方法和hashCode方法是这样规定的：

1、如果两个对象相同，那么它们的hashCode值一定要相同；

2、如果两个对象的hashCode相同，它们并不一定相同    

上面说的对象相同指的是用eqauls方法比较。   你当然可以不按要求去做了，但你会发现，相同的对象可以出现在Set集合中。同时，增加新元素的效率会大大下降。

 

11、NIO是什么？适用于何种场景？

 

NIO是为了弥补IO操作的不足而诞生的，NIO的一些新特性有：非阻塞I/O，选择器，缓冲以及管道。管道（Channel），缓冲（Buffer） ，选择器（ Selector）是其主要特征。

 

概念解释：

Channel——管道实际上就像传统IO中的流，到任何目的地(或来自任何地方)的所有数据都必须通过一个 Channel 对象。一个 Buffer 实质上是一个容器对象。

Selector——选择器用于监听多个管道的事件，使用传统的阻塞IO时我们可以方便的知道什么时候可以进行读写，而使用非阻塞通道，我们需要一些方法来知道什么时候通道准备好了，选择器正是为这个需要而诞生的。

NIO和传统的IO有什么区别呢?

1,IO是面向流的，NIO是面向块（缓冲区）的。

IO面向流的操作一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。，导致了数据的读取和写入效率不佳；

NIO面向块的操作在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多，同时数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。通俗来说，NIO采取了“预读”的方式，当你读取某一部分数据时，他就会猜测你下一步可能会读取的数据而预先缓冲下来。

2，IO是阻塞的，NIO是非阻塞的。

对于传统的IO，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。

而对于NIO，使用一个线程发送读取数据请求，没有得到响应之前，线程是空闲的，此时线程可以去执行别的任务，而不是像IO中那样只能等待响应完成。

NIO和IO适用场景

NIO是为弥补传统IO的不足而诞生的，但是尺有所短寸有所长，NIO也有缺点，因为NIO是面向缓冲区的操作，每一次的数据处理都是对缓冲区进行的，那么就会有一个问题，在数据处理之前必须要判断缓冲区的数据是否完整或者已经读取完毕，如果没有，假设数据只读取了一部分，那么对不完整的数据处理没有任何意义。所以每次数据处理之前都要检测缓冲区数据。

那么NIO和IO各适用的场景是什么呢？

如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，这时候用NIO处理数据可能是个很好的选择。

而如果只有少量的连接，而这些连接每次要发送大量的数据，这时候传统的IO更合适。使用哪种处理数据，需要在数据的响应等待时间和检查缓冲区数据的时间上作比较来权衡选择。

通俗解释

最后，对于NIO和传统IO，有一个网友讲的生动的例子：

以前的流总是堵塞的，一个线程只要对它进行操作，其它操作就会被堵塞，也就相当于水管没有阀门，你伸手接水的时候，不管水到了没有，你就都只能耗在接水（流）上。

nio的Channel的加入，相当于增加了水龙头（有阀门），虽然一个时刻也只能接一个水管的水，但依赖轮换策略，在水量不大的时候，各个水管里流出来的水，都可以得到妥

善接纳，这个关键之处就是增加了一个接水工，也就是Selector，他负责协调，也就是看哪根水管有水了的话，在当前水管的水接到一定程度的时候，就切换一下：临时关上当

前水龙头，试着打开另一个水龙头（看看有没有水）。

当其他人需要用水的时候，不是直接去接水，而是事前提了一个水桶给接水工，这个水桶就是Buffer。也就是，其他人虽然也可能要等，但不会在现场等，而是回家等，可以做

其它事去，水接满了，接水工会通知他们。

这其实也是非常接近当前社会分工细化的现实，也是统分利用现有资源达到并发效果的一种很经济的手段，而不是动不动就来个并行处理，虽然那样是最简单的，但也是最浪费

资源的方式。

 

12、HashMap实现原理，如何保证HashMap的线程安全？

Java HashMap 是非线程安全的。

在多线程条件下，容易导致死循环，具体表现为CPU使用率100%。因此多线程环境下保证 HashMap 的线程安全性，主要有如下几种方法：

 

使用 java.util.Hashtable 类，此类是线程安全的。

使用 java.util.concurrent.ConcurrentHashMap，此类是线程安全的。

使用 java.util.Collections.synchronizedMap() 方法包装 HashMap object，得到线程安全的Map，并在此Map上进行操作。

自己在程序的关键方法或者代码段加锁，保证安全性，当然这是严重的不推荐。

 

这里重点分析下上面列举的几种方法实现并行安全性的原理：

 

（一）java.util.Hashtable类：类的主要数据结构如下：

    

Java代码  收藏代码

    /** 

     * The hash table data. 

     */  

    private transient Entry[] table;  

  

private static class Entry<K,V> implements Map.Entry<K,V> {  

    int hash;  

    K key;  

    V value;  

    Entry<K,V> next;  

     

       可见，Hashtable 的实现是一个数组，每个数组元素是一个LinkList结构，因此类的数据实际上保存在一个散列表中。这个实现和 HashMap 的实现是一致的。数据结构如下：

 

 

      那么Hashtable如何保证线程安全性的哪？下面是 Hashtable的源码：

 

Java代码  收藏代码

public synchronized V get(Object key) {  

    Entry tab[] = table;  

    …… //此处省略，具体的实现请参考 jdk实现  

    }  

  

public synchronized V put(K key, V value) {  

    …… //具体实现省略，请参考jdk实现  

    }  

  

  

public synchronized V remove(Object key) {  

    …… //具体实现省略，请参考jdk实现  

    }  

  

     

    public synchronized void putAll(Map<? extends K, ? extends V> t) {  

        for (Map.Entry<? extends K, ? extends V> e : t.entrySet())  

            put(e.getKey(), e.getValue());  

    }  

  

  

    public synchronized void clear() {  

    …… //具体实现省略，请参考jdk实现  

    }  

     上面是 Hashtable 提供的几个主要方法，包括 get(), put(), remove() 等。注意到每个方法本身都是 synchronized 的，不会出现两个线程同时对数据进行操作的情况，因此保证了线程安全性，但是也大大的降低了执行效率。因此是不推荐的。

 

 

（二）使用 java.util.Collections.synchronizedMap(Map<K,V>) 方法进行封装。 方法源代码如下：

 

Java代码  收藏代码

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {  

    return new SynchronizedMap<K,V>(m);  

    }  

  

  

private static class SynchronizedMap<K,V>  

    implements Map<K,V>, Serializable {  

    // use serialVersionUID from JDK 1.2.2 for interoperability  

    private static final long serialVersionUID = 1978198479659022715L;  

  

    private final Map<K,V> m;     // Backing Map  

        final Object      mutex;    // Object on which to synchronize  

  

    SynchronizedMap(Map<K,V> m) {  

            if (m==null)  

                throw new NullPointerException();  

            this.m = m;  

            mutex = this;  

        }  

  

    SynchronizedMap(Map<K,V> m, Object mutex) {  

            this.m = m;  

            this.mutex = mutex;  

        }  

  

    public int size() {  

        synchronized(mutex) {return m.size();}  

        }  

    public boolean isEmpty(){  

        synchronized(mutex) {return m.isEmpty();}  

        }  

    public boolean containsKey(Object key) {  

        synchronized(mutex) {return m.containsKey(key);}  

        }  

       从实现源代码可以发现，其封装的本质和 Hashtable 的实现是完全一致的，即对原Map本身的方法进行加锁，加锁的对象或者为外部指定共享对象mutex，或者为包装后的线程安全的Map本身。Hashtable 可以理解为 SynchronizedMap mutex=null 时候的特殊情况。因此这种同步方式的执行效率也是很低的。

   

        既然已经有了Hashtable， 为什么还需要Collections 提供的这种静态方法包装哪？很简单，这种包装是Java Collection Framework提供的统一接口，除了用于 HashMap 外，还可以用于其他的Map。当然 除了对Map进行封装，Collections工具类还提供了对 Collection（比如Set，List）的线程安全实现封装方法，具体请参考 java.util.Colletions 实现，其原理和 SynchronizedMap 是一致的。

 

（三） 使用 java.util.concurrent.ConcurrentHashMap 类。这是 HashMap 的线程安全版，同 Hashtable 相比，ConcurrentHashMap 不仅保证了访问的线程安全性，而且在效率上有较大的提高。

 

ConcurrentHashMap的数据结构如下：

 

 

 

可以看出，相对 HashMap 和 Hashtable， ConcurrentHashMap 增加了Segment 层，每个Segment 原理上等同于一个 Hashtable， ConcurrentHashMap 为 Segment 的数组。下面是 ConcurrentHashMap 的 put 和 get 方法：

Java代码  收藏代码

final Segment<K,V> segmentFor(int hash) {  

        return segments[(hash >>> segmentShift) & segmentMask];  

    }  

  

public V put(K key, V value) {  

        if (value == null)  

            throw new NullPointerException();  

        int hash = hash(key.hashCode());  

        return segmentFor(hash).put(key, hash, value, false);  

    }  

  

public V get(Object key) {  

        int hash = hash(key.hashCode());  

        return segmentFor(hash).get(key, hash);  

    }  

向 ConcurrentHashMap 中插入数据或者读取数据，首先都要讲相应的 Key 映射到对应的 Segment，因此不用锁定整个类， 只要对单个的 Segment 操作进行上锁操作就可以了。理论上如果有 n 个 Segment，那么最多可以同时支持 n 个线程的并发访问，从而大大提高了并发访问的效率。另外 rehash() 操作也是对单个的 Segment 进行的，所以由 Map 中的数据量增加导致的 rehash 的成本也是比较低的。

 

单个 Segment 的进行数据操作的源码如下：

 

Java代码  收藏代码

V put(K key, int hash, V value, boolean onlyIfAbsent) {  

            lock();  

            try {  

                int c = count;  

                if (c++ > threshold) // ensure capacity  

                    rehash();  

  

                 …… // 代码省略，具体请查看源码                  

  

            } finally {  

                unlock();  

            }  

        }  

  

V replace(K key, int hash, V newValue) {  

            lock();  

            try {  

                HashEntry<K,V> e = getFirst(hash);  

                

                 …… // 代码省略，具体请查看源码     

                 

            } finally {  

                unlock();  

            }  

        }  

 

   可见对 单个的 Segment 进行的数据更新操作都是 加锁的，从而能够保证线程的安全性。

 

 

13、JVM内存结构，为什么需要GC？

 

1. Jvm的内存可以分为堆内存和非堆内存

1）   堆内存

Java 堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。

Java所以实例和数组的内存均在此处分配。对象的对内存

java垃圾回收器回收。

堆内存由两部分组成：Eden+Survivor(Fromspace+Tospace)叫做Young Generation(年轻代)和Old Generation（年老代）

它们分别存放的内容如下：

Eden----所有新创建的对象

Survoivor(Fromspace+Tospace)---当Eden的内存空间不足时，会将Eden中依然存活的对象拷贝到Survoivor中的Fromspace或者Tospace中

Old Generation ---当一个Survivor区域满了的时候，会将该区域中的已历经过多次的依旧存活的对象放到Old Generation中

2）   非堆内存

主要包括PermanentGeneration , Jvm Stack(java虚拟机栈), Local Method Statck(本地方法栈)。

它们分别存放的内容如下：

PermanentGeneration ---存放了所加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的Field信息、类中的方法信息，

Jvm Stack（虚拟机栈）---虚拟机栈是线程私有的，每个线程的创建都会创建虚拟机栈，Jvm Stack中存放当前线程中的局部基本类型变量，部分的返回结果,StackFrame及非基本类型的对象指向堆上的地址。

Local MethodStatck(本地方法栈)---- JVM采用本地方法堆栈来支持native方法的执行，此区域用于存储每个native方法调用的状态。

 

2. Jvm的回收机制

Jvm采用分代回收（Generationcollection）的策略，用较高频率对年轻的对象（Young Generation）进行扫描和回收，这种叫做minor collection,而对老对象（Old Generation）的回收频率要低的多，称为major collection这样就不需要每次GC都将内存中所以的对象都检查一遍。

当创建一个java对象时，内存申请过程如下：

1）   Jvm会试图为java对象在Eden中初始化一块内存区域

2）   当Eden空间足够时，内存申请结束。否则就到下一步

3）   Jvm GC机制试图释放在Eden中所以不活跃的对象（这个回收比较频繁）如果释放后Eden空间仍然不足放入新对象，则试图将部分Eden中的存活的对象放入Survivor区中

4）   Survivor区被用来作为Eden及Old Generation中间的交换区域，当Old Generation空间足够时，Survivor区的空间满时候，对象会被移动到Old Generation。

5）   当Old Generation区空间不够时，Jvm GC回收机制会在Old Generation进行完全的垃圾收集机制。

6）   完全垃圾收集后，若Survivor及Old Generation仍然无法存放从Eden复制过来的部分对象，导致Jvm无法在Eden为新对象创建内存区域，则出现“out of memory”错误。

3 Jvm  GC回收算法

1）引用计数算法

为每一个对象添加一个计数器，计数器记录了对该对象的活跃引用的数量。如果计数器为0，则说明这个对象没有被任何变量所引用，即应该进行垃圾收集。

收集过程如下：

A减少被收集对象所引用的对象的计数器的值

B将其放入延时收集队列之中

 

2） 标记-清除收集器算法

收集过程分为2个阶段

A.首先停止所有工作，从根集遍历所有被引用的节点，然后进行标记，最后恢复所有工作

B.收集阶段会收集那些没有被标记的节点，然后返回空闲链表

标记-清除法的缺点在于

A.标记阶段暂停的时间可能很长，而整个堆在交换阶段又是可访问的，可能会导致被换页换出内存。

B.另外一个问题在于，不管你这个对象是不是可达的，即是不是垃圾，都要在清楚阶段被检查一遍，非常耗时.

C.标记清楚这两个动作会产生大量的内存碎片,于是当有大对象进行分配时,不需要触发一次垃圾回收动作

3）   拷贝收集器算法

该算法的提出是为了克服句柄的开销和解决堆碎片的垃回收。将内存分为两个区域(fromspace和tospace)。所有的对象分配内存都分配到fromspace。在清理非活动对象阶段，把所有标志为活动的对象，copy到tospace，之后清楚fromspace空间。然后互换fromsapce和tospace的身份。既原先的fromspace变成tosapce，原先的tospace变成fromspace。每次清理，重复上述过程。

4） 标记-整理收集器算法

          标记整理收集器，通过融合了标记-清除收集器和拷贝收集器的优点，很好的解决了拷贝收集策略中，堆内存浪费严重的问题。
标记整理收集器分为2个阶段
1)标记阶段，这个阶段和标记-清除收集器的标记阶段相同
2)整理阶段，这个阶段将所有做了标记的活动对象整理到堆的底部

 

 

14、NIO模型，select/epoll的区别，多路复用的原理

 

select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。关于这三种IO多路复用的用法，前面三篇总结写的很清楚，并用服务器回射echo程序进行了测试。

　　今天对这三种IO多路复用进行对比，参考网上和书上面的资料，整理如下：

1、select实现

select的调用过程如下所示：

（1）使用copy_from_user从用户空间拷贝fd_set到内核空间

（2）注册回调函数__pollwait

（3）遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）

（4）以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数。

（5）__pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp_poll来说，其等待队列是sk->sk_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了。

（6）poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值。

（7）如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule_timeout是调用select的进程（也就是current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd。

（8）把fd_set从内核空间拷贝到用户空间。

总结：

select的几大缺点：

（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

（3）select支持的文件描述符数量太小了，默认是1024

2 poll实现

　　poll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd_set结构，其他的都差不多。

3、epoll

　　epoll既然是对select和poll的改进，就应该能避免上述的三个缺点。那epoll都是怎么解决的呢？在此之前，我们先看一下epoll和select和poll的调用接口上的不同，select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函数，epoll_create,epoll_ctl和epoll_wait，epoll_create是创建一个epoll句柄；epoll_ctl是注册要监听的事件类型；epoll_wait则是等待事件的产生。

　　对于第一个缺点，epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时（在epoll_ctl中指定EPOLL_CTL_ADD），会把所有的fd拷贝进内核，而不是在epoll_wait的时候重复拷贝。epoll保证了每个fd在整个过程中只会拷贝一次。

　　对于第二个缺点，epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中，而只在epoll_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd（利用schedule_timeout()实现睡一会，判断一会的效果，和select实现中的第7步是类似的）。

　　对于第三个缺点，epoll没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

总结：

（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。

（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。

 

15、  Java中一个字符占多少个字节，扩展再问int, long, double占多少字节

 

Java基本类型占用的字节数：

1字节： byte , boolean

2字节： short , char

4字节： int , float

8字节： long , double

注：1字节(byte)=8位(bits)

 

16、创建一个类的实例都有哪些办法？

 

1、关键字 new。工厂模式是对这种方式的包装；

 

2、类实现克隆接口，克隆一个实例。原型模式是一个应用实例；

 

3、用该类的加载器，newinstance。java的反射，反射使用实例：Spring的依赖注入、切面编程中动态代理

 

4、sun.misc.Unsafe类，allocateInstance方法创建一个实例。（Java官方也不建议直接使用的Unsafe类，据说Oracle正在计划从Java 9中去掉Unsafe类）

 

5、实现序列化接口的类，通过IO流反序列化读取一个类，获得实例。

 

 

17、final/finally/finalize的区别？

 

1、final修饰符（关键字）。被final修饰的类，就意味着不能再派生出新的子类，不能作为父类而被子类继承。因此一个类不能既被abstract声明，又被final声明。将变量或方法声明为final，可以保证他们在使用的过程中不被修改。被声明为final的变量必须在声明时给出变量的初始值，而在以后的引用中只能读取。被final声明的方法也同样只能使用，不能重载。

【例】

public  class  finalTest{

final   int  a=6;//final成员变量不能被更改

final   int  b;//在声明final成员变量时没有赋值，称为空白final

public finalTest(){

b=8；//在构造方法中为空白final赋值

}

int   do(final x){//设置final参数，不可以修改参数x的值

return x+1;

}

void  doit(){

final int i = 7;//局部变量定义为final，不可改变i的值

}

}

 

2、finally是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获，finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容，是在try块内容发生catch所声明的异常时，跳转到catch块中执行。finally块则是无论异常是否发生，都会执行finally块的内容，所以在代码逻辑中有需要无论发生什么都必须执行的代码，就可以放在finally块中。

 

3、finalize是方法名。java技术允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的，因此所有的类都继承了它。子类覆盖finalize（）方法以整理系统资源或者被执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。 

 

18、Session/Cookie的区别？

 

二者的定义：

当你在浏览网站的时候，WEB 服务器会先送一小小资料放在你的计算机上，Cookie 会帮你在网站上所打的文字或是一些选择，

都纪录下来。当下次你再光临同一个网站，WEB 服务器会先看看有没有它上次留下的 Cookie 资料，有的话，就会依据 Cookie

里的内容来判断使用者，送出特定的网页内容给你。 Cookie 的使用很普遍，许多有提供个人化服务的网站，都是利用 Cookie

来辨认使用者，以方便送出使用者量身定做的内容，像是 Web 接口的免费 email 网站，都要用到 Cookie。

 

具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。

同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制

来达到保存标识的目的，但实际上它还有其他选择。

cookie机制。

正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示

浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript或者VBScript也可以生成cookie。而cookie的使用

是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围

大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。

 

cookie的内容主要包括：名字，值，过期时间，路径和域。路径与域一起构成cookie的作用范围。若不设置过期时间，则表示这

个cookie的生命期为浏览器会话期间，关闭浏览器窗口，cookie就消失。这种生命期为浏览器会话期的cookie被称为会话cookie。

会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。若设置了过期时间，浏览器就会把cookie

保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏

览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式

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传递回服务器。比如： 

<form name="testform" action="/xxx"> 

<input type="hidden" name="jsessionid" value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764"> 

<input type="text"> 

</form> 

实际上这种技术可以简单的用对action应用URL重写来代替。

cookie 和session 的区别：

1、cookie数据存放在客户的浏览器上，session数据放在服务器上。

2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

   考虑到安全应当使用session。

3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能

   考虑到减轻服务器性能方面，应当使用COOKIE。

4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

5、所以个人建议：

   将登陆信息等重要信息存放为SESSION

   其他信息如果需要保留，可以放在COOKIE中

 

 

19、String/StringBuffer/StringBuilder的区别，扩展再问他们的实现？

 

java中String、StringBuffer、StringBuilder是编程中经常使用的字符串类，他们之间的区别也是经常在面试中会问到的问题。现在总结一下，看看他们的不同与相同。

1.可变与不可变

　　String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。

　　　　private final char value[];

　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。

　　　　char[] value;

2.是否多线程安全

　　String中的对象是不可变的，也就可以理解为常量，显然线程安全。

　　AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。

　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

 

1 public synchronized StringBuffer reverse() {

2     super.reverse();

3     return this;

4 }

5

6 public int indexOf(String str) {

7     return indexOf(str, 0);        //存在 public synchronized int indexOf(String str, int fromIndex) 方法

8 }

 

　　StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

 3.StringBuilder与StringBuffer共同点

　　StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。

　　抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。

　　StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

　　最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer

 

20、Servlet的生命周期？

 

Servlet的生命周期从Servlet类加载，到创建Servlet类实例，Servlet的初始化（真正成为一个Servlet），有请求到来，调用service方法（主要工作），直到Servlet被destroy；

1.Servlet类加载：

1.1  启动web容器后，容器去寻找应用的部署描述文件（web.xml），从部署描述文件中读取到上下文初始化参数，此时创建一个ServletContext对象，应用的所有部分共享此上下文；

1.2  容器为context-param创建String名值对（参数名和参数值均为String类型）；

1.3  容器将名值对交给ServletContext对象；

1.4  如果在部署描述文件中有Listener标签的话，创建Listener实例；

1.5  容器调用Listener的contextInitialized方法，传入ServletContextEvent对象，此对象包含一个ServletContext引用，事件处理代码可以得到上下文初始化参数。

 

2.创建Servlet类实例：

2.1  容器读取部署描述文件中的Servlet标签，包括初始化参数（init-param）；

2.2  容器创建ServletConfig实例；

2.3  容器为servlet初始化参数创建名值对；

2.4  容器用名值对填充ServletConfig；

2.5  容器创建Servlet类的新实例（一般在第一次请求到来时创建，也可通过设置load-on-start参数在容器启动时创建）。

 

3.Servlet初始化：

Servlet的init方法在一个生命周期中只被执行一次，调用service方法前，初始化必须完成；

在GenericServlet中有两个init方法，其中有参数的init方法，调用了无参的init方法，所以，若需要重写init方法，只需要重写无参的。

 

4.Servlet的service方法：

每次请求到来，都会调用service方法，在HttpServlet中，service方法用于判断请求的方法（不用重写），而去重写doGet方法或doPost方法。

    

5.Servlet的destroy方法：

销毁Servlet实例时调用，意味着Servlet的生命周期结束。

 

 

21、  Java有自己的内存回收机制，但为什么还存在内存泄露的问题呢？

 

1.既然 Java 的垃圾回收机制能够自动的回收内存，怎么还会出现内存泄漏的情况呢？这个问题，我们需要知道 GC 在什么时候回收内存对象，什么样的内存对象会被 GC 认为是“不再使用”的。

Java中对内存对象的访问，使用的是引用的方式。在 Java 代码中我们维护一个内存对象的引用变量，通过这个引用变量的值，我们可以访问到对应的内存地址中的内存对象空间。在 Java 程序中，这个引用变量本身既可以存放堆内存中，又可以放在代码栈的内存中（与基本数据类型相同）。 GC 线程会从代码栈中的引用变量开始跟踪，从而判定哪些内存是正在使用的。如果 GC 线程通过这种方式，无法跟踪到某一块堆内存，那么 GC 就认为这块内存将不再使用了（因为代码中已经无法访问这块内存了）。

通过这种有向图的内存管理方式，当一个内存对象失去了所有的引用之后，GC 就可以将其回收。反过来说，如果这个对象还存在引用，那么它将不会被 GC 回收，哪怕是 Java 虚拟机抛出 OutOfMemoryError 。

2.java内存泄漏的根本原因是？

答：内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。

3.堆溢出:静态集合类中存储对象

java.lang.OutOfMemoryError: Java heap space

4.栈溢出

java.lang.StackOverflowError

5.代码栈是什么？

答：

Vector v = new  Vector( 10 );

for  ( int  i = 1 ;i < 100 ; i ++ ){

Object o = new  Object();

v.add(o);

o = null ;

}

在这个例子中，代码栈中存在Vector 对象的引用 v 和 Object 对象的引用 o 。

在 For 循环中，我们不断的生成新的对象，然后将其添加到 Vector 对象中，之后将 o 引用置空。问题是当 o 引用被置空后，

如果发生 GC ，

我们创建的 Object 对象是否能够被 GC 回收呢？

答案是否定的。

因为， GC 在跟踪代码栈中的引用时，

会发现 v 引用，而继续往下跟踪，就会发现 v 引用指向的内存空间中又存在指向 Object 对象的引用。也就是说尽管 o 引用已经被置空，

但是 Object 对象仍然存在其他的引用，是可以被访问到的，所以 GC 无法将其释放掉。

如果在此循环之后， Object 对象对程序已经没有任何作用，

那么我们就认为此 Java 程序发生了内存泄漏。

 

7.内存泄漏在哪个领域比较常见？

答：在移动设备对于内存和 CPU都有较严格的限制的情况下， Java 的内存溢出会导致程序效率低下、占用大量不需要的内存等问题。这将导致整个机器性能变差，

严重的也会引起抛出 OutOfMemoryError ，导致程序崩溃。

 8.如何避免内存泄漏？

答：明确引用变量的生命周期，是方法内部的局部变量，还是类实例变量，与类实例生命周期相同的要声明为实例变量。

要避免这种情况下的内存泄露，要求我们以C/C++ 的内存管理思维来管理自己分配的内存。第一，是在声明对象引用之前，明确内存对象的有效作用域。在一个函数内有效的内存对象，应该声明为 local 变量，与类实例生命周期相同的要声明为实例变量……以此类推。第二，在内存对象不再需要时，记得手动将其引用置空。

 

22、什么是java序列化，如何实现java序列化?(写一个实例)？

 

Java 串行化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。Java的串行化机制是RMI、EJB等技术的技术基础。用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

2、串行化的特点：

    （1）如果某个类能够被串行化，其子类也可以被串行化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可串行化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可串行化接口，则该类的父类所有的字段属性将不会串行化。

  （2）声明为static和transient类型的成员数据不能被串行化。因为static代表类的状态， transient代表对象的临时数据；

  （3）相关的类和接口：在java.io包中提供的涉及对象的串行化的类与接口有ObjectOutput接口、ObjectOutputStream类、ObjectInput接口、ObjectInputStream类。

    （1）ObjectOutput接口：它继承DataOutput接口并且支持对象的串行化，其内的writeObject()方法实现存储一个对象。ObjectInput接口：它继承DataInput接口并且支持对象的串行化，其内的readObject()方法实现读取一个对象。

    （2）ObjectOutputStream类：它继承OutputStream类并且实现ObjectOutput接口。利用该类来实现将对象存储（调用ObjectOutput接口中的writeObject()方法）。ObjectInputStream类：它继承InputStream类并且实现ObjectInput接口。利用该类来实现读取一个对象（调用ObjectInput接口中的readObject()方法）。

  对于父类的处理，如果父类没有实现串行化接口，则其必须有默认的构造函数（即没有参数的构造函数）。否则编译的时候就会报错。在反串行化的时候，默认构造函数会被调用。但是若把父类标记为可以串行化，则在反串行化的时候，其默认构造函数不会被调用。这是为什么呢？这是因为Java 对串行化的对象进行反串行化的时候，直接从流里获取其对象数据来生成一个对象实例，而不是通过其构造函数来完成。

import java.io.*;

public class Cat implements Serializable {

        private String name;

        public Cat () {

                this.name = "new cat";

        }

        public String getName() {

                return this.name;

        }

        public void setName(String name) {

                this.name = name;

        }

        public static void main(String[] args) {         

                Cat cat = new Cat();

                try {

                        FileOutputStream fos = new FileOutputStream("catDemo.out");

                        ObjectOutputStream oos = new ObjectOutputStream(fos);

                        System.out.println(" 1> " + cat.getName());

                        cat.setName("My Cat");                       

                        oos.writeObject(cat);

                        oos.close();                       

                } catch (Exception ex) {  ex.printStackTrace();   }

                try {

                        FileInputStream fis = new FileInputStream("catDemo.out");

                        ObjectInputStream ois = new ObjectInputStream(fis);

                        cat = (Cat) ois.readObject();

                        System.out.println(" 2> " + cat.getName());

                        ois.close();

                } catch (Exception ex) {

                        ex.printStackTrace();

                }

        }

}//writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来。

 

 

23、String s = new String("abc");创建了几个 String Object?

 

String str=new String("abc");   紧接着这段代码之后的往往是这个问题，那就是这行代码究竟创建了几个String对象呢？

相信大家对这道题并不陌生，答案也是众所周知的，2个。

接下来我们就从这道题展开，一起回顾一下与创建String对象相关的一些JAVA知识。  

我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。那么，new String("abc")为什么又能被看成"abc"和new String()呢？

我们来看一下被我们调用了的String的构造器：  

public String(String original) {  //other code ...  }   大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种:

一、使用new创建对象。 

二、调用Class类的newInstance方法，利用反射机制创建对象。

我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。

 

这种方式是String特有的，并且它与new的方式存在很大区别。  

String str="abc";  

毫无疑问，这行代码创建了一个String对象。  

String a="abc";  String b="abc";   那这里呢？

答案还是一个。  

String a="ab"+"cd";   再看看这里呢？

答案是三个。

说到这里，我们就需要引入对字符串池相关知识的回顾了。  

在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。由于String类是final的，它的值一经创建就不可改变，因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护，我们可以调用intern()方法来访问字符串池。  

我们再回头看看String a="abc";，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象，它的判断依据是String类equals(Object obj)方法的返回值。如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。因此，我们不难理解前面三个例子中头两个例子为什么是这个答案了。

 

只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中，对此我们不再赘述。因此我们提倡大家用引号包含文本的方式来创建String对象以提高效率，实际上这也是我们在编程中常采用的。

 

栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。 

堆（heap）：用于存储对象