21、解释内存中的栈(stack)、堆(heap)和方法区(methodarea)的用法。
JAVA的JVM的内存可分为3个区:堆(heap)、栈(stack)和方法区(method)
堆区:
1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基本类型和对象引用,只存放对象本身
栈区:
1.每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象),对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的,其他栈不能访问。
3.栈分为3个部分:基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。
为了更清楚地搞明白发生在运行时数据区里的黑幕,我们来准备2个小道具(2个非常简单的小程序)。
// AppMain.java
// 运行时, jvm 把appmain的信息都放入方法区
publicclass AppMain{
//main 方法本身放入方法区。
public static void main(String[]args) {
//test1是引用,所以放到栈区里, Sample是自定义对象应该放到堆里面
Sample test1 = new Sample(" 测试1 ");
Sample test2 = new Sample(" 测试2 ");
test1.printName();
test2.printName();
}
}
//Sample.java
//运行时, jvm 把appmain的信息都放入方法区
publicclass Sample{
// 范例名称
// new Sample实例后, name引用放入栈区里,name 对象放入堆里
private name;
// 构造方法
public Sample(String name) {
this.name = name;
}
// 输出
//print方法本身放入 方法区里。
public void printName() {
System.out.println(name);
}
}
OK,让我们开始行动吧,出发指令就是:“java AppMain”,包包里带好我们的行动向导图,Let’s GO!
系统收到了我们发出的指令,启动了一个Java虚拟机进程,这个进程首先从classpath中找到AppMain.class文件,读取这个文件中的二进制数据,然后把Appmain类的类信息存放到运行时数据区的方法区中。这一过程称为AppMain类的加载过程。
接着,Java虚拟机定位到方法区中AppMain类的Main()方法的字节码,开始执行它的指令。这个main()方法的第一条语句就是:
Sample test1=new Sample("测试1");
语句很简单啦,就是让java虚拟机创建一个Sample实例,并且呢,使引用变量test1引用这个实例。貌似小case一桩哦,就让我们来跟踪一下Java虚拟机,看看它究竟是怎么来执行这个任务的:
1、 Java虚拟机一看,不就是建立一个Sample实例吗,简单,于是就直奔方法区而去,先找到Sample类的类型信息再说。结果呢,嘿嘿,没找到@@,这会儿的方法区里还没有Sample类呢。可Java虚拟机也不是一根筋的笨蛋,于是,它发扬“自己动手,丰衣足食”的作风,立马加载了Sample类,把Sample类的类型信息存放在方法区里。
2、 好啦,资料找到了,下面就开始干活啦。Java虚拟机做的第一件事情就是在堆区中为一个新的Sample实例分配内存, 这个Sample实例持有着指向方法区的Sample类的类型信息的引用。这里所说的引用,实际上指的是Sample类的类型信息在方法区中的内存地址,其实,就是有点类似于C语言里的指针啦~~,而这个地址呢,就存放了在Sample实例的数据区里。
3、 在JAVA虚拟机进程中,每个线程都会拥有一个方法调用栈,用来跟踪线程运行中一系列的方法调用过程,栈中的每一个元素就被称为栈帧,每当线程调用一个方法的时候就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。OK,原理讲完了,就让我们来继续我们的跟踪行动!位于“=”前的Test1是一个在main()方法中定义的变量,可见,它是一个局部变量,因此,它被会添加到了执行main()方法的主线程的JAVA方法调用栈中。而“=”将把这个test1变量指向堆区中的Sample实例,也就是说,它持有指向Sample实例的引用。
OK,到这里为止呢,JAVA虚拟机就完成了这个简单语句的执行任务。参考我们的行动向导图,我们终于初步摸清了JAVA虚拟机的一点点底细了,COOL!
接下来,JAVA虚拟机将继续执行后续指令,在堆区里继续创建另一个Sample实例,然后依次执行它们的printName()方法。当JAVA虚拟机执行test1.printName()方法时,JAVA虚拟机根据局部变量test1持有的引用,定位到堆区中的Sample实例,再根据Sample实例持有的引用,定位到方法去中Sample类的类型信息,从而获得printName()方法的字节码,接着执行printName()方法包含的指令。
22、int和Integer有什么区别?
1 package com.test;
2 /**
3 *
4 * @author
5 *
6 */
7 public class TestInteger {
8
9 /**
10 * @param args
11 */
12 public static void main(String[] args) {
13 int i = 128;
14 Integer i2 = 128;
15 Integer i3 = new Integer(128);
16 //Integer会自动拆箱为int,所以为true
17 System.out.println(i ==i2);
18 System.out.println(i ==i3);
19 System.out.println("**************");
20 Integer i5 = 127;//java在编译的时候,被翻译成-> Integer i5 = Integer.valueOf(127);
21 Integer i6 = 127;
22 System.out.println(i5 ==i6);//true
23 /*Integer i5 =128;
24 Integer i6 = 128;
25 System.out.println(i5 ==i6);//false
26 */ Integer ii5 = new Integer(127);
27 System.out.println(i5 ==ii5); //false
28 Integer i7 = new Integer(128);
29 Integer i8 = new Integer(123);
30 System.out.println(i7 ==i8); //false
31 }
32
33 }
首先,17行和18行输出结果都为true,因为Integer和int比都会自动拆箱(jdk1.5以上)。
22行的结果为true,而25行则为false,很多人都不动为什么。其实java在编译Integer i5 = 127的时候,被翻译成-> Integer i5 = Integer.valueOf(127);所以关键就是看valueOf()函数了。只要看看valueOf()函数的源码就会明白了。JDK源码的valueOf函数式这样的:
1 public static Integer valueOf(int i) {
2 assert IntegerCache.high >= 127;
3 if (i >= IntegerCache.low && i <= IntegerCache.high)
4 return IntegerCache.cache[i + (-IntegerCache.low)];
5 return new Integer(i);
6 }
看一下源码大家都会明白,对于-128到127之间的数,会进行缓存,Integeri5 = 127时,会将127进行缓存,下次再写Integeri6 = 127时,就会直接从缓存中取,就不会new了。所以22行的结果为true,而25行为false。
对于27行和30行,因为对象不一样,所以为false。
我对于以上的情况总结如下:
1、无论如何,Integer与newInteger不会相等。不会经历拆箱过程,i3的引用指向堆,而i4指向专门存放他的内存(常量池),他们的内存地址不一样,所以为false
2、两个都是非new出来的Integer,如果数在-128到127之间,则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存
3、两个都是new出来的,都为false
4、int和integer(无论new否)比,都为true,因为会把Integer自动拆箱为int再去比
23、String和StringBuilder、StringBuffer的区别?
1. String 类
String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且大量浪费有限的内存空间。
String a = "a"; //假设a指向地址0x0001
a = "b";//重新赋值后a指向地址0x0002,但0x0001地址中保存的"a"依旧存在,但已经不再是a所指向的,a 已经指向了其它地址。
因此String的操作都是改变赋值地址而不是改变值操作。
2. StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。 每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量。
StringBufferbuf=new StringBuffer(); //分配长16字节的字符缓冲区
StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区
StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串,并在后面预留了16字节的空缓冲区。
3.StringBuffer
StringBuffer和StringBuilder类功能基本相似,主要区别在于StringBuffer类的方法是多线程、安全的,而StringBuilder不是线程安全的,相比而言,StringBuilder类会略微快一点。对于经常要改变值的字符串应该使用StringBuffer和StringBuilder类。
4.线程安全
StringBuffer 线程安全
StringBuilder 线程不安全
5.速度
一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的,不是绝对的。
6.总结
(1).如果要操作少量的数据用 = String
(2).单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
(3).多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
//单链表
classListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
next = null;
}
}
public class SearchCycleNode{
ListNode equalListNode = null;
// 来记录判断有环时出现的相等的时的节点,姑且叫"相遇"节点。
// 从"相遇"节点出发,第一个可达的节点(从单链表的头节点开始)即是单链表的环产生的起始位置
public ListNode detectCycle(ListNode head) {
if (!hasCycle(head)) return null;
ListNode p = head;
while (!isReach(p)) {
p = p.next;
}
return p;
}
// 判断从相遇的节点到 head节点可达性
private boolean isReach(ListNode head) {
if (head == equalListNode) return true;
ListNode p = equalListNode.next;
while (p != equalListNode) {
if (p == head) return true;
p = p.next;
}
return false;
}
// 判断是否有环,通过一个指针p走一步,一个指针q走两步,如果能出现p=q的情况,则有环,并记录p为"相遇"节点。
private boolean hasCycle(ListNode head) {
if (head == null) return false;
if (head.next == null) return false;
ListNode p = head;
ListNode q = head.next;
while (p != q) {
if (p.next == null) return false;
p = p.next;
if (q.next == null) return false;
if (q.next.next == null) return false;
q = q.next.next;
}
equalListNode = p;
return true;
}
}
25、重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分?
1、重载(Overload):首先是位于一个类之中或者其子类中,具有相同的方法名,但是方法的参数不同,返回值类型可以相同也可以不同。
(1):方法名必须相同
(2):方法的参数列表一定不一样。
(3):访问修饰符和返回值类型可以相同也可以不同。
其实简单而言:重载就是对于不同的情况写不同的方法。比如,同一个类中,写不同的构造函数用于初始化不同的参数。
2:重写:
重写(override):一般都是表示子类和父类之间的关系,其主要的特征是:方法名相同,参数相同,但是具体的实现不同。
重写的特征:
(1):方法名必须相同,返回值类型必须相同
(2):参数列表必须相同
(3):访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected。
(4):子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为private和final的方法。
(5):构造方法不能被重写,
简单而言:就是具体的实现类对于父类的该方法实现不满意,需要自己在写一个满足于自己要求的方法。
26、抽象类(abstract class)和接口(interface)有什么异同?
- 抽象类可以有构造方法,接口中不能有构造方法。(虽然抽象类有构造方法,但它也不能被实例化)
- 抽象类中可以有普通成员变量,接口中没有普通成员变量。
- 抽象类和接口中都可以包含静态成员变量。抽象类中的静态成员变量的访问类型可以是任意类型,但接口中定义的变量只能是public static final,并且默认为:public staic final类型。(接口毕竟要被子类实现,所以成员变量必须是public,如果是其他访问类型,那这个变量存在还有什么意义)
- 抽象类中可以包含非抽象的普通方法,接口中的方法必须是抽象的,不能有非抽象的普通方法。
- 抽象类中的抽象方法访问类型可以是public, protected和默认。但接口抽象方法只能是public类型的,且不管接口的方法是否使用public abstract修饰默认即为public abstract类型。(例如:在接口中定义void add();方法 是和public void add(); 、public abstract void add()等价的)
- 抽象类中可以包含静态方法,而接口中不能包含静态方法
- 一个类可以实现多个接口,但只能继承一个抽象类。
- abstract class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is-a"关系,即父类和派生类在概念本质上应该是相同的。对于interface来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的, 仅仅是实现了interface定义的契约而已。
1、抽象类和接口都不能直接实例化,如果要实例化,抽象类变量必须指向实现所有抽象方法的子类对象,接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承,接口要被类实现。
3、接口只能做方法申明,抽象类中可以做方法申明,也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现,如果子类不能全部实现父类抽象方法,那么该子类只能是抽象类。同样,一个实现接口的时候,如不能全部实现接口方法,那么该类也只能为抽象类。
6、抽象方法只能申明,不能实现,接口是设计的结果 ,抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法,那么这个类只能是抽象类
9、抽象方法要被实现,所以不能是静态的,也不能是私有的。
10、接口可继承接口,并可多继承接口,但类只能单根继承。
27、Java 中会存在内存泄漏吗,请简单描述。
会。java导致内存泄露的原因很明确:长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露,尽管短生命周期对象已经不再需要,但是因为长生命周期对象持有它的引用而导致不能被回收,这就是java中内存泄露的发生场景。
1.集合类,集合类仅仅有添加元素的方法,而没有相应的删除机制,导致内存被占用。这一点其实也不明确,这个集合类如果仅仅是局部变量,根本不会造成内存泄露,在方法栈退出后就没有引用了会被jvm正常回收。而如果这个集合类是全局性的变量(比如类中的静态属性,全局性的map等即有静态引用或final一直指向它),那么没有相应的删除机制,很可能导致集合所占用的内存只增不减,因此提供这样的删除机制或者定期清除策略非常必要。
2.单例模式。不正确使用单例模式是引起内存泄露的一个常见问题,单例对象在被初始化后将在JVM的整个生命周期中存在(以静态变量的方式),如果单例对象持有外部对象的引用,那么这个外部对象将不能被jvm正常回收,导致内存泄露,考虑下面的例子:
class A{
public A(){
B.getInstance().setA(this);
}
....
}
//B类采用单例模式
class B{
private A a;
private static B instance=new B();
public B(){}
public static B getInstance(){
return instance;
}
public void setA(A a){
this.a=a;
}
//getter...
}
显然B采用singleton模式,他持有一个A对象的引用,而这个A类的对象将不能被回收。想象下如果A是个比较大的对象或者集合类型会发生什么情况。
上面所讲的这些也启发我们如何去查找内存泄露问题,在代码复审的时候关注长生命周期对象:全局性的集合、单例模式的使用、类的static变量等等。在Java的实现过程中,也要考虑其对象释放,最好的方法是在不使用某对象时,显式地将此对象赋空。最好遵循谁创建谁释放的原则。
28、Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行,它们有什么区别?
sleep()方法
sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给其他线程执行的机会;
sleep()是Thread类的Static(静态)的方法;因此他不能改变对象的机锁,所以当在一个Synchronized块中调用Sleep()方法是,线程虽然休眠了,但是对象的机锁并木有被释放,其他线程无法访问这个对象(即使睡着也持有对象锁)。
在sleep()休眠时间期满后,该线程不一定会立即执行,这是因为其它线程可能正在运行而且没有被调度为放弃执行,除非此线程具有更高的优先级。
wait()方法
wait()方法是Object类里的方法;当一个线程执行到wait()方法时,它就进入到一个和该对象相关的等待池中,同时失去(释放)了对象的机锁(暂时失去机锁,wait(long timeout)超时时间到后还需要返还对象锁);其他线程可以访问;
wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
wiat()必须放在synchronized block中,否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
所以sleep()和wait()方法的最大区别是:
sleep()睡眠时,保持对象锁,仍然占有该锁;
而wait()睡眠时,释放对象锁。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException(但不建议使用该方法)。
29、线程的sleep()方法和yield()方法有什么区别?
wait()和sleep()的区别主要表现在一下几个方面:
原理不同。sleep()方法是Thread类的静态方法,是线程用来控制自身流程的。它会使线程暂停执行一段时间,把执行机会让给其他线程,等到时间一到,此线程会自动“苏醒”; wait()方法是Object类的方法,用于线程间的通信。它会使当前拥有改对象锁的进程等待,直到其他进程调用notify()或notifyALL(),不过开发人员也可以指定一个时间自动“醒”来。
对锁的处理机制不同。调用sleep()方法并不会释放锁;而调用wait()方法,线程会释放掉它所占用的锁。
使用区域不同。wait()方法必须放在同步控制方法或同步语句块中使用;sleep()方法可以放在任何地方使用。
sleep()方法必须捕获异常,而wait()方法不需要捕获异常。
一般情况下,不推荐使用sleep()方法,而推荐使用wait()方法。
sleep()和yield()的区别:
sleep()方法给其它线程运行时,不考虑线程的优先级;而yield()方法只会给相同优先级或更高优先级的线程运行的机会。
执行sleep()方法后会转入阻塞状态,所以线程在指定的时间内肯定不会被执行;而yield()只是使当前线程重新回到可执行状态,所以线程有可能在进入到可执行状态后马上又被执行。
sleep()方法声明抛出InterruptedException;而yield()没有声明任何异常。
sleep()方法比yield()方法具有更好的可移植性。
30、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?
分几种情况:1.其他方法前是否加了synchronized关键字,如果没加,则能。
2.如果这个方法内部调用了wait,则可以进入其他synchronized方法。
3.如果其他个方法都加了synchronized关键字,并且内部没有调用wait,则不能。
4.如果其他方法是static,它用的同步锁是当前类的字节码,与非静态的方法不能同步,因为非静态的方法用的是this。