java面试基础之三

淡淡的烟草味﹌ 2022-06-15 08:28 153阅读 0赞

# 1.java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ #

java5以前，有如下两种：  
第一种：  
new Thread()\{\}.start();这表示调用Thread子类对象的run方法，new Thread()\{\}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：  
new Thread()\{  
public void run()\{  
\}  
\}.start();

第二种：  
new Thread(new Runnable()\{\}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable()\{\}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：  
new Thread(new Runnable()\{  
public void run()\{  
\}  
\}  
).start();

从java5开始，还有如下一些线程池创建多线程的方式：  
ExecutorService pool = Executors.newFixedThreadPool(3)  
for(int i=0;i<10;i++)  
\{  
pool.execute(new Runable()\{public void run()\{\}\});  
\}  
Executors.newCachedThreadPool().execute(new Runable()\{public void run()\{\}\});  
Executors.newSingleThreadExecutor().execute(new Runable()\{public void run()\{\}\});

有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。

有两种实现方法，分别是继承Thread类与实现Runnable接口  
用synchronized关键字修饰同步方法  
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

# 2.sleep() 和 wait() 有什么区别? #

通俗点讲就是：  
sleep是让线程指定休眠时间，然后继续工作  
wait则是等待，直到有线程通知notify（）唤醒他才会重新工作。

wait的本质是条件等待，这里涉及到了锁的概念（也就是多线程中要保证线程安全的锁）。所谓条件等待就是已经获得了锁的线程，由于需要满足某种条件才能继续执行，而当前不满足条件，所以只能等待。所以调用wait的一个前提条件就是要先拿到锁。拿到锁的线程，wait之后，该线程就进入条件等待队列，并且释放锁，让其他线程执行。当其他线程的执行使得条件满足之后，再调用notify或者notifyAll方法，将条件等待队列中的线程唤醒，这些线程再去请求锁，拿到锁的线程接着去执行。建议你看一下ReentrantLock类，顺便用一下Condition类，看一看《Java核心技术》第二卷关于线程那一章的讲解。

调用wait()/wait(long t)线程进入Waiting/TimeWaiting状态。

sleep（long t）的意思是暂停当前线程t毫秒，当然，其他线程就得到了时间片，sleep与线程是否获得锁无关。调用sleep线程进入TimeWaiting状态。  
![这里写图片描述][SouthEast]

# 3.java中同步和异步有什么异同？ #

同步:发送一个请求,等待返回,然后再发送下一个请求  
异步:发送一个请求,不等待返回,随时可以再发送下一个请求  
同步会出现死锁，读脏数据的发生，一般共享某一资源的时候用，如果每个人都有修改权限，同时修改一个文件，有可能使一个人读取另一个人已经删除的内容，就会出错，同步就会按顺序来修改。  
异步则是可以提高效率了，现在cpu都是双核，四核，异步处理的话可以同时做多项工作，当然必须保证是可以并发处理的。  
这些都是对的。  
同步和异步最大的区别就在于。一个需要等待，一个不需要等待。

比如广播，就是一个异步例子。发起者不关心接收者的状态。不需要等待接收者的返回信息  
电话，就是一个同步例子。发起者需要等待接收者，接通电话后，通信才开始。需要等待接收者的返回信息

# 4.线程的基本概念、线程的基本状态以及状态之间的关系 #

线程的基本概念：  
一个程序中可以有多条线程同时执行，一个线程就是程序中的一条执行线程，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu一会执行a线程，一会执行b线程，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。

状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。  
状态之间的关系：  
调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

# 5.设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。 #

package com.test1;
    
    public class Demo6 {   
    
        private int j;  
        public static void main(String args[]) {  
    
            Demo6 tt = new Demo6();  
    
            Inc inc = tt.new Inc();  
    
            Dec dec = tt.new Dec();  
    
            for (int i = 0; i < 2; i++) {  
                Thread t = new Thread(inc);  
                t.start();  
                t = new Thread(dec);  
                t.start();  
            }  
    
        }  
    
        private synchronized void inc() {  
            j++;  
            System.out.println(Thread.currentThread().getName() + "-inc:" + j);  
        }  
    
        private synchronized void dec() {  
            j--;  
            System.out.println(Thread.currentThread().getName() + "-dec:" + j);  
        }  
    
        class Inc implements Runnable {   
    
            public void run() {  
                for (int i = 0; i < 100; i++) {  
                    inc();  
                }  
            }  
        }  
    
        class Dec implements Runnable {   
    
            public void run() {  
                for (int i = 0; i < 100; i++) {  
                    dec();  
                }  
            }  
        }  
    
    }

# 6.子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。 #

public class Demo7 { 
    
        /** * 子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序. */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            new Demo7().init();
    
        }
    
        public void init()
        {
            final Business business = new Business();
            new Thread(
                    new Runnable()
                    {
    
                        public void run() {
                            for(int i=0;i<50;i++)
                            {
                                business.SubThread(i);
                            }                       
                        }
    
                    }
    
            ).start();
    
            for(int i=0;i<50;i++)
            {
                business.MainThread(i);
            }       
        }
    
        private class Business { 
            boolean flag = true;//这里相当于定义了控制该谁执行的一个信号灯
            public synchronized void MainThread(int i)
            {
                if(flag)
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }       
    
                for(int j=0;j<5;j++)
                {
                    System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
                }
                flag = true;
                this.notify();
    
            }
    
    
            public synchronized void SubThread(int i)
            {
                if(!flag)
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }   
    
                for(int j=0;j<10;j++)
                {
                    System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
                }
                flag = false;               
                this.notify();          
            }
        }
    }

# 7.ArrayList和Vector的区别 #

这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，，并且其中的数据是允许重复的，这是与HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素。

ArrayList与Vector的区别，这主要包括两个方面：.  
（1）同步性：  
Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。所以，我们讲课时先讲老的。  
（2）数据增长：  
ArrayList（初始容量大小为10）与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。  
总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。

# 8、HashMap和Hashtable的区别 #

（条理上还需要整理，也是先说相同点，再说不同点）  
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。  
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。  
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。  
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。  
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。  
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

就HashMap与HashTable主要从三方面来说。  
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现  
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的  
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

# 9、List 和 Map 区别? #

一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。

# 10.List、Map、Set三个接口，存取元素时，各有什么特点？ #

这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内容，二是要有较强的总结和表述能力。如果你明白，但表述不清楚，在别人那里则等同于不明白。

首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。  
List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。  
Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。例如，”abc” —> 78，”def” —> 62，”xyz” —> 65在hashSet中的存储顺序不是62,65,78，这些问题感谢以前一个叫崔健的学员提出，最后通过查看源代码给他解释清楚，看本次培训学员当中有多少能看懂源码。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？学员想想!hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。

同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。

# 11、说出ArrayList,Vector, LinkedList的存储性能和特性 #

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。

# 12、去掉一个Vector集合中重复的元素 #

Vector newVector = new Vector();  
For (int i=0;i

# 13、Collection 和 Collections的区别。 #

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.  
Collections是针对集合类的一个工具类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

# 14、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别? #

Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。  
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

# 15、你所知道的集合类都有哪些？主要方法？ #

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。  
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作”键”和”值”），其中每个键映射到一个值。

ArrayList/VectorList  
Collection  
HashSet/TreeSetSet

PropetiesHashTable  
Map  
Treemap/HashMap

我记的不是方法名，而是思想，我知道它们都有增删改查的方法，但这些方法的具体名称，我记得不是很清楚，对于set，大概的方法是add,remove, contains；对于map，大概的方法就是put,remove，contains等，因为，我只要在eclispe下按点操作符，很自然的这些方法就出来了。我记住的一些思想就是List类会有get(int index)这样的方法，因为它可以按顺序取元素，而set类中没有get(int index)这样的方法。List和set都可以迭代出所有元素，迭代时先要得到一个iterator对象，所以，set和list类都有一个iterator方法，用于返回那个iterator对象。map可以返回三个集合，一个是返回所有的key的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。

[SouthEast]: /images/20220615/010c8d5330b4451ab96ca2478ec06cf3.png