1、既然有GC机制，为何还会有内存泄漏的状况?
理论上Java因为有垃圾接纳机制（GC）不会存在内存泄漏题目（这也是Java被普遍运用于服务器端编程的一个重要原因）。但是在现实开辟中，可以会存在无用但可达的对象，这些对象不能被GC接纳，因而也会致使内存泄漏的发作。
比方hibernate的Session（一级缓存）中的对象属于耐久态，垃圾接纳器是不会接纳这些对象的，但是这些对象中可以存在无用的垃圾对象，假如不实时封闭（close）或清空（flush）一级缓存就可以致使内存泄漏。
下面例子中的代码也会致使内存泄漏。
import java.util.Arrays;
import java.util.EmptyStackException;
public class MyStack<T> {
private T[] elements;
private int size = 0;
private static final int INIT_CAPACITY = 16;
public MyStack() {
elements = (T[]) new Object[INIT_CAPACITY];
}
public void push(T elem) {
ensureCapacity();
elements[size++] = elem;
}
public T pop() {
if (size == 0) throw new EmptyStackException();
return elements[--size];
}
private void ensureCapacity() {
if (elements.length == size) {
elements = Arrays.copyOf(elements,2 * size + 1);
}
}
}
上面的代码完成了一个栈（先进后出（FILO））构造，乍看之下好像没有什么显著的题目，它以至可以经由过程你编写的种种单元测试。
但是个中的pop要领却存在内存泄漏的题目，当我们用pop要领弹出栈中的对象时，该对象不会被看成垃圾接纳，纵然运用栈的递次不再援用这些对象，因为栈内部维护着对这些对象的逾期援用（obsolete reference）。在支撑垃圾接纳的言语中，内存泄漏是很隐藏的，这类内存泄漏着实就是无意识的对象坚持。
假如一个对象援用被无意识的保留起来了，那末垃圾接纳器不会处置惩罚这个对象，也不会处置惩罚该对象援用的其他对象，纵然如许的对象只需少数几个，也可以会致使许多的对象被消除在垃圾接纳以外，从而对机能形成严重影响，极度状况下会激发Disk Paging（物理内存与硬盘的虚拟内存交流数据），以至形成OutOfMemoryError。
2、Java中为何会有GC机制呢？
·安全性斟酌；--for security.
·削减内存泄漏；--erase memory leak in some degree.
·削减递次员事情量。--Programmers dont worry about memory releasing.
3、关于Java的GC哪些内存须要接纳？
内存运转时JVM会有一个运转时数据区来治理内存。
它重要包含5大部分：
递次计数器(Program CounterRegister)；
虚拟机栈(VM Stack)；
当地要领栈(Native Method Stack)；
要领区(Method Area)；
堆(Heap)。
而个中递次计数器、虚拟机栈、当地要领栈是每一个线程私有的内存空间，随线程而生，随线程而亡。比方栈中每一个栈帧中分派若干内存基本上在类构造肯定是哪一个时就已知了，因而这3个地区的内存分派和接纳都是肯定的，无需斟酌内存接纳的题目。
但要领区和堆就差别了，一个接口的多个完成类须要的内存可以不一样，我们只需在递次运转时期才会晓得会建立哪些对象，这部分内存的分派和接纳都是动态的，GC重要关注的是这部分内存。总而言之，GC重要举行接纳的内存是JVM中的要领区和堆。
4、Java的GC什么时候接纳垃圾？
在口试中经常会遇到如许一个题目（事实上笔者也遇到过）：如何推断一个对象已死去？
很轻易想到的一个答案是：对一个对象增加援用计数器。每当有处所援用它时，计数器值加1；当援用失效时，计数器值减1.而当计数器的值为0时这个对象就不会再被运用，推断为已死。是不是是简朴又直观。
但是，很遗憾。这类做法是毛病的！为何是错的呢？事实上，用援用计数法确着实大部分状况下是一个不错的处理方案，而在现实的运用中也有不少案例，但它却没法处理对象之间的轮回援用题目。
比方对象A中有一个字段指向了对象B，而对象B中也有一个字段指向了对象A，而事实上他们俩都不再运用，但计数器的值永久都不可以为0，也就不会被接纳，然后就发作了内存泄漏。
准确的做法应该是如何呢？
在Java，C#等言语中，比较主流的剖断一个对象已死的要领是：可达性剖析(Reachability Analysis).一切生成的对象都是一个称为"GC Roots"的根的子树。
从GC Roots最先向下搜刮，搜刮所经由的途径称为援用链(Reference Chain)，当一个对象到GC Roots没有任何援用链可以抵达时，就称这个对象是不可达的（不可援用的），也就是可以被GC接纳了。
不管是援用计数器照样可达性剖析，剖断对象是不是存活都与援用有关！那末，如何定义对象的援用呢？
我们愿望给出如许一类形貌：当内存空间还够时，可以保留在内存中；假如举行了垃圾接纳以后内存空间依旧异常慌张，则可以扬弃这些对象。所以依据差别的需求，给出以下四种援用，依据援用范例的差别，GC接纳时也会有差别的操纵：
强援用(Strong Reference):Object obj=new Object();只需强援用还存在，GC永久不会接纳掉被援用的对象。
软援用(Soft Reference)：形貌一些还有效但非必须的对象。在体系将会发作内存溢出之前，会把这些对象列入接纳局限举行二次接纳（即体系将会发作内存溢出了，才会对他们举行接纳）
弱援用(Weak Reference):水平比软援用还要弱一些。这些对象只能生存到下次GC之前。当GC事情时，不管内存是不是充足都邑将其接纳（即只需举行GC，就会对他们举行接纳。）
虚援用(Phantom Reference):一个对象是不是存在虚援用，完整不会对其生存时候组成影响。关于要领区中须要接纳的是一些烧毁的常量和无用的类。
1.烧毁的常量的接纳。这里看援用计数就可以了。没有对象援用该常量就可以宁神的接纳了。
2.无用的类的接纳。什么是无用的类呢？
A.该类一切的实例都已被接纳。也就是Java堆中不存在该类的任何实例；
B加载该类的ClassLoader已被接纳；
C.该类对应的java.lang.Class对象没有任何处所被援用，没法在任何处所经由过程反射接见该类的要领。
总而言之:关于堆中的对象，重要用可达性剖析推断一个对象是不是还存在援用，假如该对象没有任何援用就应该被接纳。而依据我们现实对援用的差别需求，又分成了4种援用，每种援用的接纳机制也是差别的。
关于要领区中的常量和类，当一个常量没有任何对象援用它，它就可以被接纳了。而关于类，假如可以剖断它为无用类，就可以被接纳了。
5、经由过程10个示例来开端熟悉Java8中的lambda表达式
用lambda表达式完成Runnable
// Java 8 之前：
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("Before Java8， too much code for too little to do");
}}).start();
//Java 8 体式格局：
new Thread(()->System.out.println("In Java8， Lambda expression rocks !!")).start();
输出：
too much code，for too little to do Lambda expression rocks!!
这个例子向我们展现了Java 8 lambda表达式的语法。你可以运用lambda写出以下代码：
(params) -> expression (params) -> statement
(params) -> { statements }
比方，假如你的要领不对参数举行修正、重写，只是在控制台打印点东西的话，那末可以如许写：
() -> System.out.println("Hello Lambda Expressions");
假如你的要领吸收两个参数，那末可以写成以下如许：
(int even， int odd) -> even + odd
趁便提一句，一般都邑把lambda表达式内部变量的名字起得短一些。如许能使代码更简短，放在统一行。所以，在上述代码中，变量名选用a、b或许x、y会比even、odd要好。
运用Java 8 lambda表达式举行事宜处置惩罚
假如你用过Swing API编程，你就会记得如何写事宜监听代码。这又是一个旧版本简朴匿名类的典范用例，但如今可以不如许了。你可以用lambda表达式写出更好的事宜监听代码，以下所示：
// Java 8 之前：
JButton show = new JButton("Show"); show.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Event handling without lambda expression is boring");
}
});
// Java 8 体式格局：
show.addActionListener((e) -> {
System.out.println("Light， Camera， Action !! Lambda expressions Rocks");
});
运用Java 8 lambda表达式举行事宜处置惩罚 运用lambda表达式对列表举行迭代
假如你使过几年Java，你就晓得针对鸠合类，最常见的操纵就是举行迭代，并将营业逻辑运用于各个元素，比方处置惩罚定单、生意业务和事宜的列表。
因为Java是敕令式言语，Java 8之前的一切轮回代码都是递次的，即可以对其元素举行并行化处置惩罚。假如你想做并行过滤，就须要本身写代码，这并非那末轻易。
经由过程引入lambda表达式和默许要领，将做什么和怎样做的题目分开了，这意味着Java鸠合如今晓得如何做迭代，并可以在API层面临鸠合元素举行并行处置惩罚。
下面的例子里，我将引见如安在运用lambda或不运用lambda表达式的状况下迭代列表。你可以看到列表如今有了一个forEach()要领，它可以迭代一切对象，并将你的lambda代码运用在个中。
// Java 8 之前：
List features = Arrays.asList("Lambdas"， "Default Method"， "Stream API"，"Date and Time API");
for (String feature : features) {
System.out.println(feature);
}
// Java 8 以后：
List features = Arrays.asList("Lambdas"， "Default Method"， "Stream API"，"Date and Time API");
features.forEach(n -> System.out.println(n));
// 运用 Java 8 的要领援用更轻易，要领援用由::双冒号操纵符标示，
// 看起来像 C++的作用域剖析运算符
features.forEach(System.out::println);
输出：
Lambdas Default Method Stream API Date and Time API
列表轮回的末了一个例子展现了如安在Java 8中运用要领援用（method reference）。你可以看到C++内里的双冒号、局限剖析操纵符如今在Java 8中用来示意要领援用。
运用lambda表达式和函数式接口Predicate
除了在言语层面支撑函数式编程作风，Java 8也增加了一个包，叫做java.util.function。它包含了许多类，用来支撑Java的函数式编程。个中一个就是Predicate，运用java.util.function.Predicate函数式接口以及lambda表达式，可以向API要领增加逻辑，用更少的代码支撑更多的动态行动。下面是Java 8 Predicate的例子，展现了过滤鸠合数据的多种经常使用要领。Predicate接口异常适用于做过滤。
public static void main(String[]args){
List languages=Arrays.asList("Java", "Scala","C++", "Haskell", "Lisp");
System.out.println("Languages which starts with J :");
filter(languages, (str)->str.startsWith("J"));
System.out.println("Languages which ends with a ");
filter(languages, (str)->str.endsWith("a"));
System.out.println("Print all languages :");
filter(languages, (str)->true);
System.out.println("Print no language : ");
filter(languages, (str)->false);
System.out.println("Print language whose length greater than 4:");
filter(languages, (str)->str.length()>4);
}
public static void filter(List names, Predicate condition){
for(String name:names){
if(condition.test(name)){
System.out.println(name+" ");
}
}
}
// filter 更好的方法--filter 要领革新
public static void filter(List names, Predicate condition) {
names.stream().filter((name)->(condition.test(name))).forEach((name)->
{System.out.println(name + " ");
});
}
可以看到，Stream API的过滤要领也接收一个Predicate，这意味着可以将我们定制的filter()要领替换成写在内里的内联代码，这就是lambda表达式的魔力。别的，Predicate接口也许可举行多重前提的测试。
以上就是java gc 口试题及答案（1~5题）的细致内容，更多请关注ki4网别的相干文章！
