agoodcoder777
agoodcoder777

BTA 常问的 Java基础40道常见面试题及详细答案，java初级面试笔试题


我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。
扫描二维码或搜索下图红色VX号，加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。
推荐文章：Java 面试知识点解析；Mysql优化技巧（数据库设计、命名规范、索引优化

 

原文：http://www.ymq.io/2018/03/10/java/

 




  1.  
  2. 八种基本数据类型的大小，以及他们的封装类


     
  3. 引用数据类型


     
  4. Switch能否用string做参数


     
  5. equals与==的区别


     
  6. 自动装箱，常量池


     
  7. Object有哪些公用方法


     
  8. Java的四种引用，强弱软虚，用到的场景


     
  9. Hashcode的作用


     
  10. HashMap的hashcode的作用


     
  11. 为什么重载hashCode方法？


     
  12. ArrayList、LinkedList、Vector的区别


     
  13. String、StringBuffer与StringBuilder的区别


     
  14. Map、Set、List、Queue、Stack的特点与用法


     
  15. HashMap和HashTable的区别


     
  16. JDK7与JDK8中HashMap的实现


     
  17. HashMap和ConcurrentHashMap的区别，HashMap的底层源码


     
  18. ConcurrentHashMap能完全替代HashTable吗


     
  19. 为什么HashMap是线程不安全的


     
  20. 如何线程安全的使用HashMap


     
  21. 多并发情况下HashMap是否还会产生死循环


     
  22. TreeMap、HashMap、LindedHashMap的区别


     
  23. Collection包结构，与Collections的区别


     
  24. try?catch?finally，try里有return，finally还执行么


     
  25. Excption与Error包结构，OOM你遇到过哪些情况，SOF你遇到过哪些情况


     
  26. Java(OOP)面向对象的三个特征与含义


     
  27. Override和Overload的含义去区别


     
  28. Interface与abstract类的区别


     
  29. Static?class?与non?static?class的区别


     
  30. java多态的实现原理


     
  31. foreach与正常for循环效率对比


     
  32. Java?IO与NIO


     
  33. java反射的作用于原理


     
  34. 泛型常用特点


     
  35. 解析XML的几种方式的原理与特点：DOM、SAX


     
  36. Java1.7与1.8,1.9,10 新特性


     
  37. 设计模式：单例、工厂、适配器、责任链、观察者等等


     
  38. JNI的使用


     
  39. AOP是什么


     
  40. OOP是什么


     
  41. AOP与OOP的区别


     

八种基本数据类型的大小，以及他们的封装类

八种基本数据类型：int、short、float、double、long、boolean、byte、char；它们的

封装类分别是：Integer、Short、Float、Double、Long、Boolean、Byte、Character。

引用数据类型

引用数据类型是由类的编辑器定义的，他们是用于访问对象的。这些变量被定义为不可更改的特定类型

例如：Employee， Puppy 等等




  •  
  • 类对象和数组变量就是这种引用数据类型


     
  • 任何引用数据类型的默认值都为空


     
  • 一个引用数据类型可以被用于任何声明类型和兼容类型的对象


     

Switch能否用string做参数

jdk7之前 switch 只能支持 byte、short、char、int 这几个基本数据类型和其对应的封装类型。

switch后面的括号里面只能放int类型的值，但由于byte，short，char类型，它们会 自动 转换为int类型（精精度小的向大的转化），所以它们也支持。

jdk1.7后 整形，枚举类型，boolean，字符串都可以。

原理



 

switch (expression)  // 括号里是一个表达式，结果是个整数{

  case constant1:   // case 后面的标号，也是个整数

     group of statements 1;

     break;

  case constant2:

     group of statements 2;

     break;

  ...

  default:

     default group of statements

}



 

jdk1.7后，整形，枚举类型，boolean，字符串都可以。



 

public class TestString {

    static String string = "123";

    public static void main(String[] args) {

        switch (string) {

        case "123":

            System.out.println("123");

            break;

        case "abc":

            System.out.println("abc");

            break;

        default:

            System.out.println("defauls");

            break;

        }

    }

}



 

为什么jdk1.7后又可以用string类型作为switch参数呢？

其实，jdk1.7并没有新的指令来处理switch string，而是通过调用switch中string.hashCode,将string转换为int从而进行判断。

equals与==的区别

使用==比较原生类型如：boolean、int、char等等，使用equals()比较对象

1、==是判断两个变量或实例是不是指向同一个内存空间
equals是判断两个变量或实例所指向的内存空间的值是不是相同

2、==是指对内存地址进行比较
equals()是对字符串的内容进行比较

3、==指引用是否相同 equals()指的是值是否相同



 

public static void main(String[] args) {

        String a = new String("ab"); // a 为一个引用

        String b = new String("ab"); // b为另一个引用,对象的内容一样

        String aa = "ab"; // 放在常量池中

        String bb = "ab"; // 从常量池中查找

        System.out.println(aa == bb); // true

        System.out.println(a == b); // false，非同一对象

        System.out.println(a.equals(b)); // true

        System.out.println(42 == 42.0);  // true

    }

public static void main(String[] args) {

    Object obj1 = new Object(); 

    Object obj2 = new Object();

    System.out.println(obj1.equals(obj2));//false

    System.out.println(obj1==obj2);//false

    obj1=obj2;

    System.out.println(obj1==obj2);//true

    System.out.println(obj2==obj1);//true

}



 

自动装箱，常量池

自动装箱 在jdk 1.5之前，如果你想要定义一个value为100的Integer对象，则需要如下定义：



 

Integer i = new Integer(100);

int intNum1 = 100; //普通变量

Integer intNum2 = intNum1; //自动装箱

int intNum3 = intNum2; //自动拆箱

Integer intNum4 = 100; //自动装箱



 

上面的代码中，intNum2为一个Integer类型的实例，intNum1为Java中的基础数据类型， 将intNum1赋值给intNum2便是自动装箱；而将intNum2赋值给intNum3则是自动拆箱。

八种基本数据类型： boolean byte char shrot int long float double ,所生成的变量相当于常量；

基本类型包装类：Boolean Byte Character Short Integer Long Float Double。

自动拆箱和自动装箱定义：

自动装箱是将一个java定义的基本数据类型赋值给相应封装类的变量。 拆箱与装箱是相反的操作，自动拆箱则是将一个封装类的变量赋值给相应基本数据类型的变量。

Object有哪些公用方法

Object是所有类的父类，任何类都默认继承Object

clone 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常

equals 在Object中与==是一样的，子类一般需要重写该方法

hashCode 该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到

getClass final方法，获得运行时类型

wait 使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。
wait() 方法一直等待，直到获得锁或者被中断。
wait(long timeout) 设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生

1、其他线程调用了该对象的notify方法
2、其他线程调用了该对象的notifyAll方法
3、其他线程调用了interrupt中断该线程
4、时间间隔到了
5、此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常

notify 唤醒在该对象上等待的某个线程

notifyAll 唤醒在该对象上等待的所有线程

toString 转换成字符串，一般子类都有重写，否则打印句柄

Java的四种引用，强弱软虚，用到的场景

从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1、强引用

最普遍的一种引用方式，如String s = “abc”，变量s就是字符串“abc”的强引用，只要强引用存在，则垃圾回收器就不会回收这个对象。

2、软引用（SoftReference）

用于描述还有用但非必须的对象，如果内存足够，不回收，如果内存不足，则回收。一般用于实现内存敏感的高速缓存，软引用可以和引用队列ReferenceQueue联合使用，如果软引用的对象被垃圾回收，JVM就会把这个软引用加入到与之关联的引用队列中。

3、弱引用（WeakReference）

弱引用和软引用大致相同，弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

4、虚引用（PhantomReference）

就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。 虚引用主要用来跟踪对象被垃圾回收器回收的活动。

虚引用与软引用和弱引用的一个区别在于：

虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

Hashcode的作用

http://blog.csdn.net/seu_calvin/article/details/52094115

1、HashCode的特性

（1）HashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，HashCode经常用于确定对象的存储地址

（2）如果两个对象相同， equals方法一定返回true，并且这两个对象的HashCode一定相同

（3）两个对象的HashCode相同，并不一定表示两个对象就相同，即equals()不一定为true，只能够说明这两个对象在一个散列存储结构中

（4）如果对象的equals方法被重写，那么对象的HashCode也尽量重写。

2、HashCode作用

Java中的集合有两类，一类是List，再有一类是Set。前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复

equals方法可用于保证元素不重复，但如果每增加一个元素就检查一次，若集合中现在已经有1000个元素，那么第1001个元素加入集合时，就要调用1000次equals方法。这显然会大大降低效率。 于是，Java采用了哈希表的原理

哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上

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

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

（2）如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了

（3）不相同的话，也就是发生了Hash key相同导致冲突的情况，那么就在这个Hash key的地方产生一个链表，将所有产生相同HashCode的对象放到这个单链表上去，串在一起（很少出现）

这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次

如何理解HashCode的作用：

从Object角度看，JVM每new一个Object，它都会将这个Object丢到一个Hash表中去，这样的话，下次做Object的比较或者取这个对象的时候（读取过程），它会根据对象的HashCode再从Hash表中取这个对象。这样做的目的是提高取对象的效率。若HashCode相同再去调用equal。

3、HashCode实践（如何用来查找）

HashCode是用于查找使用的，而equals是用于比较两个对象是否相等的

（1）例如内存中有这样的位置



 

0  1  2  3  4  5  6  7



 

而我有个类，这个类有个字段叫ID，我要把这个类存放在以上8个位置之一，如果不用HashCode而任意存放，那么当查找时就需要到这八个位置里挨个去找，或者用二分法一类的算法

但以上问题如果用HashCode就会使效率提高很多 定义我们的HashCode为ID％8，比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。依此类推。

（2）但是如果两个类有相同的HashCode，例如9除以8和17除以8的余数都是1，也就是说，我们先通过 HashCode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过equals在这个桶里找到我们要的类

请看下面这个例子



 

public class HashTest {

    private int i;

    public int getI() {

        return i;

    }

    public void setI(int i) {

        this.i = i;

    }

    public int hashCode() {

        return i % 10;

    }

    public final static void main(String[] args) {

        HashTest a = new HashTest();

        HashTest b = new HashTest();

        a.setI(1);

        b.setI(1);

        Set set = new HashSet();

        set.add(a);

        set.add(b);

        System.out.println(a.hashCode() == b.hashCode());

        System.out.println(a.equals(b));

        System.out.println(set);

    }

}



 

输出结果为：



 

true

False

[HashTest@1, HashTest@1]



 

以上这个示例，我们只是重写了HashCode方法，从上面的结果可以看出，虽然两个对象的HashCode相等，但是实际上两个对象并不是相等，因为我们没有重写equals方法，那么就会调用Object默认的equals方法，显示这是两个不同的对象。

这里我们将生成的对象放到了HashSet中，而HashSet中只能够存放唯一的对象，也就是相同的（适用于equals方法）的对象只会存放一个，但是这里实际上是两个对象ab都被放到了HashSet中，这样HashSet就失去了他本身的意义了。

下面我们继续重写equals方法：



 

public class HashTest {

    private int i;

    public int getI() {

        return i;

    }

    public void setI(int i) {

        this.i = i;

    }

    public boolean equals(Object object) {

        if (object == null) {

            return false;

        }

        if (object == this) {

            return true;

        }

        if (!(object instanceof HashTest)) {

            return false;

        }

        HashTest other = (HashTest) object;

        if (other.getI() == this.getI()) {

            return true;

        }

        return false;

    }

    public int hashCode() {

        return i % 10;

    }

    public final static void main(String[] args) {

        HashTest a = new HashTest();

        HashTest b = new HashTest();

        a.setI(1);

        b.setI(1);

        Set set = new HashSet();

        set.add(a);

        set.add(b);

        System.out.println(a.hashCode() == b.hashCode());

        System.out.println(a.equals(b));

        System.out.println(set);

    }

}



 

输出结果如下所示。

从结果我们可以看出，现在两个对象就完全相等了，HashSet中也只存放了一份对象。

注意： hashCode()只是简单示例写的，真正的生产换将不是这样的



 

true

true

[HashTest@1]



 

HashMap的hashcode的作用

hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；

如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；

如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；

两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。

什么时候需要重写？

一般的地方不需要重载hashCode，只有当类需要放在HashTable、HashMap、HashSet等等hash结构的集合时才会重载hashCode，那么为什么要重载hashCode呢？

要比较两个类的内容属性值，是否相同时候，根据hashCode 重写规则，重写类的 指定字段的hashCode()，equals()方法

例如



 

public class EmpWorkCondition{

    /**

     * 员工ID

     */

    private Integer empId;

    /**

     * 员工服务总单数

     */

    private Integer orderSum;

    @Override

    public boolean equals(Object o) {

        if (this == o) {

            return true;

        }

        if (o == null || getClass() != o.getClass()) {

            return false;

        }

        EmpWorkCondition that = (EmpWorkCondition) o;

        return Objects.equals(empId, that.empId);

    }

    @Override

    public int hashCode() {

        return Objects.hash(empId);

    }

    // 省略 getter setter

}



 



 

public static void main(String[] args) {

    List list1 = new ArrayList();

    EmpWorkCondition emp1 = new EmpWorkCondition();

    emp1.setEmpId(100);

    emp1.setOrderSum(90000);

    list1.add(emp1);

    List list2 = new ArrayList();

    EmpWorkCondition emp2 = new EmpWorkCondition();

    emp2.setEmpId(100);

    list2.add(emp2);

    System.out.println(list1.contains(emp2));

}



 

输出结果：true

上面的方法，做的事情就是，比较两个集合中的，实体类对象属性值，是否一致

OrderSum 不在比较范围内，因为没有重写它的，equals()和hashCode()方法

为什么要重载equal方法？

因为Object的equal方法默认是两个对象的引用的比较，意思就是指向同一内存,地址则相等，否则不相等；如果你现在需要利用对象里面的值来判断是否相等，则重载equal方法

为什么重载hashCode方法？

一般的地方不需要重载hashCode，只有当类需要放在HashTable、HashMap、HashSet等等hash结构的集合时才会重载hashCode，那么为什么要重载hashCode呢？

如果你重写了equals，比如说是基于对象的内容实现的，而保留hashCode的实现不变，那么很可能某两个对象明明是“相等”，而hashCode却不一样。

这样，当你用其中的一个作为键保存到hashMap、hasoTable或hashSet中，再以“相等的”找另一个作为键值去查找他们的时候，则根本找不到。

为什么equals()相等，hashCode就一定要相等，而hashCode相等，却不要求equals相等?

1、因为是按照hashCode来访问小内存块，所以hashCode必须相等
2、HashMap获取一个对象是比较key的hashCode相等和equal为true

之所以hashCode相等，却可以equal不等，就比如ObjectA和ObjectB他们都有属性name，那么hashCode都以name计算，所以hashCode一样，但是两个对象属于不同类型，所以equal为false

为什么需要hashCode?

1、通过hashCode可以很快的查到小内存块
2、通过hashCode比较比equal方法快，当get时先比较hashCode，如果hashCode不同，直接返回false

ArrayList、LinkedList、Vector的区别

List的三个子类的特点

ArrayList:




  •  
  • 底层数据结构是数组，查询快，增删慢。


     
  • 线程不安全，效率高。


     

Vector:




  •  
  • 底层数据结构是数组，查询快，增删慢。


     
  • 线程安全，效率低。


     
  • Vector相对ArrayList查询慢(线程安全的)


     
  • Vector相对LinkedList增删慢(数组结构)


     

LinkedList




  •  
  • 底层数据结构是链表，查询慢，增删快。


     
  • 线程不安全，效率高。


     

Vector和ArrayList的区别




  •  
  • Vector是线程安全的,效率低


     
  • ArrayList是线程不安全的,效率高


     
  • 共同点:底层数据结构都是数组实现的,查询快,增删慢


     

ArrayList和LinkedList的区别




  •  
  • ArrayList底层是数组结果,查询和修改快


     
  • LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢


     

共同点:都是线程不安全的

List有三个子类使用




  •  
  • 查询多用ArrayList


     
  • 增删多用LinkedList


     
  • 如果都多ArrayList


     

String、StringBuffer与StringBuilder的区别

String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
StringBuilder：是线程不安全的，而StringBuffer是线程安全的

这三个类之间的区别主要是在两个方面，即运行速度和线程安全这两方面
首先说运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String

String最慢的原因

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。

再来说线程安全

在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

Map、Set、List、Queue、Stack的特点与用法

Map




  •  
  • Map是键值对，键Key是唯一不能重复的，一个键对应一个值，值可以重复。


     
  • TreeMap可以保证顺序


     
  • HashMap不保证顺序，即为无序的。


     
  • Map中可以将Key和Value单独抽取出来，其中KeySet()方法可以将所有的keys抽取正一个Set。而Values()方法可以将map中所有的values抽取成一个集合。


     

Set




  •  
  • 不包含重复元素的集合，set中最多包含一个null元素


     
  • 只能用Lterator实现单项遍历，Set中没有同步方法。


     

List




  •  
  • 有序的可重复集合。


     
  • 可以在任意位置增加删除元素。


     
  • 用Iterator实现单向遍历，也可用ListIterator实现双向遍历


     

Queue




  •  
  • Queue遵从先进先出原则。


     
  • 使用时尽量避免add()和remove()方法,而是使用offer()来添加元素，使用poll()来移除元素，它的优点是可以通过返回值来判断是否成功。


     
  • LinkedList实现了Queue接口。


     
  • Queue通常不允许插入null元素。


     

Stack




  •  
  • Stack遵从后进先出原则。


     
  • Stack继承自Vector。


     
  • 它通过五个操作对类Vector进行扩展，允许将向量视为堆栈，它提供了通常的push和pop操作，以及取堆栈顶点的peek()方法、测试堆栈是否为空的empty方法等


     

用法




  •  
  • 如果涉及堆栈，队列等操作，建议使用List


     
  • 对于快速插入和删除元素的，建议使用LinkedList


     
  • 如果需要快速随机访问元素的，建议使用ArrayList


     

更为精炼的总结

Collection 是对象集合， Collection 有两个子接口 List 和 Set

List 可以通过下标 (1,2..) 来取得值，值可以重复
Set 只能通过游标来取值，并且值是不能重复的

ArrayList ， Vector ， LinkedList 是 List 的实现类




  •  
  • ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的


     
  • LinkedList 是线程不安全的，底层是由链表实现的


     

Map 是键值对集合




  •  
  • HashTable 和 HashMap 是 Map 的实现类


     
  • HashTable 是线程安全的，不能存储 null 值


     
  • HashMap 不是线程安全的，可以存储 null 值


     

Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。

Queue接口：提供了几个基本方法，offer、poll、peek等。已知实现类有LinkedList、PriorityQueue等。

HashMap和HashTable的区别

https://segmentfault.com/a/1190000008101567

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现，它们都是集合中将数据无序存放的。

1、hashMap去掉了HashTable 的contains方法，但是加上了containsValue()和containsKey()方法

HashTable Synchronize同步的，线程安全，HashMap不允许空键值为空 ，效率低
HashMap 非Synchronize线程同步的，线程不安全，HashMap允许空键值为空 ，效率高
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现，它们都是集合中将数据无序存放的。

Hashtable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样

查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized 关键字，而HashMap的源代码中则连 synchronized 的影子都没有，当然，注释除外。

2、Hashtable不允许 null 值(key 和 value 都不可以)，HashMap允许 null 值(key和value都可以)

3、两者的遍历方式大同小异，Hashtable仅仅比HashMap多一个elements方法



 

Hashtable table = new Hashtable();  

table.put("key", "value");

Enumeration em = table.elements();  

while (em.hasMoreElements()) {  

   String obj = (String) em.nextElement();  

   System.out.println(obj);   

}



 

4、HashTable使用Enumeration，HashMap使用Iterator

从内部机制实现上的区别如下：




  1.  
  2. 哈希值的使用不同，Hashtable直接使用对象的hashCode


     



 

int hash = key.hashCode();  

int index = (hash & 0x7FFFFFFF) % tab.length;



 

而HashMap重新计算hash值，而且用与代替求模：



 

int hash = hash(k);  

int i = indexFor(hash, table.length);  

  

static int hash(Object x) {  

  int h = x.hashCode();  

  

  h += ~(h << 9);  

  h ^= (h >>> 14);  

  h += (h << 4);  

  h ^= (h >>> 10);  

  return h;  

}



 



 

static int indexFor(int h， int length) {  

  return h & (length-1);



 




  1.  
  2. Hashtable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。


     

JDK7与JDK8中HashMap的实现

JDK7中的HashMap

HashMap底层维护一个数组，数组中的每一项都是一个Entry



 

transient Entry[] table;



 

我们向 HashMap 中所放置的对象实际上是存储在该数组当中

而Map中的key，value则以Entry的形式存放在数组中



 

static class Entry implements Map.Entry {

        final K key;

        V value;

        Entry next;

        int hash;



 

总结一下map.put后的过程：

当向 HashMap 中 put 一对键值时，它会根据 key的 hashCode 值计算出一个位置， 该位置就是此对象准备往数组中存放的位置。

如果该位置没有对象存在，就将此对象直接放进数组当中；如果该位置已经有对象存在了，则顺着此存在的对象的链开始寻找(为了判断是否是否值相同，map不允许键值对重复)， 如果此链上有对象的话，再去使用 equals方法进行比较，如果对此链上的每个对象的 equals 方法比较都为 false，则将该对象放到数组当中，然后将数组中该位置以前存在的那个对象链接到此对象的后面。

JDK8中的HashMap

JDK8中采用的是位桶+链表/红黑树（有关红黑树请查看红黑树）的方式，也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候，这个链表就将转换成红黑树。

JDK8中，当同一个hash值的节点数不小于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树（上图中null节点没画）。这就是JDK7与JDK8中HashMap实现的最大区别。

接下来，我们来看下JDK8中HashMap的源码实现。

JDK中Entry的名字变成了Node，原因是和红黑树的实现TreeNode相关联。



 

transient Node[] table;



 

当冲突节点数不小于8-1时，转换成红黑树。



 

static final int TREEIFY_THRESHOLD = 8;



 

HashMap和ConcurrentHashMap的区别，HashMap的底层源码

为了线程安全从ConcurrentHashMap代码中可以看出，它引入了一个“分段锁”的概念，具体可以理解为把一个大的Map拆分成N个小的HashTable，根据key.hashCode()来决定把key放到哪个HashTable中。

Hashmap本质是数组加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。

ConcurrentHashMap：在hashMap的基础上，ConcurrentHashMap将数据分为多个segment，默认16个（concurrency level），然后每次操作对一个segment加锁，避免多线程锁的几率，提高并发效率。

总结

JDK6,7中的ConcurrentHashmap主要使用Segment来实现减小锁粒度，把HashMap分割成若干个Segment，在put的时候需要锁住Segment，get时候不加锁，使用volatile来保证可见性，当要统计全局时（比如size），首先会尝试多次计算modcount来确定，这几次尝试中，是否有其他线程进行了修改操作，如果没有，则直接返回size。如果有，则需要依次锁住所有的Segment来计算。

jdk7中ConcurrentHashmap中，当长度过长碰撞会很频繁，链表的增改删查操作都会消耗很长的时间，影响性能

jdk8 中完全重写了concurrentHashmap,代码量从原来的1000多行变成了 6000多 行，实现上也和原来的分段式存储有很大的区别。

JDK8中采用的是位桶+链表/红黑树（有关红黑树请查看红黑树）的方式，也是非线程安全的。当某个位桶的链表的长度达到某个阀值的时候，这个链表就将转换成红黑树。

JDK8中，当同一个hash值的节点数不小于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树（上图中null节点没画）。这就是JDK7与JDK8中HashMap实现的最大区别。

主要设计上的变化有以下几点

1.jdk8不采用segment而采用node，锁住node来实现减小锁粒度。 2.设计了MOVED状态 当resize的中过程中 线程2还在put数据，线程2会帮助resize。 3.使用3个CAS操作来确保node的一些操作的原子性，这种方式代替了锁。 4.sizeCtl的不同值来代表不同含义，起到了控制的作用。

至于为什么JDK8中使用synchronized而不是ReentrantLock，我猜是因为JDK8中对synchronized有了足够的优化吧。

ConcurrentHashMap能完全替代HashTable吗

hashTable虽然性能上不如ConcurrentHashMap，但并不能完全被取代，两者的迭代器的一致性不同的，hash table的迭代器是强一致性的，而concurrenthashmap是弱一致的。

ConcurrentHashMap的get，clear，iterator 都是弱一致性的。 Doug Lea 也将这个判断留给用户自己决定是否使用ConcurrentHashMap。

ConcurrentHashMap与HashTable都可以用于多线程的环境，但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。

那么既然ConcurrentHashMap那么优秀，为什么还要有Hashtable的存在呢？ConcurrentHashMap能完全替代HashTable吗？

HashTable虽然性能上不如ConcurrentHashMap，但并不能完全被取代，两者的迭代器的一致性不同的，HashTable的迭代器是强一致性的，而ConcurrentHashMap是弱一致的。 ConcurrentHashMap的get，clear，iterator 都是弱一致性的。 Doug Lea 也将这个判断留给用户自己决定是否使用ConcurrentHashMap。

那么什么是强一致性和弱一致性呢？

get方法是弱一致的，是什么含义？可能你期望往ConcurrentHashMap底层数据结构中加入一个元素后，立马能对get可见，但ConcurrentHashMap并不能如你所愿。换句话说，put操作将一个元素加入到底层数据结构后，get可能在某段时间内还看不到这个元素，若不考虑内存模型，单从代码逻辑上来看，却是应该可以看得到的。

下面将结合代码和java内存模型相关内容来分析下put/get方法。put方法我们只需关注Segment#put，get方法只需关注Segment#get，在继续之前，先要说明一下Segment里有两个volatile变量：count和table；HashEntry里有一个volatile变量：value。

总结

ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。

为什么HashMap是线程不安全的

HashMap 在并发执行 put 操作时会引起死循环，导致 CPU 利用率接近100%。因为多线程会导致 HashMap 的 Node 链表形成环形数据结构，一旦形成环形数据结构，Node 的 next 节点永远不为空，就会在获取 Node 时产生死循环。

如何线程安全的使用HashMap

了解了 HashMap 为什么线程不安全，那现在看看如何线程安全的使用 HashMap。这个无非就是以下三种方式：

Hashtable ConcurrentHashMap Synchronized Map

Hashtable

例子



 

//Hashtable  

Map hashtable = new Hashtable<>();  

//synchronizedMap  

Map synchronizedHashMap = Collections.synchronizedMap(new HashMap());  

//ConcurrentHashMap  

Map concurrentHashMap = new ConcurrentHashMap<>();  

Hashtable



 

先稍微吐槽一下，为啥命名不是 HashTable 啊，看着好难受不管了就装作它叫HashTable 吧。这货已经不常用了，就简单说说吧。HashTable 源码中是使用 synchronized 来保证线程安全的，比如下面的 get 方法和 put 方法：



 

public synchronized V get(Object key) {  

   // 省略实现  

}  

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

// 省略实现  

}



 

所以当一个线程访问 HashTable 的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。举个例子，当一个线程使用 put 方法时，另一个线程不但不可以使用 put 方法，连 get 方法都不可以，好霸道啊！！！so~~，效率很低，现在基本不会选择它了。

ConcurrentHashMap

ConcurrentHashMap 于 Java 7 的，和8有区别,在8中 CHM 摒弃了 Segment（锁段）的概念，而是启用了一种全新的方式实现,利用 CAS 算法，有时间会重新总结一下。

SynchronizedMap

synchronizedMap() 方法后会返回一个 SynchronizedMap 类的对象，而在 SynchronizedMap 类中使用了 synchronized 同步关键字来保证对 Map 的操作是线程安全的。

性能对比

这是要靠数据说话的时代，所以不能只靠嘴说 CHM 快，它就快了。写个测试用例，实际的比较一下这三种方式的效率(源码来源)，下面的代码分别通过三种方式创建 Map 对象，使用 ExecutorService 来并发运行5个线程，每个线程添加/获取500K个元素。



 

Test started for: class java.util.Hashtable

2500K entried added/retrieved in 2018 ms

2500K entried added/retrieved in 1746 ms

2500K entried added/retrieved in 1806 ms

2500K entried added/retrieved in 1801 ms

2500K entried added/retrieved in 1804 ms

For class java.util.Hashtable the average time is 1835 ms

Test started for: class java.util.Collections$SynchronizedMap

2500K entried added/retrieved in 3041 ms

2500K entried added/retrieved in 1690 ms

2500K entried added/retrieved in 1740 ms

2500K entried added/retrieved in 1649 ms

2500K entried added/retrieved in 1696 ms

For class java.util.Collections$SynchronizedMap the average time is 1963 ms

Test started for: class java.util.concurrent.ConcurrentHashMap

2500K entried added/retrieved in 738 ms

2500K entried added/retrieved in 696 ms

2500K entried added/retrieved in 548 ms

2500K entried added/retrieved in 1447 ms

2500K entried added/retrieved in 531 ms

For class java.util.concurrent.ConcurrentHashMap the average time is 792 ms



 

ConcurrentHashMap 性能是明显优于 Hashtable 和 SynchronizedMap 的,CHM 花费的时间比前两个的一半还少。

多并发情况下HashMap是否还会产生死循环

今天本来想看下了ConcurrentHashMap的源码，ConcurrentHashMap是Java 5中支持高并发、高吞吐量的线程安全HashMap实现

在看很多博客在介绍ConcurrentHashMap之前，都说HashMap适用于单线程访问，这是因为HashMap的所有方法都没有进行锁同步，因此是线程不安全的，不仅如此，当多线程访问的时候还容易产生死循环。

虽然自己在前几天的时候看过HashMap的源码，感觉思路啥啥的都还清楚，对于多线程访问只知道HashMap是线程不安全的，但是不知道HashMap在多线程并发的情况下会产生死循环呢，为什么会产生,何种情况下才会产生死循环呢？？？

《Java困惑》：多并发情况下HashMap是否还会产生死循环

http://blog.csdn.net/u010412719/article/details/52049347

既然会产生死循环，为什么并发情况下，还是用ConcurrentHashMap。 jdk 好像有，但是Jdk8 已经修复了这个问题

TreeMap、HashMap、LindedHashMap的区别

LinkedHashMap可以保证HashMap集合有序，存入的顺序和取出的顺序一致。

TreeMap实现SortMap接口，能够把它保存的记录根据键排序,默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。

HashMap不保证顺序，即为无序的，具有很快的访问速度
HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null
HashMap不支持线程的同步

我们在开发的过程中使用HashMap比较多，在Map中在Map 中插入、删除和定位元素，HashMap 是最好的选择

但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好

如果需要输出的顺序和输入的相同,那么用LinkedHashMap 可以实现,它还可以按读取顺序来排列

Collection包结构，与Collections的区别

http://blog.sina.com.cn/s/blog_105817120102vzh6.html

Collection 是集合类的上级接口，子接口主要有Set、List 、Map。

Collecions 是针对集合类的一个帮助类， 提供了操作集合的工具方法，一系列静态方法实现对各种集合的搜索、排序线性、线程安全化等操作。

例如



 

Map map4 = Collections.synchronizedMap(new HashMap());  线程安全 的HashMap

Collections.sort(List list, Comparator c); 排序 List



 

Collection

Collection 是单列集合

List

元素是有序的、可重复
有序的 collection，可以对列表中每个元素的插入位置进行精确地控制
可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素
可存放重复元素，元素存取是有序的。

List接口中常用类

Vector：线程安全，但速度慢，已被ArrayList替代。底层数据结构是数组结构
ArrayList：线程不安全，查询速度快。底层数据结构是数组结构
LinkedList：线程不安全。增删速度快。底层数据结构是列表结构

Set

Set接口中常用的类

Set(集) 元素无序的、不可重复
取出元素的方法只有迭代器。不可以存放重复元素，元素存取是无序的

HashSet：线程不安全，存取速度快。它是如何保证元素唯一性的呢？依赖的是元素的hashCode方法和euqals方法
TreeSet：线程不安全，可以对Set集合中的元素进行排序。它的排序是如何进行的呢？通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的

Map

map是一个双列集合

Hashtable:线程安全，速度快。底层是哈希表数据结构。是同步的。不允许null作为键，null作为值

Properties:用于配置文件的定义和操作，使用频率非常高，同时键和值都是字符串。是集合中可以和IO技术相结合的对象。(到了IO在学习它的特有和io相关的功能

HashMap:线程不安全，速度慢。底层也是哈希表数据结构。是不同步的。允许null作为键，null作为值。替代了Hashtable

LinkedHashMap: 可以保证HashMap集合有序。存入的顺序和取出的顺序一致

TreeMap：可以用来对Map集合中的键进行排序

try catch finally，try里有return，finally还执行么

肯定会执行。finally{}块的代码
只有在try{}块中包含遇到System.exit(0)
之类的导致Java虚拟机直接退出的语句才会不执行

当程序执行try{}遇到return时，程序会先执行return语句，但并不会立即返回——也就是把return语句要做的一切事情都准备好，也就是在将要返回、但并未返回的时候，程序把执行流程转去执行finally块，当finally块执行完成后就直接返回刚才return语句已经准备好的结果。

Excption与Error包结构。OOM你遇到过哪些情况，SO F你遇到过哪些情况

Throwable是 Java 语言中所有错误或异常的超类
Throwable包含两个子类: Error 和 Exception 。它们通常用于指示发生了异常情况
Throwable包含了其线程创建时线程执行堆栈的快照，它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息

Java将可抛出(Throwable)的结构分为三种类型：

被检查的异常(Checked Exception)
运行时异常(RuntimeException)
错误(Error)

运行时异常RuntimeException

定义 : RuntimeException及其子类都被称为运行时异常
特点 : Java编译器不会检查它 也就是说，当程序中可能出现这类异常时，倘若既”没有通过throws声明抛出它”，也”没有用try-catch语句捕获它”，还是会编译通过

例如，除数为零时产生的ArithmeticException异常，数组越界时产生的IndexOutOfBoundsException异常，fail-fail机制产生的ConcurrentModificationException异常等，都属于运行时异常。

堆内存溢出 OutOfMemoryError（OOM）

除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError(OOM)异常的可能

Java Heap 溢出 一般的异常信息：java.lang.OutOfMemoryError:Java heap spacess
java堆用于存储对象实例，我们只要不断的创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，就会在对象数量达到最大堆容量限制后产生内存溢出异常。

堆栈溢出 StackOverflow （SOF）

StackOverflowError 的定义：
当应用程序递归太深而发生堆栈溢出时，抛出该错误
因为栈一般默认为1-2m，一旦出现死循环或者是大量的递归调用，在不断的压栈过程中，造成栈容量超过1m而导致溢出

栈溢出的原因：

递归调用
大量循环或死循环
全局变量是否过多
数组、List、map数据过大

Java(OOP)面向对象的三个特征与含义

封装（高内聚低耦合 –>解耦）

封装是指将某事物的属性和行为包装到对象中，这个对象只对外公布需要公开的属性和行为，而这个公布也是可以有选择性的公布给其它对象。在java中能使用private、protected、public三种修饰符或不用（即默认defalut）对外部对象访问该对象的属性和行为进行限制

java的继承（重用父类的代码）

继承是子对象可以继承父对象的属性和行为，亦即父对象拥有的属性和行为，其子对象也就拥有了这些属性和行为

java中的多态（父类引用指向子类对象）

多态是指父对象中的同一个行为能在其多个子对象中有不同的表现

有两种多态的机制：编译时多态、运行时多态

1、方法的重载：重载是指同一类中有多个同名的方法，但这些方法有着不同的参数。，因此在编译时就可以确定到底调用哪个方法，它是一种编译时多态
2、方法的重写：子类可以覆盖父类的方法，因此同样的方法会在父类中与子类中有着不同的表现形式

Override和Overload的含义去区别

重载 Overload方法名相同，参数列表不同(个数、顺序、类型不同)与返回类型无关
重写 Override 覆盖。 将父类的方法覆盖 重写方法重写：方法名相同，访问修饰符只能大于被重写的方法访问修饰符，方法签名个数，顺序个数类型相同

Override（重写）




  •  
  • 方法名、参数、返回值相同


     
  • 子类方法不能缩小父类方法的访问权限


     
  • 子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)


     
  • 存在于父类和子类之间


     
  • 方法被定义为final不能被重写


     

Overload（重载）




  •  
  • 参数类型、个数、顺序至少有一个不相同


     
  • 不能重载只有返回值不同的方法名


     
  • 存在于父类和子类、同类中


     

而重载的规则

1、必须具有不同的参数列表 2、可以有不同的返回类型，只要参数列表不同就可以了 3、可以有不同的访问修饰符 4、可以抛出不同的异常

重写方法的规则

1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。
3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）。 4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。

例如： 父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

Interface与abstract类的区别

Interface 只能有成员常量，只能是方法的声明 Abstract class可以有成员变量，可以声明普通方法和抽象方法

interface是接口，所有的方法都是抽象方法，成员变量是默认的public static final 类型。接口不能实例化自己

abstract class是抽象类，至少包含一个抽象方法的累叫抽象类，抽象类不能被自身实例化，并用abstract关键字来修饰

Static class 与non static class的区别

static class（内部静态类）

1、用static修饰的是内部类，此时这个内部类变为静态内部类；对测试有用 2、内部静态类不需要有指向外部类的引用 3、静态类只能访问外部类的静态成员，不能访问外部类的非静态成员

non static class（非静态内部类）

1、非静态内部类需要持有对外部类的引用 2、非静态内部类能够访问外部类的静态和非静态成员 3、一个非静态内部类不能脱离外部类实体被创建 4、一个非静态内部类可以访问外部类的数据和方法

java多态的实现原理

https://www.cnblogs.com/startRuning/p/5673485.html

foreach与正常for循环效率对比

用for循环arrayList 10万次花费时间：5毫秒
用foreach循环arrayList 10万次花费时间：7毫秒
用for循环linkList 10万次花费时间：4481毫秒
用foreach循环linkList 10万次花费时间：5毫秒

循环ArrayList时，普通for循环比foreach循环花费的时间要少一点 循环LinkList时，普通for循环比foreach循环花费的时间要多很多

当我将循环次数提升到一百万次的时候，循环ArrayList，普通for循环还是比foreach要快一点；但是普通for循环在循环LinkList时，程序直接卡死。

ArrayList：ArrayList是采用数组的形式保存对象的，这种方式将对象放在连续的内存块中，所以插入和删除时比较麻烦，查询比较方便。

LinkList：LinkList是将对象放在独立的空间中，而且每个空间中还保存下一个空间的索引，也就是数据结构中的链表结构，插入和删除比较方便，但是查找很麻烦，要从第一个开始遍历。

结论：

需要循环数组结构的数据时，建议使用普通for循环，因为for循环采用下标访问，对于数组结构的数据来说，采用下标访问比较好。

需要循环链表结构的数据时，一定不要使用普通for循环，这种做法很糟糕，数据量大的时候有可能会导致系统崩溃。

Java IO与NIO

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

概念解释

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

每一种基本 Java 类型都有一种缓冲区类型：



 

ByteBuffer——byte  

CharBuffer——char  

ShortBuffer——short  

IntBuffer——int  

LongBuffer——long  

FloatBuffer——float  

DoubleBuffer——double



 

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

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

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

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

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

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

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

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

NIO和IO适用场景

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

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

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

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

通俗解释，最后，对于NIO和传统IO

有一个网友讲的生动的例子：

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

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

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

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

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

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

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

java反射的作用于原理

什么是Java的反射呢？

Java 反射是可以让我们在运行时，通过一个类的Class对象来获取它获取类的方法、属性、父类、接口等类的内部信息的机制

这种动态获取信息以及动态调用对象的方法的功能称为JAVA的反射。

反射的作用？

反射就是：在任意一个方法里：

1.如果我知道一个类的名称/或者它的一个实例对象， 我就能把这个类的所有方法和变量的信息找出来(方法名，变量名，方法，修饰符，类型，方法参数等等所有信息)

2.如果我还明确知道这个类里某个变量的名称，我还能得到这个变量当前的值。

3.当然，如果我明确知道这个类里的某个方法名+参数个数类型，我还能通过传递参数来运行那个类里的那个方法。

反射机制主要提供了以下功能：




  •  
  • 在运行时判断任意一个对象所属的类；


     
  • 在运行时构造任意一个类的对象；


     
  • 在运行时判断任意一个类所具有的成员变量和方法；


     
  • 在运行时调用任意一个对象的方法；


     
  • 生成动态代理。


     

反射的原理？

JAVA语言编译之后会生成一个.class文件，反射就是通过字节码文件找到某一个类、类中的方法以及属性等。

反射的实现API有哪些？

反射的实现主要借助以下四个类：



 

Class：类的对象

Constructor：类的构造方法

Field：类中的属性对象

Method：类中的方法对象



 

反射的实例

http://blog.csdn.net/xuefeng_yang/article/details/49497415

http://www.cnblogs.com/zhaoyanjun/p/6074887.html

泛型常用特点

泛型常用特点，List能否转为List

不可以强转类型的

这个问题涉及到了，范型向上转型 和 范型向下转型问题。

List向上转换至List（等价于List）会丢失String类的身份（String类型的特有接口）

当需要由List向下转型时，你的程序必须明确的知道将对象转换成何种具体类型，不然这将是不安全的操作！

如果要强转类型,Json 序列化转型



 

List str = new ArrayList();

List obj= JSONObject.parseArray(JSONObject.toJSONString(str));

 
  


  
 
  
或者遍历，或者克隆，但是取出来就是（Object）了，需要强转，String 因为类型丢了
 
  
解析XML的几种方式的原理与特点：DOM、SAX
 
  
Android中三种常用解析XML的方式（DOM、SAX、PULL）简介及区别
 
  
http://blog.csdn.net/cangchen/article/details/44034799
 
  
xml解析的两种基本方式：DOM和SAX的区别是?
 
  


  
 
  
DOM: document object model。

SAX: simple api for xml 。


 
  


  
 
  
dom一次性把xml文件全部加载到内存中简历一个结构一摸一样的树， 效率低
 SAX解析器的优点是解析速度快，占用内存少，效率高
 
  
DOM在内存中以树形结构存放，因此检索和更新效率会更高。但是对于特别大的文档，解析和加载整个文档将会很耗资源
 
  
DOM，它是生成一个树，有了树以后你搜索、查找都可以做
SAX，它是基于流的，就是解析器从头到尾解析一遍xml文件，解析完了以后你不过想再查找重新解析
 sax解析器核心是事件处理机制。例如解析器发现一个标记的开始标记时，将所发现的数据会封装为一个标记开始事件，并把这个报告给事件处理器，
 
  
平时工作中，xml解析你是使用什么？
 
  


  
 
  
JDOM

DOM4J


 
  


  
 
  
Java1.7与1.8,1.9.10 新特性
 
  
1.5
 
  
     
   



  1.    
    2.  
   
  2. 自动装箱与拆箱


       
    3.  
   
  3. 枚举(常用来设计单例模式)


       
    4.  
   
  4. 静态导入


       
    5.  
   
  5. 可变参数


       
    6.  
   
  6. 内省


       
    7.  
  
 
  
1.6
 
  
     
   



  1.    
    2.  
   
  2. Web服务元数据


       
    3.  
   
  3. 脚本语言支持


       
    4.  
   
  4. JTable的排序和过滤


       
    5.  
   
  5. 更简单,更强大的JAX-WS


       
    6.  
   
  6. 轻量级Http Server


       
    7.  
   
  7. 嵌入式数据库 Derby


       
    8.  
  
 
  
1.7
 
  
     
   



  1.    
    2.  
   
  2. switch中可以使用字串了


       
    3.  
   
  3. 运用List tempList = new ArrayList<>(); 即泛型实例化类型自动推断


       
    4.  
   
  4. 语法上支持集合，而不一定是数组


       
    5.  
   
  5. 新增一些取环境信息的工具方法


       
    6.  
   
  6. Boolean类型反转，空指针安全,参与位运算


       
    7.  
   
  7. 两个char间的equals


       
    8.  
   
  8. 安全的加减乘除


       
    9.  
   
  9. map集合支持并发请求，且可以写成 Map map = {name:”xxx”,age:18};


       
    10.  
  
 
  
1.8
 
  
     
   



  1.    
    2.  
   
  2. 允许在接口中有默认方法实现


       
    3.  
   
  3. Lambda表达式


       
    4.  
   
  4. 函数式接口


       
    5.  
   
  5. 方法和构造函数引用


       
    6.  
   
  6. Lambda的范围


       
    7.  
   
  7. 内置函数式接口


       
    8.  
   
  8. Streams


       
    9.  
   
  9. Parallel Streams


       
    10.  
   
  10. Map


       
    11.  
   
  11. 时间日期API


       
    12.  
   
  12. Annotations


       
    13.  
  
 
  
1.9
 
  
     
   



  1.    
    2.  
   
  2. Jigsaw 项目;模块化源码


       
    3.  
   
  3. 简化进程API


       
    4.  
   
  4. 轻量级 JSON API


       
    5.  
   
  5. 钱和货币的API


       
    6.  
   
  6. 改善锁争用机制


       
    7.  
   
  7. 代码分段缓存


       
    8.  
   
  8. 智能Java编译, 第二阶段


       
    9.  
   
  9. HTTP 2.0客户端


       
    10.  
   
  10. Kulla计划: Java的REPL实现


       
    11.  
  
 
  
10
 
  
     
   



  1.    
    2.  
   
  2. 本地变量类型推断


       
    3.  
   
  3. 统一JDK仓库


       
    4.  
   
  4. 垃圾回收器接口


       
    5.  
   
  5. G1的并行Full GC


       
    6.  
   
  6. 应用程序类数据共享


       
    7.  
   
  7. ThreadLocal握手机制


       
    8.  
  
 
  
设计模式：单例、工厂、适配器、责任链、观察者等等
 
  
【示例】设计模式——单例模式、工厂模式、代理模式、观察者模式、装饰器模式
 
  
http://blog.csdn.net/learrrrrrrrn/article/details/66476691
 
  
菜鸟教程-设计模式
 
  
http://www.runoob.com/design-pattern/design-pattern-intro.html
 
  
什么是设计模式
 
  
设计模式是一种解决方案，用于解决在软件设计中普遍存在的问题，是前辈们对之前软件设计中反复出现的问题的一个总结。
 
  
我们学设计模式，是为了学习如何合理的组织我们的代码，如何解耦，如何真正的达到对修改封闭对扩展开放的效果，而不是去背诵那些类的继承模式，然后自己记不住，回过头来就骂设计模式把你的代码搞复杂了，要反设计模式。
 
  
设计模式的六大原则
 
  
     
   



  •    
    •  
   
  • 开闭原则：实现热插拔，提高扩展性。


       
    •  
   
  • 里氏代换原则：实现抽象的规范，实现子父类互相替换；


       
    •  
   
  • 依赖倒转原则：针对接口编程，实现开闭原则的基础；


       
    •  
   
  • 接口隔离原则：降低耦合度，接口单独设计，互相隔离；


       
    •  
   
  • 迪米特法则，又称不知道原则：功能模块尽量独立；


       
    •  
   
  • 合成复用原则：尽量使用聚合，组合，而不是继承；


       
    •  
  
 
  
1、开闭原则（Open Close Principle）
 
  
开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
 
  
2、里氏代换原则（Liskov Substitution Principle）
 
  
里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
 
  
3、依赖倒转原则（Dependence Inversion Principle）
 
  
这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
 
  
4、接口隔离原则（Interface Segregation Principle）
 
  
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
 
  
5、迪米特法则，又称最少知道原则（Demeter Principle）
 
  
最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
 
  
6、合成复用原则（Composite Reuse Principle）
 
  
合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。
 
  
JNI的使用
 
  
https://www.cnblogs.com/larryzeal/p/5687392.html
 
  
JNI是 Java Native Interface 的缩写，它提供了若干的API实现了Java和其他语言的通信（主要是C&C++）。从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他编程语言，只要调用约定受支持就可以了。使用java与本地已编译的代码交互，通常会丧失平台可移植性。
 
  
JNI步骤
 
  
     
   



  1.    
    2.  
   
  2. java类中编写带有native 声明的方法。


       
    3.  
   
  3. 使用 javac 命令编译所编写的java类。


       
    4.  
   
  4. 使用 javah 命令生成头文件。


       
    5.  
   
  5. 使用C/C++实现本地方法。


       
    6.  
   
  6. 生成动态连接库。


       
    7.  
   
  7. 执行（java）。


       
    8.  
  
 
  
JNI实例
 
  


  
 
  
public class HelloWorld {

    public native void displayHelloWorld();//所有native关键词修饰的都是对本地的声明

    static {

        System.loadLibrary("hello");//载入本地库

    }

    public static void main(String[] args) {

        new HelloWorld().displayHelloWorld();

    }

}


 
  


  
 
  
AOP是什么
 
  
AOP(Aspect Oriented Programming) 面向切面编程，是目前软件开发中的一个热点，是Spring框架内容，利用AOP可以对业务逻辑的各个部分隔离，从而使的业务逻辑各部分的耦合性降低，提高程序的可重用性，踢开开发效率，主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等。
 
  
AOP实现原理是java动态代理，但是jdk的动态代理必须实现接口，所以spring的aop是用cglib这个库实现的，cglis使用里asm这个直接操纵字节码的框架，所以可以做到不使用接口的情况下实现动态代理。
 
  
OOP是什么
 
  
OOP面向对象编程，针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分
 
  
AOP与OOP的区别
 
  
OOP面向对象编程，针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程的某个步骤或阶段，以获得逻辑过程的中各部分之间低耦合的隔离效果。这两种设计思想在目标上有着本质的差异。
 
  
举例：
 
  
对于“雇员”这样一个业务实体进行封装，自然是OOP的任务，我们可以建立一个“Employee”类，并将“雇员”相关的属性和行为封装其中。而用AOP 设计思想对“雇员”进行封装则无从谈起。
 
  
同样，对于“权限检查”这一动作片段进行划分，则是AOP的目标领域。
 
  
OOP面向名次领域，AOP面向动词领域。
 
  
总之AOP可以通过预编译方式和运行期动态代理实现在不修改源码的情况下，给程序动态同意添加功能的一项技术。
 
  
 
 
  

 转载：https://www.cnblogs.com/shihaiming/p/9413588.html

 推荐内容：
windows一键部署java项目
阿里面试回来，想和Java程序员谈一谈
java后端面试
Java面试通关要点汇总整理【终极版】
Java常见面试题
50道Java线程面试题（转载）
最近面试java后端开发的感受：如果就以平时项目经验来面试，通过估计很难——再论面试前的准备
java面试常考题
java常见报错及解决
53道Java线程面试题
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java面试)

        

            

                
    
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • 题解 | #完全数计算#不知道为什么没超时的暴力解法
                        huaxinjiayou
java
                        
    兄弟们，坚持就是胜利啊，找工作从去年秋招就开始找，到五月底才收到第一个offer星环的，然后六月初t咋六月了还有面试啊，有兄弟了解这个部门吗面完了家人们，纯纯kpi啊，上来就是一道题是打印多个字符串的华为接头人话术指南：欲投华为，必看此贴!引流华为招聘提前批【奖】这个夏天，和牛牛一起打卡刷题~Java面试实战项目25届本科找暑期实习的历程飞猪旅行运营岗面经百度视觉算法一面面经感谢牛友们，腾子pcg
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入解析JVM中的Serial GC：工作原理与代际区别
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈SerialGC工作原理年轻代垃圾回收MinorGC老年代垃圾回收MajorGCFullGC年轻代和老年代的区别SerialGC垃圾收集器单线程垃圾收集器
                        
    目录引言：正文：一、SerialGC工作原理年轻代垃圾回收（MinorGC）：老年代垃圾回收（MajorGC或FullGC）：二、年轻代和老年代的区别年轻代（YoungGeneration）：老年代（OldGeneration）：结束语：引言：Java虚拟机（JVM）作为Java程序的运行环境，其性能和稳定性在很大程度上依赖于垃圾收集器（GC）的效率。SerialGC是JVM中最古老也是最简单的一
    
                    
    • 
                    
  • Java面试必问之Hashmap底层实现原理(JDK1.7)
                        当我遇上你csy
Java基础javahashmap面试源码
                        
    1.前言Hashmap可以说是Java面试必问的，一般的面试题会问:Hashmap有哪些特性？Hashmap底层实现原理(get\put\resize)Hashmap怎么解决hash冲突？Hashmap是线程安全的吗？…今天就从源码角度一探究竟。笔者的源码是OpenJDK1.72.构造方法首先看构造方法的源码//默认初始容量staticfinalintDEFAULT_INITIAL_CAPACIT
    
                    
    • 
                    
  • 程序员必看：图解 Spring 循环依赖，看过之后再也不怕面试了
                        陪伴她的梦

                        
    前言Spring如何解决的循环依赖，是近两年流行起来的一道Java面试题。其实笔者本人对这类框架源码题还是持一定的怀疑态度的。如果笔者作为面试官，可能会问一些诸如“如果注入的属性为null，你会从哪几个方向去排查”这些场景题。那么既然写了这篇文章，闲话少说，发车看看Spring是如何解决的循环依赖，以及带大家看清循环依赖的本质是什么。正文通常来说，如果问Spring内部如何解决循环依赖，一定是单默
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之JVM大厂面试题及答案解析（5）
                        青云交
Java虚拟机（JVM）专栏Java大厂面试题javajvm垃圾收集器类加载器JVM面试题JVM大厂面试题及答案解析
                        
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之未来已来：为什么ZGC是大规模Java应用的终极武器？
                        青云交
Java虚拟机（JVM）专栏Java技术栈Javajavajvm大规模Java应用的终极武器ZGC的技术进化历程ZGC的优势解析ZGC在不同场景中的应用ZGC未来发展和改进方向
                        
    亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
    
                    
    • 
                    
  • Java面试题真题·技术面试题部分总结
                        攸攸太上
Java面试题总结--攸攸太上java学习
                        
    系列文章目录Java面试题真题·技术面试题部分总结Java面试题真题·融资管理系统项目介绍文章目录系列文章目录前言技术问题Java的跨平台原理String常用方法分布式的优点对cookie有什么了解，Cookie和Session的区别最熟悉jdk哪个版本redis的部署方式mysql的配置和安装熟不熟悉如何配置多集群mysqlspringboot分布式有了解吗http和https的区别，https
    
                    
    • 
                    
  • Java面试题 -- SpringBoot面试题二(Spring Boot 是微服务中最好的 Java 框架)
                        Liberty-895
JavaWeb高级Java面试题
                        
    问题一path=”users”,collectionResourceRel=”users”如何与SpringDataRest一起使用？@RepositoryRestResource(collectionResourceRel="users",path="users")publicinterfaceUserRestRepositoryextendsPagingAndSortingRepository
    
                    
    • 
                    
  • 从面试官的角度，聊聊java面试流程
                        hsm_computer
程序人生面试java面试spring
                        
    在这篇回答里，就讲以我常规的面试流程为例，说下java方面大致会问什么问题，以及如何确认候选人达到招聘要求。先说面试前准备，可能有些面试官是拿到简历直接问，而且是在候选人自我介绍时再草草浏览简历，但我不是这样。1问招人的项目经理，这个岗位需要的技术什么，比如必须Springboot，有数据库调优经验优先考虑，要有2到3年相关经验等等。问清楚了，我就好在面试中组织自己的问题。2浏览候选人的简历，找出
    
                    
    • 
                    
  • 最新java面试笔试编程题
                        Mr_张三阿
Java面试java笔试面试题java编程题
                        
    【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？//这是一个菲波拉契数列问题publicclasslianxi01{publicstaticvoidmain(String[]args){System.out.println("第1个月的兔子对数:1");System.out.println
    
                    
    • 
                    
  • 【Java面试题-001】什么是JVM?为什么称Java为跨平台的编程语言？
                        陈春满
JavaSEjvm编程语言跨平台面试题虚拟机
                        
    1.什么是JVM?为什么称Java为跨平台的编程语言？答：①概述：JVM是Java虚拟机的英文简称。全称为JavaVirtualMachine。②用途：JVM是用来执行Java字节码的虚拟机，每个Java源文件将被编译成字节码文件(即.class文件)，然后在JVM中执行。③作用：-->Java之所以可以跨平台，关键因为JVM屏蔽了与具体操作系统平台相关的信息，只需要有经过编译的字节码(.clas
    
                    
    • 
                    
  • java面试--http和https的区别
                        望山。
面试题httphttps
                        
    先来观察这两张图，第一张访问域名http://www.12306.cn，谷歌浏览器提示不安全链接，第二张是https://kyfw.12306.cn/otn/regist/init，浏览器显示安全，为什么会这样子呢？2017年1月发布的Chrome56浏览器开始把收集密码或信用卡数据的HTTP页面标记为“不安全”，若用户使用2017年10月推出的Chrome62，带有输入数据的HTTP页面和所有以
    
                    
    • 
                    
  • 这可能是全网最详细的 Spring Cloud OAuth2 单点登录使用教程了，妈妈再也不用担心我被面试官吊打了！
                        2401_84558091
程序员java面试学习
                        
    最后对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收
    
                    
    • 
                    
  • 大厂Java面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？
                        技术范王有志
大厂Java面试题mybatisjava面试后端
                        
    大家好，我是王有志。今天给大家带来的是一道来自京东的关于MyBatis实现分页功能的面试题：MyBatis是如何进行分页的？分页插件的实现原理是什么？通常，分页的方式可以分为两种：逻辑（内存）分页物理分页逻辑（内存）分页指的是数据库返回全部符合条件的数据，然后再通过程序代码对数据结果进行分页处理；物理分页指的是通过SQL语句查询，由数据库返回分页后的查询结果。逻辑（内存）分页和物理分页各有优缺点，
    
                    
    • 
                    
  • Java面试复习总结03
                        ok!ko
java面试开发语言
                        
    Java面试复习总结031、什么是SPI？2、SPI和API有什么区别？3、使用SPI机制的原因？4、SPI机制的优缺点？1、什么是SPI？SPI即ServiceProviderInterface，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。SPI将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之JVM大厂面试题及答案解析（7）
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏javajvmJVM大厂面试题及答案解析字节码校验内存管理多线程分布式系统
                        
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之Java工程师必备：顶尖工具助你全面监控和分析CMS GC性能（1）
                        青云交
工具秘籍Java虚拟机（JVM）专栏Java大厂面试题javajvm顶尖工具监控和分析CMSGCJConsoleVisualVMGC日志分析JProfilerPrometheus+Graf
                        
    亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之低停顿、高性能：深入解析ZGC的优势
                        青云交
Java虚拟机（JVM）专栏Java技术栈JavaGC机制概述javaJVM大厂面试题ZGC与CMSG1的深度对比GC优化在线教育平台案例GC优化电子商务网站案例低停顿高性能：深入解析ZGC
                        
    亲爱的朋友们，热烈欢迎你们来到我的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：1.Ja
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之揭秘：如何通过优化 CMS GC 提升各行业服务器响应速度
                        青云交
java学习Java虚拟机（JVM）专栏JavajavajvmGC（垃圾回收）的优化CMSGC实战案例教育行业CMSGC实战案例游戏行业CMSGC实战案例医疗行业CMSGC实战案例金融行业
                        
    Java面试题--JVM大厂篇之揭秘：如何通过优化CMSGC提升各行业服务器响应速度引言：正文：一、游戏行业1.问题：2.优化措施：二、在线教育行业1.问题：2.优化措施：三、医疗信息化行业1.问题：2.优化措施：四、金融科技行业1.问题：2.优化措施：结束语：引言：早上好，亲爱的各位Java开发者们！在大规模Java应用的浩瀚世界里，性能优化始终是我们聚焦的核心要点，尤其是当我们面对那些对响应速
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之高并发Java应用的秘密武器：深入剖析GC优化实战案例
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Javajavajvm不同场景中优化CMSGC高并发Java应用的秘密武器CMSGC电商实战优化案例CMSGC大数据优化案例CMSGC金融系统优化案例
                        
    引言：晚上好，Java开发者们！在高并发的现代应用中，垃圾回收器（GC）是Java性能优化的重要环节。尤其在CMS（ConcurrentMark-Sweep）GC曾经担任主角的日子里，适当的调优和优化措施至关重要。本篇文章将通过三个实际案例，探讨如何在不同场景中优化CMSGC，为你揭示Java性能调优的秘密。vQingYunJiao，无论你是新手还是资深工程师，希望这篇文章能为你提供实践中的宝贵经
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之破解Java性能瓶颈！深入理解Parallel GC并优化你的应用
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈javajvmParallelGC的工作原理配置ParallelGC深入理解ParallelGC监控和分析GC日志常见调优技巧
                        
    目录引言：正文：1.理解ParallelGC的工作原理2.配置ParallelGC3.监控和分析GC日志4.常见调优技巧5.持续迭代和优化结束语：补充考虑1.综合考虑吞吐量与响应时间2.评估和优化垃圾回收频率3.动态调整与自适应策略最佳实践定期基准测试与压力测试实时监控与告警机制探索替代垃圾回收器结论引言：在现代Java应用程序中，垃圾回收（GarbageCollection,GC）作为JVM核心
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入探讨Serial GC的应用场景
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈jvmSerialGCSerialGC的工作原理垃圾回收器复制算法和标记-清除-压缩算法SerialGC适用场景SerialGC参数配置
                        
    目录引言:正文:一、什么是SerialGC？二、SerialGC的工作原理三、适用场景单处理器环境在单处理器环境下，SerialGC是一个非常好的选择。由于没有多余的处理器资源，单线程的垃圾回收操作不会导致额外的上下文切换开销，从而能够最大化地利用CPU资源。小型应用对于小型应用程序，特别是那些堆内存较小且垃圾回收频率较低的应用，SerialGC能够提供足够的性能。由于其实现简单，SerialGC
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入解析G1 GC——革新Java垃圾回收机制
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈javajvm开发语言G1GC的区域划分及其作用伊甸园区幸存者区老年代区
                        
    目录引言:正文：一、G1GC的区域划分及其作用1.伊甸园区（EdenRegion）2.幸存者区（SurvivorRegion）3.老年代区（OldGenerationRegion）二、区域划分的优势:三、图片解析:结束语：引言:在Java应用开发中，性能优化始终是一个重要而又棘手的话题。尤其是垃圾回收（GC）机制，常常是影响应用性能的关键因素。G1GarbageCollector（Garbage-
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入了解Java虚拟机（JVM）：工作机制与优化策略
                        青云交
Java大厂面试题Java技术栈Java虚拟机（JVM）专栏javajvm开发语言工作机制与优化策略JVM的基本工作原理JVM性能优化策略JVM调优实例
                        
    引言：Java虚拟机（JavaVirtualMachine，简称JVM）是Java程序员绕不开的主题。作为Java语言的执行平台，JVM不仅为Java程序提供了平台无关性，还承担了内存管理、线程管理和垃圾回收等复杂任务。了解JVM的工作机制和优化策略，对于提升Java应用的性能具有重要意义。正文：一、JVM的基本工作原理要理解JVM，我们首先需要了解它的基本工作原理。JVM在运行时负责将Java字
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入解析JVM运行时数据区：Java开发者必读
                        青云交
Java大厂面试题Java技术栈Java虚拟机（JVM）专栏javaJava虚拟机的运行时数据区JVM运行时数据区程序计数器Java虚拟机栈本地方法栈堆（Heap）方法区或元空间
                        
    引言：Java虚拟机（JVM）是Java编程语言的重要组件，它不仅实现了Java程序的跨平台特性，还高度关注内存管理和性能优化。在JVM的体系结构中，运行时数据区是实现这些特性的关键部分。本文将详细介绍JVM的运行时数据区及其各部分的作用，以帮助开发者更好地理解和优化Java程序。正文：在Java虚拟机（JVM）的运行时数据区中，主要分为若干内存区域，这些区域各自承担着不同的职责。了解这些区域及其
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之掌握JVM性能优化：选择合适的垃圾回收器
                        青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈JVM串行垃圾回收器并行垃圾回收器并发标记清除垃圾回收器GarbageFirst选择合适的垃圾回收器GC
                        
    掌握JVM性能优化：选择合适的垃圾回收器引言:  在Java开发中，性能优化往往是提高应用稳定性和用户体验的关键所在。而垃圾回收器的选择和优化，是JVM性能调优的核心环节。如何在众多垃圾回收器中选出适合自己应用需求的那一个？如何通过合理配置和监控，最大限度地提升系统效率？本文将为你详细解析。正文:1.了解不同垃圾回收器的特点SerialGC（串行垃圾回收器）：适用场景：小型单线程应用。优点：实现简
    
                    
    • 
                    
  • Java面试题--JVM大厂篇（1-10）
                        青云交
java学习路线Java大厂面试题JavajvmJavaJVM类加载器栈内存溢出Java面试题Java内存模型（JMM）MinorGC与FullGC
                        
    引言：在这个信息时代，对于准备进入大厂工作的朋友们来说，对于JVM（Java虚拟机）的掌握是面试中的一项重要内容。下面是一些精选的JVM面试题，希望对大家能有所帮助。正文：1.JVM有哪几种垃圾收集器？每种的特点是什么？JVM主要有以下几种垃圾收集器：Serial收集器、ParNew收集器、Parallel收集器、CMS收集器和G1收集器。每种垃圾收集器都有各自的特点，比如Serial是单线程的垃
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •