• java笔试题(金山网络)


      今天参加金山的校园招聘,java笔试,回来仔细研究实现一下:

    题目1:工厂两条生产线,三个工人,生产线上可以最多存放m个产品,当生产线满时,机器停止生产,等产品线不满时才继续生产,每条产线上一次只能允许一个工人取产品,编程实现该过程,使整个生产线能流畅 运行。

    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    
    //多线程(生产者消费者问题)
    class Producer extends Thread {
        //使用阻塞队列(BlockingQueue)控制线程通信
        private BlockingQueue<String>bq;
        public Producer(BlockingQueue<String> bq){
            this.bq = bq;
        }
        public void run(){
            //用于生产的元素
            String[] strArr = new String[]{
                    "Java",
                    "Structs",
                    "Spring"
            };
            for(int i = 0;i<9;i++){
                System.out.println(getName()+"生产者准备生产集合元素");
                try{
                    Thread.sleep(200);
                    //尝试放入元素,如果队列已满,则线程被阻塞
                    bq.put(strArr[i%3]);
                }catch(Exception ex){
                    ex.printStackTrace();
                }
                System.out.println(getName()+"生产完成:"+bq);
            }
        }
    }
    
    class Consumer extends Thread{
        private BlockingQueue<String>bq;
        public Consumer(BlockingQueue<String>bq){
            this.bq = bq;
        }
        public void run(){
            //每条生产线上只允许一个人去取(同步代码块“加锁-修改-释放锁”)
            synchronized(bq){
            while(true){
                System.out.printf(getName()+"消费者准备消费集合元素");
                try{
                    Thread.sleep(200);
                    //尝试取出元素,如果队列已空,则阻塞该线程
                    bq.take();
                }catch(Exception ex){
                    ex.getStackTrace();
                }
                System.out.println(getName()+"消费完成"+bq);
               }
            }//同步代码块结束,该线程释放同步锁
        }
    }
    
    
    
    
    
    
    public class UseBlockingQueue {
        public static void main(String[] args){
            //创建一个容量为1的BlockingQueue
           int m=10;
            BlockingQueue<String>bq = new ArrayBlockingQueue<>(m);
            //启动2个生产者线程
            new Producer(bq).start();
            new Producer(bq).start();
     
            //启动一个消费者线程
            new Consumer(bq).start();
        }
    }

     题目二:写一个java程序实现ArrayList类,最简单必须实现add()、remove().....

         发现网上写成 什么样的都有,于是参考了一下jdk源码,简单实现了一个:

         

    import java.util.AbstractList;
    import java.util.List;
    
    
    public class shixianArrayList<E> extends AbstractList<E> implements List<E>{
        private transient Object[] elementData;
        private int size=0;
        
        
        public shixianArrayList(int initialCapacity){
            super();
            if(initialCapacity<0){
                return ;
            }
            this.elementData = new Object[initialCapacity];
        }
        //默认长度为10
        public shixianArrayList(){
            this(10);
        }
    
        @Override
        public E get(int index) {
            // TODO Auto-generated method stub
            return null;
        }
        @Override
        public int size() {
            // TODO Auto-generated method stub
            return size;
        }
        
        public boolean isEmpty(){
            return size ==0;
        }
        
        public boolean contains(Object o){
            return indexOf(o) >=0;
        }
        
        public int indexOf(Object o){
            if(o == null){
                for(int i=0;i<size;i++){
                    if(elementData[i]==null){
                        return i;
                    }
                }
            }else{
                for(int i=0;i<size;i++){
                    if(o.equals(elementData[i]))
                        return i;
                }
            }
            return -1;
        }
        //这里是不带索引的add(),带索引的也可以有
        public boolean add(E e){
            
            elementData[size++] = e;
            return true;
        }
        
        //这里是直接按照元素删除,按照索引删除的也可以有
        public boolean remove(Object o){
            if(o == null){
                for(int index=0;index<size;index++){
                    if(elementData[index] == null){
                        fastRemove(index);
                        return true;
                            }
                }
            }else{
                for(int index=0;index<size;index++){
                    if(o.equals(elementData[index])){
                        fastRemove(index);
                        return true;
                    }
                }
            }
            return false;
        }
        
        
        private void fastRemove(int index) {
            modCount++;
            int numMoved = size-index-1;
            if(numMoved>0)
                System.arraycopy(elementData, index+1,elementData , index,numMoved);
            elementData[--size] = null; //让gc来做这个工作
            
        }
    
        public static void main(String[] args){
            String[] books = {
                    "java","structs"
            };
            shixianArrayList<String> booklist = new shixianArrayList<String>();
            for(int i =0;i<books.length;i++){
                booklist.add(books[i]);
            }
            //booklist.remove(books[1]);
            
            System.out.println(booklist.toStringFunc());
        }
        //elementData为Object[]类型,不能直接打印
        public String toStringFunc(){
            String tempstr="";
            for(int i=0;i<this.size;i++){
                if(this.elementData[i]!=null){
                tempstr+=this.elementData[i];
               }
            }
           return tempstr;    
        }
    
        
        
        
       
    }

     题目三:已知两个字符串由不同的字母组成,一长一短,长的为A,短的为B。若所有在B中出现的字符都在A中出现,则返回true,否则返回false。假设短的长度为m,长的长度为n,要求算法的时间复杂度不能大于O(m+n)。 

           解法一:最先想到的解法,对字符串B中的每个字母在A中都遍历一遍(但是时间复杂度为O(m*n))

       

    public class BinA {
    
        public static void main(String[] args){
            String[] stra = {"a","a","b","b","b","b","c","d","e","e"};
            String[] strb = {"a","a","c","d","e"};
            Contain A = new Contain();
            
            System.out.println(A.containStr(stra, strb));
          
        }
    }
        
    class Contain{
          public  boolean containStr(String[] stra,String[] strb){ 
              int count=0;
              //因为是要把strb中的每个元素拿出来跟stra中的每个元素比,所以要把strb的放在外面的循环
                 for(int i=0;i<strb.length;i++)
                 {
                     for(int j=0;j<stra.length;j++)
                     {
                         //因为数组中可能有重复元素,所以只要在stra中找到一个与strb相等的就就跳出来,才能保证count值=length
                         if(strb[i]==stra[j]){
                             count++;
                         j=stra.length;
                         }
                     }
                 }
                 //count用作计数器,恰好比较了strb。length次说明在stra中每个strb中的数都有相等的了
                 if(count==strb.length){
                     return true;
                 }
              return false;
          
        }
    }

             解法二:设一个哈希表,对字符串A的字符遍历,将每个字符对应的哈希表中的值设为1。然后对B中的字符进行遍历,如果所有字符对应的hash值都为1,则返回true,否则返回false。时间复杂度为O(m+n)。

      

    package JingDian;
    
    import java.util.HashMap;
    
    public class HashBinA {
        
        public static void main(String[] args){
            String[] stra = {"a","a","b","b","b","b","c","d","e","e"};
            String[] strb = {"a","b","c","d","e"};
            hashSolve hs = new hashSolve();
            System.out.println(hs.hashBinA(stra, strb));
        
            
        }
    
    }
    
    class hashSolve{
        public boolean hashBinA(String[] stra,String[] strb){
            HashMap<String, Integer> hm = new HashMap<String, Integer>();
            int count=0;
            for(int i=0;i<stra.length;i++)
            {
                hm.put(stra[i], 1);
            }
            for(int j=0;j<strb.length;j++)
            {
                //若strb中存在stra中没有的keyget()方法会返回空而报空指针错误,因此要判断是否为空
                if(hm.get(strb[j])!=null&&hm.get(strb[j])==1){
                    count += 1;
                    
                   }
                }
            //count只是一个计数器,如果每一个strb中字母得到的value都为一(都在stra中)则其长度为strb。length
            if(count == strb.length)
            {
                return true;
            }
            
            return false;
        }
        
    }
  • 相关阅读:
    EasyDarwin开源流媒体云平台之云台ptz控制设计与实现
    ffmpeg强制使用TCP方式推流到EasyDarwin开源流媒体服务器进行直播
    开源流媒体云视频平台EasyDarwin中EasyCMS服务是如何进行命令转发和消息路由的
    开源流媒体云视频平台EasyDarwin中EasyCMS服务是如何进行命令转发和消息路由的
    EasyDarwin开源流媒体服务器性能瓶颈分析及优化方案设计
    EasyDarwin开源流媒体服务器性能瓶颈分析及优化方案设计
    vs2015编译EasyDarwin开源流媒体服务器Linux版本调研
    vs2015编译EasyDarwin开源流媒体服务器Linux版本调研
    EasyDarwin接入ffmpeg实现264转图片快照功能
    EasyDarwin接入ffmpeg实现264转图片快照功能
  • 原文地址:https://www.cnblogs.com/skylar/p/3657319.html
Copyright © 2020-2023  润新知