Java基础面试题(八)

2019-03-05 11:07|来源: 网友

56、子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序。

最终的程序代码如下:

public class ThreadTest {

   public static void main(String[] args) {

      new ThreadTest().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 bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯

      public synchronized void MainThread(int i){

          if(bShouldSub)

             try {

                 this.wait();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

          for(int j=0;j<5;j++){

             System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);

          }

          bShouldSub = true;

          this.notify();

      }

      public synchronized void SubThread(int i){

          if(!bShouldSub)

             try {

                 this.wait();

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

          for(int j=0;j<10;j++){

             System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);

          }

          bShouldSub = false;            

          this.notify();          

      }

   }

}

备注:不可能一上来就写出上面的完整代码,最初写出来的代码如下,问题在于两个线程的代码要参照同一个变量,即这两个线程的代码要共享数据,所以,把这两个线程的执行代码搬到同一个类中去:

package com.huawei.interview.lym;

public class ThreadTest {

   private static boolean bShouldMain = false;

   

   public static void main(String[] args) {

      /*new Thread(){

      public void run(){

          for(int i=0;i<50;i++){

             for(int j=0;j<10;j++){

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

             }

          }            

      }

     

   }.start();*/      

     

      //final String str = new String("");

      new Thread(

             new Runnable(){

                 public void run(){

                    for(int i=0;i<50;i++){

                        synchronized (ThreadTest.class) {

                           if(bShouldMain){

                               try {

                                  ThreadTest.class.wait();}

                               catch (InterruptedException e) {

                                  e.printStackTrace();

                               }

                           }

                           for(int j=0;j<10;j++){

                               System.out.println(

                                      Thread.currentThread().getName() +

                                      "i=" + i + ",j=" + j);

                           }

                           bShouldMain = true;

                           ThreadTest.class.notify();

                        }                        

                    }                    

                 }

             }

      ).start();

     

      for(int i=0;i<50;i++){

          synchronized (ThreadTest.class) {

             if(!bShouldMain){

                 try {

                    ThreadTest.class.wait();}

                 catch (InterruptedException e) {

                    e.printStackTrace();

                 }

             }            

             for(int j=0;j<5;j++){

                 System.out.println(

                        Thread.currentThread().getName() +                    

                        "i=" + i + ",j=" + j);

             }

             bShouldMain = false;

             ThreadTest.class.notify();            

          }          

      }

   }

}

下面使用jdk5中的并发库来实现的:

import java.util.concurrent.Executors;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import java.util.concurrent.locks.Condition;

public class ThreadTest{

      private static Lock lock = new ReentrantLock();

      private static Condition subThreadCondition = lock.newCondition();

      private static boolean bBhouldSubThread = false;

      public static void main(String [] args){

             ExecutorService threadPool = Executors.newFixedThreadPool(3);

             threadPool.execute(new Runnable(){

                    public void run(){

                           for(int i=0;i<50;i++){

                                  lock.lock();                                

                                  try{                            

                                         if(!bBhouldSubThread)

                                                subThreadCondition.await();

                                         for(int j=0;j<10;j++){

                                                System.out.println(Thread.currentThread().getName() + ",j=" + j);

                                         }

                                         bBhouldSubThread = false;

                                         subThreadCondition.signal();

                                  }catch(Exception e){                                        

                                  }finally{

                                         lock.unlock();

                                  }

                           }                  

                    }

             });

             threadPool.shutdown();

             for(int i=0;i<50;i++){

                           lock.lock();                                

                           try{

                                  if(bBhouldSubThread)

                                                subThreadCondition.await();                                            

                                  for(int j=0;j<10;j++){

                                         System.out.println(Thread.currentThread().getName() + ",j=" + j);

                                  }

                                  bBhouldSubThread = true;

                                  subThreadCondition.signal();                            

                           }catch(Exception e){                                        

                           }finally{

                                  lock.unlock();

                           }                                

             }

      }

}

57、介绍Collection框架的结构

答:随意发挥题,天南海北谁便谈,只要让别觉得你知识渊博,理解透彻即可。

58Collection框架中实现比较要实现什么接口

comparable/comparator

59ArrayListVector的区别

答:

这两个类都实现了List接口(List接口继承了Collection接口),他们都是有序集合,即存储在这两个集合中的元素的位置都是有顺序的,相当于一种动态的数组,我们以后可以按位置索引号取出某个元素,,并且其中的数据是允许重复的,这是HashSet之类的集合的最大不同处,HashSet之类的集合不可以按索引号去检索其中的元素,也不允许有重复的元素(本来题目问的与hashset没有任何关系,但为了说清楚ArrayList与Vector的功能,我们使用对比方式,更有利于说明问题)。

接着才说ArrayList与Vector的区别,这主要包括两个方面:.
(1)同步性:

      Vector是线程安全的,也就是说是它的方法之间是线程同步的,而ArrayList是线程序不安全的,它的方法之间是线程不同步的。如果只有一个线程会访问到集合,那最好是使用ArrayList,因为它不考虑线程安全,效率会高些;如果有多个线程会访问到集合,那最好是使用Vector,因为不需要我们自己再去考虑和编写线程安全的代码。

备注:对于Vector&ArrayList、Hashtable&HashMap,要记住线程安全的问题,记住Vector与Hashtable是旧的,是java一诞生就提供了的,它们是线程安全的,ArrayList与HashMap是java2时才提供的,它们是线程不安全的。所以,我们讲课时先讲老的。
(2)数据增长:

      ArrayList与Vector都有一个初始的容量大小,当存储进它们里面的元素的个数超过了容量时,就需要增加ArrayList与Vector的存储空间,每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元,每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍,而ArrayList的增长策略在文档中没有明确规定(从源代码看到的是增长为原来的1.5倍)。ArrayList与Vector都可以设置初始的空间大小,Vector还可以设置增长的空间大小,而ArrayList没有提供设置增长空间的方法。

   总结:即Vector增长原来的一倍,ArrayList增加原来的0.5倍。

60HashMapHashtable的区别

(条理上还需要整理,也是先说相同点,再说不同点)

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


本文链接:领悟书生教程网-面试题大全,转载请注明出处

相关问答

更多
  • java基础面试题[2022-04-05]

      1.抽象:   抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。   2.继承:   继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继 承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变 ...
  • Java面试题[2022-05-31]

    1、面向对象的特征有哪些方面 1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打 算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数 据抽象。 2.继承: 继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新 类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类 ),而原始类称为新类的基类(父类)。派生类可以从它的基类 ...
  • java基础面试题[2023-10-31]

    1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。 2.继承: 继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继 承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以修 ...
  • ?不把问题贴出来,肚子里的萨姆大叔才回答你的问题呢。。。
  • java基础,面向对象,线程,流,jdbc,集合,网络编程,异常,常用的数据结构。 javascript:(函数,对象,操作页面元素。) jsp:(内置对象,标准动作,javabean servlet 自定义标签) struts2:(mvc设计模式,分层软件设计模式) 要考的基本上就这些,还有好多都是逻辑题。我是java的爱好者 我QQ是88986735 有时间一起讨论讨论呀?
  • CSDN有下载,不过你需要免费注册一下XSDN用户,以下是下载地址: http://download.csdn.net/source/222020 这有一篇有关面试题的文章,有兴趣你可以看看: http://www.javaresearch.org/article/24088.htm 下面这个网址有很多面试题的链接,强烈推荐: http://topic.csdn.net/u/20071106/20/c204a2c4-9e51-4d5d-8017-3803f4e943c3.html 最后,我相信你会找到一份满 ...
  • 基于AXIS的web service: 1 比如要建一个Server.java类的web service public class Server { public String printInfo(String name){ return "Hello,"+name; } } 2 把Server.java改为Server.Jws放到 …\Tomcat 5.5\webapps\axis中,重启服务器 3 访问 4 在cmd中输入 cd D:\Program Files\Apache Software Foun ...
  • 我有一部分!
  • 觉得范围太大,没有特别经典的题。如果看知识广度,需要了解1)servlet规范及常见servlet-based的server,如tomcat, jetty..2)主流框架的使用及原理,如表示层的struts/struts2,管理服务对象生命周期的spring,持久层的hibernate/jpa..然后看情况选其一深入研究实践即是。