java宝典(5)

简介: java宝典(5)

66、描述一下JVM加载class文件的原理机制?

JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。



67、heap和stack有什么区别。

java的内存分为两类,一类是栈内存,一类是堆内存。栈内存是指程序进入一个方法时,会为这个方法单独分配一块私属存储空间,用于存储这个方法内部的局部变量,当这个方法结束时,分配给这个方法的栈会释放,这个栈中的变量也将随之释放。


堆是与栈作用不同的内存,一般用于存放不放在当前方法栈中的那些数据,例如,使用new创建的对象都放在堆里,所以,它不会随方法的结束而消失。方法中的局部变量使用final修饰后,放在堆中,而不是栈中。



68、GC是什么? 为什么要有GC?    

GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。



69、垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制,使c++程序员最头疼的内存管理的问题迎刃而解,它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制,Java中的对象不再有"作用域"的概念,只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收,增量垃圾回收。



70、垃圾回收器的基本原理是什么?垃圾回收器可以马上回收内存吗?有什么办法主动通知虚拟机进行垃圾回收?

对于GC来说,当程序员创建对象时,GC就开始监控这个对象的地址、大小以及使用情况。通常,GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的",哪些对象是"不可达的"。当GC确定一些对象为"不可达"时,GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc(),通知GC运行,但是Java语言规范并不保证GC一定会执行。




71、什么时候用assert。

assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。在实现中,assertion就是在程序中的一条语句,它对一个boolean表达式进行检查,一个正确程序必须保证这个boolean表达式的值为true;如果该值为false,说明程序已经处于不正确的状态下,assert将给出警告或退出。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后,assertion检查通常是关闭的。


package com.huawei.interview;



public class AssertTest {


/**


* @param args


*/


public static void main(String[] args) {

// TODO Auto-generated method stub


int i = 0;


for(i=0;i<5;i++)


{

System.out.println(i);


}


//假设程序不小心多了一句--i;


--i;


assert i==5;


}



}



72、java中会存在内存泄漏吗,请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制,它可以保证一对象不再被引用的时候,即对象编程了孤儿的时候,对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理,可以消除引用循环的问题,例如有两个对象,相互引用,只要它们和根进程不可达的,那么GC也是可以回收它们的,例如下面的代码可以看到这种情况的内存回收:


package com.huawei.interview;



import java.io.IOException;



public class GarbageTest {


/**


* @param args


* @throws IOException


*/


public static void main(String[] args) throws IOException {

// TODO Auto-generated method stub


try {

gcTest();


} catch (IOException e) {

// TODO Auto-generated catch block


e.printStackTrace();


}


System.out.println("has exited gcTest!");


System.in.read();


System.in.read();


System.out.println("out begin gc!");


for(int i=0;i<100;i++)


{

System.gc();


System.in.read();


System.in.read();


}


}



private static void gcTest() throws IOException {

System.in.read();


System.in.read();


Person p1 = new Person();


System.in.read();


System.in.read();


Person p2 = new Person();


p1.setMate(p2);


p2.setMate(p1);


System.out.println("before exit gctest!");


System.in.read();


System.in.read();


System.gc();


System.out.println("exit gctest!");


}



private static class Person


{

byte[] data = new byte[20000000];


Person mate = null;


public void setMate(Person other)


{

mate = other;


}


}


}



java中的内存泄露的情况:长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露,尽管短生命周期对象已经不再需要,但是因为长生命周期对象持有它的引用而导致不能被回收,这就是java中内存泄露的发生场景,通俗地说,就是程序员可能创建了一个对象,以后一直不再使用这个对象,这个对象却一直被引用,即这个对象无用但是却无法被垃圾回收器回收的,这就是java中可能出现内存泄露的情况,例如,缓存系统,我们加载了一个对象放在缓存中(例如放在一个全局map对象中),然后一直不再使用它,这个对象一直被缓存引用,但却不再被使用。


检查java中的内存泄露,一定要让程序将各种分支情况都完整执行到程序结束,然后看某个对象是否被使用过,如果没有,则才能判定这个对象属于内存泄露。



下面内容来自于网上(主要特点就是清空堆栈中的某个元素,并不是彻底把它从数组中拿掉,而是把存储的总数减少,本人写得可以比这个好,在拿掉某个元素时,顺便也让它从数组中消失,将那个元素所在的位置的值设置为null即可):


我实在想不到比那个堆栈更经典的例子了,以致于我还要引用别人的例子,下面的例子不是我想到的,是书上看到的,当然如果没有在书上看到,可能过一段时间我自己也想的到,可是那时我说是我自己想到的也没有人相信的。


   public class Stack {

   private Object[] elements=new Object[10];

   private int size = 0;

   public void push(Object e){

   ensureCapacity();

   elements[size++] = e;

   }

   public Object pop(){

   if( size == 0)


   throw new EmptyStackException();

   return elements[--size];

   }

   private void ensureCapacity(){

   if(elements.length == size){

   Object[] oldElements = elements;

   elements = new Object[2 * elements.length+1];

   System.arraycopy(oldElements,0, elements, 0, size);

   }

   }

   }

   上面的原理应该很简单,假如堆栈加了10个元素,然后全部弹出来,虽然堆栈是空的,没有我们要的东西,但是这是个对象是无法回收的,这个才符合了内存泄露的两个条件:无用,无法回收。


   但是就是存在这样的东西也不一定会导致什么样的后果,如果这个堆栈用的比较少,也就浪费了几个K内存而已,反正我们的内存都上G了,哪里会有什么影响,再说这个东西很快就会被回收的,有什么关系。下面看两个例子。


   例子1

   public class Bad{

   public static Stack s=Stack();

   static{

   s.push(new Object());

   s.pop(); //这里有一个对象发生内存泄露

   s.push(new Object()); //上面的对象可以被回收了,等于是自愈了

   }

   }

   因为是static,就一直存在到程序退出,但是我们也可以看到它有自愈功能,就是说如果你的Stack最多有100个对象,那么最多也就只有100个对象无法被回收其实这个应该很容易理解,Stack内部持有100个引用,最坏的情况就是他们都是无用的,因为我们一旦放新的进取,以前的引用自然消失!




73、下面程序的输出结果是多少?


import java.util.Date;


public  class Test extends Date{


/**


* @param args add by zxx ,Dec 9, 2008


*/


public static void main(String[] args) {

new Test().test();



}



public void test()


{

System.out.println(super.getClass().getName());


}


}


Public class Test1 extends Test{

Public static void main(String[] agrs){

New Test1().test();


}


Public void test(){

System.out.println(getClass().getSuperClass().getName());


}


}



很奇怪,结果是Test


这属于脑筋急转弯的题目,在一个qq群有个网友正好问过这个问题,我觉得挺有趣,就研究了一下,没想到今天还被你面到了,哈哈。


在test方法中,直接调用getClass().getName()方法,返回的是Test类名


由于getClass()在Object类中定义成了final,子类不能覆盖该方法,所以,在


test方法中调用getClass().getName()方法,其实就是在调用从父类继承的getClass()方法,等效于调用super.getClass().getName()方法,所以,super.getClass().getName()方法返回的也应该是Test。


如果想得到父类的名称,应该用如下代码:


getClass().getSuperClass().getName();


74、说出一些常用的类,包,接口,请各举5个

要让人家感觉你对java ee开发很熟,所以,不能仅仅只列core java中的那些东西,要多列你在做ssh项目中涉及的那些东西。就写你最近写的那些程序中涉及的那些类。



常用的类:BufferedReader  BufferedWriter  FileReader  FileWirter  String  Integer


java.util.Date,System,Class,List,HashMap



常用的包:java.lang   java.io  java.util  java.sql ,javax.servlet,org.apache.strtuts.action,org.hibernate


常用的接口:Remote  List  Map  Document  NodeList ,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate)、Session(Hibernate),HttpSession




2. 特高深的Java问题

75、能不能自己写个类,也叫java.lang.String?


可以,但在应用的时候,需要用自己的类加载器去加载,否则,系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中,都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类,然后才委托上级的类加载器加载,如果我们在tomcat的web应用程序中写一个java.lang.String,这时候Servlet程序加载的就是我们自己写的java.lang.String,但是这么干就会出很多潜在的问题,原来所有用了java.lang.String类的都将出现问题。



虽然java提供了endorsed技术,可以覆盖jdk中的某些类,具体做法是….。但是,能够被覆盖的类是有限制范围,反正不包括java.lang这样的包中的类。



(下面的例如主要是便于大家学习理解只用,不要作为答案的一部分,否则,人家怀疑是题目泄露了)例如,运行下面的程序:


package java.lang;



public class String {


/**


* @param args


*/


public static void main(String[] args) {

// TODO Auto-generated method stub


System.out.println("string");


}



}


报告的错误如下:


java.lang.NoSuchMethodError: main


Exception in thread "main"


这是因为加载了jre自带的java.lang.String,而该类中没有main方法。



76. Java代码查错

1.

abstract class Name {

  private String name;

  public abstract boolean isStupidName(String name) {}

}

大侠们,这有何错误?

答案: 错。abstract method必须以分号结尾,且不带花括号。

2.

public class Something {

  void doSomething () {

      private String s = "";

      int l = s.length();

  }

}

有错吗?

答案: 错。局部变量前不能放置任何访问修饰符 (private,public,和protected)。final可以用来修饰局部变量

(final如同abstract和strictfp,都是非访问修饰符,strictfp只能修饰class和method而非variable)。

3.

abstract class Something {

  private abstract String doSomething ();

}

这好像没什么错吧?

答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的,怎么可以用private把abstract

method封锁起来呢? (同理,abstract method前不能加final)。

4.

public class Something {

  public int addOne(final int x) {

      return ++x;

  }

}

这个比较明显。

答案: 错。int x被修饰成final,意味着x不能在addOne method中被修改。

5.

public class Something {

  public static void main(String[] args) {

      Other o = new Other();

      new Something().addOne(o);

  }

  public void addOne(final Other o) {

      o.i++;

  }

}

class Other {

  public int i;

}

和上面的很相似,都是关于final的问题,这有错吗?

答案: 正确。在addOne method中,参数o被修饰成final。如果在addOne method里我们修改了o的reference

(比如: o = new Other();),那么如同上例这题也是错的。但这里修改的是o的member vairable

(成员变量),而o的reference并没有改变。

6.

class Something {

   int i;

   public void doSomething() {

       System.out.println("i = " + i);

   }

}

有什么错呢? 看不出来啊。

答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量,或叫成员变量)。instant variable有default value。int的default value是0。

7.

class Something {

   final int i;

   public void doSomething() {

       System.out.println("i = " + i);

   }

}

和上面一题只有一个地方不同,就是多了一个final。这难道就错了吗?

答案: 错。final int i是个final的instant variable (实例变量,或叫成员变量)。final的instant variable没有default value,必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

8.

public class Something {

    public static void main(String[] args) {

       Something s = new Something();

       System.out.println("s.doSomething() returns " + doSomething());

   }

   public String doSomething() {

       return "Do something ...";

   }

}

看上去很完美。

答案: 错。看上去在main里call doSomething没有什么问题,毕竟两个methods都在同一个class里。但仔细看,main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理,static method不能访问non-static instant variable。

9.

此处,Something类的文件名叫OtherThing.java

class Something {

   private static void main(String[] something_to_do) {        

       System.out.println("Do something ...");

   }

}

这个好像很明显。

答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

10.

interface  A{

  int x = 0;

}

class B{

  int x =1;

}

class C extends B implements A {

  public void pX(){

     System.out.println(x);

  }

  public static void main(String[] args) {

     new C().pX();

  }

}

答案:错误。在编译时会发生错误(错误描述不同的JVM有不同的信息,意思就是未明确的x调用,两个x都匹配(就象在同时import java.util和java.sql两个包时直接声明Date一样)。对于父类的变量,可以用super.x来明确,而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

11.

interface Playable {

   void play();

}

interface Bounceable {

   void play();

}

interface Rollable extends Playable, Bounceable {

   Ball ball = new Ball("PingPang");

}

class Ball implements Rollable {

   private String name;

   public String getName() {

       return name;

   }

   public Ball(String name) {

       this.name = name;        

   }

  public void play() {

       ball = new Ball("Football");

       System.out.println(ball.getName());

   }

}

这个错误不容易发现。

答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces,所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量,也可称成员变量),默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中,"ball = new Ball("Football");"改变了ball的reference,而这里的ball来自Rollable interface,Rollable interface里的ball是public static final的,final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。


2. 算法与编程

77、说明生活中遇到的二叉树,用java实现二叉树

我有很多个(假设10万个)数据要保存起来,以后还需要从保存的这些数据中检索是否存在某个数据,(我想说出二叉树的好处,该怎么说呢?那就是说别人的缺点),假如存在数组中,那么,碰巧要找的数字位于99999那个地方,那查找的速度将很慢,因为要从第1个依次往后取,取出来后进行比较。平衡二叉树(构建平衡二叉树需要先排序,我们这里就不作考虑了)可以很好地解决这个问题,但二叉树的遍历(前序,中序,后序)效率要比数组低很多,原理如下图:



代码如下:


package com.huawei.interview;



public class Node {

public int value;


public Node left;


public Node right;



public void store(int value)


{

if(value<this.value)


{

if(left == null)


{

left = new Node();


left.value=value;


}


else


{

left.store(value);


}


}


else if(value>this.value)


{

if(right == null)


{

right = new Node();


right.value=value;


}


else


{

right.store(value);


}


}


}



public boolean find(int value)


{

System.out.println("happen " + this.value);


if(value == this.value)


{

return true;


}


else if(value>this.value)


{

if(right == null) return false;


return right.find(value);


}else


{

if(left == null) return false;


return left.find(value);


}



}



public  void preList()


{

System.out.print(this.value + ",");


if(left!=null) left.preList();


if(right!=null) right.preList();


}



public void middleList()


{

if(left!=null) left.preList();


System.out.print(this.value + ",");


if(right!=null) right.preList();


}


public void afterList()


{

if(left!=null) left.preList();


if(right!=null) right.preList();


System.out.print(this.value + ",");


}


public static void main(String [] args)


{

int [] data = new int[20];


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


{

data[i] = (int)(Math.random()*100) + 1;


System.out.print(data[i] + ",");


}


System.out.println();



Node root = new Node();


root.value = data[0];


for(int i=1;i<data.length;i++)


{

root.store(data[i]);


}



root.find(data[19]);



root.preList();


System.out.println();


root.middleList();


System.out.println();


root.afterList();


}


}


 


相关文章
|
负载均衡 算法 NoSQL
阿里大佬倾情力荐:Java全线成长宝典,从P5到P8一应俱全
前言 对于大部分的程序员来说,清晰地规划自己的职业发展并不是一件容易的事情。作为一个曾经底子比较差,从底层摸爬滚打多年走过来的程序员,在这里分享一下对我帮助很大的一份宝典,希望同行们能快速掌握这些技术,直接弯道超车。 很多程序员不知道学什么?或者说不知道从何学习?今天分享的这份宝典由阿里大佬倾情力荐,Java全线成长宝典,从P5到P8一应俱全。
|
消息中间件 设计模式 缓存
复习这份美团架构师的Java核心面试宝典,我四面阿里拿下offer
怎样才能拿到大厂的offer,没有掌握绝对的技术,那么就要不断的学习 他是如何拿下阿里等大厂的offer的呢,今天分享他的秘密武器,美团资深架构师整理的Java核心知识点,面试时面试官必问的知识点,篇章包括了很多知识点,其中包括了有基础知识、Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构等等。
工作五年,一年内我靠这系列java面试宝典从13K到大厂30K
我认为对于面试以及进阶最佳的学习方法莫过于刷题+博客+书籍+总结! 前三者我将淋漓尽致地挥毫于这篇文章中,至于总结要靠个人。实际上越到后面你越会发现面试并不难,其次就是在刷题的过程中有没有去思考,刷题只是次之,这又是一个层次了,这里暂时不提后面再谈。 我总结了一系列大厂面试中常问的面试技术点、深入解析以及答案,将为最近准备面试的各位去大厂保驾护航! 何谓面试?
|
设计模式 缓存 算法
阿里逆天级调优方案,内部这套Java性能调优实战宝典,堪称教科书
随着互联网的发展,高可靠、高并发以及降本增效,已成为各大公司面临的现实挑战,性能优化需求愈发迫切,大到分布式系统,小到代码块的算法优化,都已经成为你日常工作中必须要面对的事情。对于开发者而言,性能优化也从加分项变为一个热门技能,缺乏相关知识将很难在面试或工作中脱颖而出
阿里逆天级调优方案,内部这套Java性能调优实战宝典,堪称教科书
|
设计模式 监控 Java
简直人生外挂,直接涨薪25K,跪谢这份Java性能调优实战宝典
从整个软件生命周期的视角去关注与审视软件性能,通过主动式地设计与实现来主导软件性能,这样才能保证软件性能长期保持竞争力。针对这些问题,我结合自己十余年的性能调优开发经验。
|
监控 前端开发 Dubbo
Java 工程师必读的避坑宝典
但凡工作过的同学都会亲自经历过或者听过各种故障。 轻则受到批评,重则影响绩效,甚至被罚钱、开除。 那么,作为 Java 工程师,我们该如何尽可能避坑呢,有没有一些经验可以交流分享的呢? 本文,结合自己的经验,谈谈自己的看法。
360 1
Java 工程师必读的避坑宝典
|
XML Java 应用服务中间件
java宝典(9)
java宝典(9)
121 0
|
XML 缓存 开发框架
java宝典(8)
java宝典(8)
203 0
|
SQL 存储 开发框架
java宝典(7)
java宝典(7)
130 0
|
前端开发 JavaScript 算法
java宝典(6)
java宝典(6)
204 0