Android开发Android开发经验谈Android技术知识

在这白驹过隙的时代，Android开发者如何先人一步？

2019-04-25  本文已影响16人  迷途小码农h

1.前言

2.正文

JAVA面试题

1.GC机制

2.JVM内存区域的划分，哪些区域会发生OOM

3.类加载过程，双亲委派模型

Java中类加载分为3个步骤：加载、链接、初始化。

4.HashMap的原理

5.什么情况下Java会产生死锁，如何定位、修复，手写死锁
答案略

6.sleep和wait的区别

7.join的用法

   throws InterruptedException {
       long base = System.currentTimeMillis();
       long now = 0;

       if (millis < 0) {
           throw new IllegalArgumentException("timeout value is negative");
       }

       if (millis == 0) {
           while (isAlive()) {
               wait(0);
           }
       } else {
           while (isAlive()) {
               long delay = millis - now;
               if (delay <= 0) {
                   break;
               }
               wait(delay);
               now = System.currentTimeMillis() - base;
           }
       }
   }

8.volatile和synchronize的区别

9.Java中的线程池

10.线程通信

11.Java中的并发集合

12.Java中生产者与消费者模式


 public class StorageWithWaitAndNotify {
   private final int                MAX_SIZE = 10;
   private       LinkedList<Object> list     = new LinkedList<Object>();

   public void produce() {
       synchronized (list) {
           while (list.size() == MAX_SIZE) {
               System.out.println("仓库已满：生产暂停");
               try {
                   list.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

           list.add(new Object());
           System.out.println("生产了一个新产品，现库存为：" + list.size());
           list.notifyAll();
       }
   }

   public void consume() {
       synchronized (list) {
           while (list.size() == 0) {
               System.out.println("库存为0：消费暂停");
               try {
                   list.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

           list.remove();
           System.out.println("消费了一个产品，现库存为：" + list.size());
           list.notifyAll();
       }
   }


}


await和signal

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class StorageWithAwaitAndSignal {
   private final int                MAX_SIZE = 10;
   private       ReentrantLock      mLock    = new ReentrantLock();
   private       Condition          mEmpty   = mLock.newCondition();
   private       Condition          mFull    = mLock.newCondition();
   private       LinkedList<Object> mList    = new LinkedList<Object>();

   public void produce() {
       mLock.lock();
       while (mList.size() == MAX_SIZE) {
           System.out.println("缓冲区满，暂停生产");
           try {
               mFull.await();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       mList.add(new Object());
       System.out.println("生产了一个新产品，现容量为：" + mList.size());
       mEmpty.signalAll();

       mLock.unlock();
   }

   public void consume() {
       mLock.lock();
       while (mList.size() == 0) {
           System.out.println("缓冲区为空，暂停消费");
           try {
               mEmpty.await();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       mList.remove();
       System.out.println("消费了一个产品，现容量为：" + mList.size());
       mFull.signalAll();

       mLock.unlock();
   }
}

BlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

public class StorageWithBlockingQueue {
   private final int                         MAX_SIZE = 10;
   private       LinkedBlockingQueue<Object> list     = new LinkedBlockingQueue<Object>(MAX_SIZE);

   public void produce() {
       if (list.size() == MAX_SIZE) {
           System.out.println("缓冲区已满，暂停生产");
       }

       try {
           list.put(new Object());
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("生产了一个产品，现容量为：" + list.size());
   }

   public void consume() {
       if (list.size() == 0) {
           System.out.println("缓冲区为空，暂停消费");
       }

       try {
           list.take();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("消费了一个产品，现容量为：" + list.size());
   }

}

13.final、finally、finalize区别

14.Java中单例模式

  //需要注意的是volatile
  private static volatile SingleTon mInstance;

  private SingleTon() {

  }

  public static SingleTon getInstance() {
      if (mInstance == null) { 
          synchronized (SingleTon.class) {
              if (mInstance == null) {
                  mInstance=new SingleTon();
              }
          }
      }

      return mInstance;
  }
}


   private SingletonWithInnerClass() {

   }

   private static class SingletonHolder{
       private static SingletonWithInnerClass INSTANCE=new SingletonWithInnerClass();
   }

   public SingletonWithInnerClass getInstance() {
       return SingletonHolder.INSTANCE;
   }

}

由于外部类的加载并不会导致内部类立即加载，只有当调用getInstance的时候才会加载内部类，所以实现了延迟初始化。由于类只会被加载一次，并且类加载也是线程安全的，所以满足我们所有的需求。静态内部类实现的单例也是最为推荐的一种方式。

15.Java中引用类型的区别，具体的使用场景

16.Exception和Error的区别

17.volatile

网络相关面试题

1.http 状态码

2.http 与 https 的区别？https 是如何工作的？

3.TCP三次握手流程

Android面试题

1.Android中的动画有哪几类，它们的特点和区别是什么

2.Android性能优化工具使用（这个问题建议配合Android中的性能优化）

3.Android性能优化

4.Android内存优化

5.Binder机制

6.图片加载如何避免OOM

7.数据结构与算法

3.总结

4.最后

为大家准备了一些需要学习掌握的知识，这些都是我们工作，面试的资本。
读者福利

加群免费领取安卓进阶学习视频，源码，面试资料，群内有大牛一起交流讨论技术；【1005956838】。 （包括跨平台开发(Flutter，Weex)、java基础与原理，自定义控件、NDK、架构设计、性能优化、完整商业项目开发等）

阿里P7系列视频教程.png
面试各大专题整理

至此，本篇已结束，如有不对的地方，欢迎建议与指正。同时期待您的关注，感谢您的阅读，谢谢！希望大家共同进步。

上一篇下一篇

猜你喜欢

热点阅读