Android 知识相关问题整理

已于 2024-08-17 22:04:23 修改
阅读量284 收藏
点赞数
分类专栏： 面试 文章标签： android
于 2021-05-19 22:55:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_12345_liu/article/details/116504598
版权

文章目录

算法题：给你一个数组，判断该数组是不是二叉搜索树的后序遍历序列。（剑指offer30题）

https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/
由于工作了，好久没看树方面的知识，二叉搜索树的定义有点忘了，面试后搜索定义如下：

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

解法一
后序遍历的最后一个数字一定是根节点，我们可以在数组中确定根节点的位置。
在这里插入图片描述
上面这棵树的后序遍历：
[3，5，4，10，12，9]，
后续遍历的最后一个数字一定是根节点，所以数组中最后一个数字9就是根节点，我们从前往后找到第一个比9大的数字10，那么10后面的[10，12]（除了9）都是9的右子节点，10前面的[3，5，4]都是9的左子节点，10以及10后面的需要判断一下，如果有小于9的，说明不是二叉搜索树，直接返回false。然后再以递归的方式判断左右子树。

代码：

    public boolean verifyPostorder(int[] postorder) {
        return helper(postorder, 0, postorder.length - 1);
    }

    boolean helper(int[] nums, int left, int right) {
        if (left >= right) {
            return true;
        }

        int leftIndex = left;

        // 数组中的最后一个数字是二叉搜索树的根节点
        int root = nums[right];
        while (nums[leftIndex] < root) {
            leftIndex++;
        }
        int rightIndex = leftIndex;
        while (rightIndex < right) {
            if (nums[rightIndex++] < root) {
                return false;
            }
        }
        return helper(nums, left, leftIndex - 1) && helper(nums, leftIndex, right - 1);
    }

Android属性动画和补间动画的区别

两者的主要区别：

  • 作用对象不同，补间动画只能作用于View上，而属性动画可以作用于所有对对应属性提供了set和get方法的对象上。
  • 补间动画只是改变动画的显示效果，不会真正改变View的属性，比如位置，宽高等。而属性动画则会改变对象的属性值。
  • 补间动画只能实现位移，缩放，旋转，透明度四种动画操作，而属性动画可以实现更多的效果。

属性动画是如何驱动的

详细的属性动画的驱动原理可以看下面的博客，博主介绍的很详细。
看了博客之后，可以将属性动画的运行原理大体概括为下面的流程。

  1. 调用start()之后，回去注册屏幕刷新信号，当接收到屏幕刷新信号后，会遍历待执行的属性动画列表，计算待执行的属性动画的动画行为。
  2. 每个动画在处理当前帧的刷新逻辑时，先会根据当前时间和动画和动画开始时间，以及动画持续时长来计算得到当前帧时动画所处的进度，然后将这个进度等价转换到0-1区间之内。
  3. 然后插值器会根据这个初步计算之后的进度值，得到实际的动画进度，取值也是在0-1区间内。
  4. 计算得到当前帧处于哪两个关键帧之间，然后根据估值器的规则将进度映射到实际的值。
  5. 然后将计算得到的值回掉到onAnimationUpdate接口中。

参考:https://www.jianshu.com/p/46f48f1b98a9

提升动画性能

Android应用性能优化最佳实践 2.7节动画性能中，对属性动画和补件动画的性能进行了对比，对比显示属性动画的性能更高。同时动画过程如果只涉及scale，alpha等非布局全量刷新的场景时，可以将硬件加速打开，提升动画流畅性，同时可以使用setLayerType设置layer的类型，比如设置为HARD_WARE_LAYER类型或者SOFTWARE_LAYER。

android中导致oom的主要原因

  1. 加载大图
    Android中Bitmap会占用很多内存，在加载BItmap的时候可以先使用inJustDecodeBounds去解析图片的大小，预估图片占用的内存，或者对图片进行采样和缩放，避免占用过多内存。
  2. 内存泄漏
    单例，非静态内部类持有外部类的引用（AsyncTask，Handler），context被引用导致内存泄漏。
  3. 应用程序自己的虚拟机内存上限太小。
  4. 堆溢出或者永久代溢出
    堆溢出是由于分配大对象，或者内存泄漏引起的。
    永久代中存放了被虚拟机加载的类信息，常量，静态变量等，方法区被撑爆也会造成oom。

多线程问题：线程A等待线程B的执行结果，线程B等待线程C的执行结果

使用CountDownLatch来实现，先简单介绍CountDownLatch的用法和作用。

  • CountDownLatch可以用来使一个线程等待其他线程执行完毕后再执行。调用一次countDown的话，计数器的值会减一，当计数器的值为0时，在CountDownLatch上面等待的线程会被唤醒，重新开始工作。

相关接口：

//参数count为计数值
public CountDownLatch(int count)

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException {};   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//将count值减1
public void countDown() { };

代码如下：


/**
 * 有三个线程，线程A等待线程B执行结果，
 * 线程B等待线程C的执行结果
 */
public class ThreadABC {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatchAB = new CountDownLatch(1);
        CountDownLatch countDownLatchBC = new CountDownLatch(1);

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchAB.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(new java.util.Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }, "Thread-A");

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchBC.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(new java.util.Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
                countDownLatchAB.countDown();
            }
        }, "Thread-B");

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                countDownLatchBC.countDown();
            }
        }, "Thread-C");

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

下面的代码线程B会获取lock锁，然后进入await状态，然后线程d会等待1000ms后去尝试获取锁：


/**
 * 有三个线程，线程A等待线程B执行结果，
 * 线程B等待线程C的执行结果
 */
public class ThreadABC {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatchAB = new CountDownLatch(1);
        CountDownLatch countDownLatchBC = new CountDownLatch(2);
        Lock lock = new ReentrantLock();

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatchAB.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(new java.util.Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }, "Thread-A");

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread b try lock");
                lock.lock();
                System.out.println("thread b lock");
                try {
                    countDownLatchBC.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(new java.util.Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
                countDownLatchAB.countDown();
                lock.unlock();
            }
        }, "Thread-B");

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                countDownLatchBC.countDown();
            }
        }, "Thread-C");

        threadA.start();
        threadB.start();
        threadC.start();

        Thread.sleep(1000);
        Thread threadD = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread d try lock");
                lock.lock();
                System.out.println(Thread.currentThread().getName());
                countDownLatchBC.countDown();
                lock.unlock();
            }
        }, "Thread-D");
        threadD.start();
    }
}

thread b try lock
thread b lock
Thread-C
thread d try lock

上面的代码执行结果日志如上，可以看到d县城尝试去lock并没有获取到锁，所以标名await()使线程进入到阻塞状态，但是并没有释放自己持有的锁。

IntentService了解过吗？

IntentService是继承于Service并异步处理请求的一个类，在IntentService内部有一个工作线程来处理耗时任务，当任务执行完时IntentService会自动停止。在执行任务的时候，每一个耗时任务会在onHandleIntent回调方法中执行，并且每次只会执行一个任务，第一个执行完了再执行第二个。
使用IntentService的优点：

  • 省去了在Service中手动开线程的麻烦，第二，当操作完成时，我们不用手动停止Service，第三，it’s so easy to use！

IntentService代码


public class DemoIntentService extends IntentService {
    private static final String TAG = "DemoIntentService";

    public DemoIntentService() {
        super("DemoIntentService");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate: ");
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        super.onStart(intent, startId);
        Log.i(TAG, "onStart: ");
    }

    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        Log.i(TAG, "onStartCommand: ");
        return super.onStartCommand(intent, flags, startId);
    }


    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Log.i(TAG, "onHandleIntent: " + intent.toString() + " current thread is " + Thread.currentThread());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy: ");
    }
}

activity中启动IntentService的代码：

                //可以启动多次，每启动一次，就会新建一个work thread，但IntentService的实例始终只有一个
                //Operation 1
                Intent startServiceIntent = new Intent();
                startServiceIntent.setClassName("com.example.recyclerviewlearn", "com.example.recyclerviewlearn.DemoIntentService");
                Bundle bundle = new Bundle();
                bundle.putString("param", "oper1");
                startServiceIntent.putExtras(bundle);
                startService(startServiceIntent);

                //Operation 2
                Intent startServiceIntent2 = new Intent();
                startServiceIntent2.setClassName("com.example.recyclerviewlearn", "com.example.recyclerviewlearn.DemoIntentService");
                Bundle bundle2 = new Bundle();
                bundle2.putString("param", "oper2");
                startServiceIntent2.putExtras(bundle2);
                startService(startServiceIntent2);

两次启动IntentService运行的日志如下：

2021-05-18 20:53:01.244 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onCreate: 
2021-05-18 20:53:01.244 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onStartCommand: 
2021-05-18 20:53:01.244 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onStart: 
2021-05-18 20:53:01.245 21393-22982/com.example.recyclerviewlearn I/DemoIntentService: onHandleIntent: Intent { cmp=com.example.recyclerviewlearn/.DemoIntentService (has extras) } current thread is Thread[IntentService[DemoIntentService],5,main]
2021-05-18 20:53:01.245 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onStartCommand: 
2021-05-18 20:53:01.245 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onStart: 
2021-05-18 20:53:01.246 21393-22982/com.example.recyclerviewlearn I/DemoIntentService: onHandleIntent: Intent { cmp=com.example.recyclerviewlearn/.DemoIntentService (has extras) } current thread is Thread[IntentService[DemoIntentService],5,main]
2021-05-18 20:53:01.258 21393-21393/com.example.recyclerviewlearn I/DemoIntentService: onDestroy:

可以看到onHandleIntent方法执行的时候，线程id变成了22982，任务再子线程中执行了。同时每次startService都会调用onStartCommand，onStart，最终调用onHandleIntent方法，任务执行结束后onDestory自动结束生命。
onCreate执行的时候会创建一个HandlerThread对象，并启动线程，紧接着创建ServiceHandler对象，ServiceHandler继承自Handler，用来处理消息。ServiceHandler将获取HandlerThread的Looper就可以开始正常工作了。

    @Override
    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

每一次启动onStart方法，会把数据和消息发送给mServiceHandler，然后发送给onHandleIntent方法。

IntentService可以Bind吗？

    public IBinder onBind(Intent intent) {
        return null;
    }

IntentService的onBind方法返回为null。不建议使用bind方法绑定，如果需要使用bind方法绑定的话，这个时候IntentService就变为了Service。

实现一个子线程的Handler

实现一个子线程的Handler我们可以使用下面的方式：

  • 创建当前线程的Looper

  • 创建当前线程的Handler

  • 调用当前线程Looper对象的loop方法
    代码如下：

public class ChildThreadHandlerActivity extends Activity {
    private MyThread childThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler);

        childThread = new MyThread();
        childThread.start();

        Handler childHandler = new Handler(childThread.childLooper){//这样之后，childHandler和childLooper就关联起来了。
            public void handleMessage(Message msg) {
                
            };
        };
    }

    private class MyThread extends Thread{
        public Looper childLooper;

        @Override
        public void run() {
            Looper.prepare();//创建与当前线程相关的Looper
            childLooper = Looper.myLooper();//获取当前线程的Looper对象
            Looper.loop();//调用此方法，消息才会循环处理
        }
    }
}

但是上面的代码会存在空指针的问题，因为我们是在子线程的run方法中创建Looper的，有可能主线程中获取looper的时候子线程的run方法还没有得到执行，就会有空指针问题。
那如何解决上面的问题呢，我们可以使用HandlerThread创建得到一个子线程的Looper：

        HandlerThread handlerThread = new HandlerThread("HandlerThread");
        handlerThread.start();

使用HandlerThread是如何避免空指针的呢?查看HandlerThread的实现：

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

getLooper的时候回去判断，当前的Looper如果为空的话，就会让线程wait()，那么唤醒的地方在哪里呢？

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

HandlerThread的run方法在执行的时候，先会去创建Looper，创建了Looper以后会去调用notifyAll()，这样就将等待的线程唤醒了，从而避免了空指针。

设计模式

工厂模式：
对创建对象的接口进行封装，只根据名称获取对应的具体实现类。
优点：获取产品的时候只用知道名称就可以，扩展的时候增加具体的实现类就可以了。
缺点：同一个接口中扩展产品困难。扩展产品只能增加工厂，增加了复杂度。
参考：https://www.runoob.com/design-pattern/factory-pattern.html

抽象工厂模式：
是围绕一个超级工厂创建其他工厂。该超级工厂又称为其它工厂的工厂。简单理解为有多个接口，根据需要选择实现对应的工厂去创建对应的产品。
优点：将不同产品的接口隔离开来，代码封装较好，
缺点：产品族扩展比较麻烦，得改多处代码。
参考：https://www.runoob.com/design-pattern/abstract-factory-pattern.html

设计模式基本原则

  1. 单一职责原则：
    通俗地说，即一个类只负责一项职责。因为如果一个类负责多项职责的话，对其它功能的修改可能影响已有的功能。
    优点：降低了类的复杂度，一个类仅负责一个职责。其逻辑肯定要比负责多项职责简单。
    缺点：代码改动可能比较大
  2. 开放关闭原则
    软件实体（类，模块，函数）是可以被扩展的，但是不可以被修改。
    优点：代码可以具有很好的可扩展性，可维护性。扩展同类型产品的时候可以不修改旧的代码。工厂，抽象工厂
  3. 里氏替换原则：
    里氏替换原则告诉我们，当使用继承的时候，类B继承类A时，除添加新的方法完成新增功能，尽量不要修改父类方法的预期行为。
    里氏替换的重点在不影响原有功能，可以扩展父类的功能。
  4. 依赖倒转原则
    定义：高层模块不应该依赖低层模块，抽象不应该依赖于细节，细节应该依赖于抽象。
    依赖倒转原则的核心思想就是面向接口编程，子类可以根据抽象出来的接口完成自己的功能。这样上层只关注抽象出来的接口的功能，不用关注具体的实现。
  5. 接口隔离原则
    接口分离原则，客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。避免一个实体类中有不需要的接口
  6. 迪米特法则
    最小知道原则，一个对象应该对其他对象保持最少的了解，避免将过多的接口能力暴漏出去。
  7. 组合/聚合复用原则
    组合/聚合复用原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分; 新的对象通过已有对象的接口达到复用已有功能的目的。
    在面向对象的设计中，如果直接继承基类，会破坏封装，因为将基类的实现细节暴漏给了子类。基类的实现发生了改变，则子类的实现也不得不改变。
    聚合和组合
  • 聚合：整体与部分之前的弱关系，部分不会随着整体生命周期的结束而结束。eg：电脑（整体）与 鼠标（部分）
  • 组合：整体与部分之间的强关系，部分随着整体生命周期的结束而结束（部分不能脱离整体单独存在）。 eg: 鸟（整体）与 翅膀（部分）
    设计模式七大基本原则：
    https://zhuanlan.zhihu.com/p/24614363

commit和apply的区别

相同点：

  • 两者都是提交Preference的修改数据
  • 两者都是原子的操作
    不同点
  • commit会有返回值，apply没有返回值
  • commit的执行是同步的，如果进行并发处理的时候会等待之前的commit执行后再进行操作，而Apply的执行是异步的，因此效率较高

当不需要返回值的时候优先使用apply，因为apply是异步的，当需要返回值的时候还是需要使用commit的。

实现一个阻塞队列

面试的时候被问到手动实现一个阻塞队列，回答得并不好，自己下来在网上搜了下，发现其实也没有那么难，其实就是对wait和notify机制需要掌握。
首先wait和notfy需要在同步块中调用，不然会抛出IllegalMonitorStateException异常，

在实现阻塞队列的时候我们主要实现两个接口，take和put，take用于从阻塞队列中获取元素，put用于向阻塞队列中放置元素，实现代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class BlockQueue {
    public static final int CAPASITY = 20;

    private final Object mLock = new Object();

    private static final List<Integer> mQueue = new ArrayList<>();

    public void add(int num) {
        synchronized (mLock) {

            // 这里使用while循环，防止当线程被唤醒的时候但是这个时候条件还是不满足的，
            // 就直接往队列中添加元素，比如一个线程添加元素后队列满，如果没有while，唤醒另一个生产者线程
            // 就会直接再次想list中添加元素
            while (mQueue.size() == CAPASITY) {
                System.out.println("Queue 满，生产者开始wait" + Thread.currentThread().getName());
                try {
                    mLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            mQueue.add(mQueue.size(), num);
            System.out.println("Queue produce :[" + num + "] 当前线程为:" + Thread.currentThread().getName());

            // 唤醒在这个锁上面等待的所有线程，线程之间通过竞争获取锁
            mLock.notifyAll();
        }
    }

    public void take() {
        synchronized (mLock) {
        	// 当队列为空的时候停止消费者线程获取元素
            while (mQueue.size() == 0) {
                try {
                    System.out.println("队列为空，停止消费者");
                    mLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            int num = mQueue.remove(0);
            System.out.println("Queue Cosumer :[" + num + "] 当前线程为:" + Thread.currentThread().getName());
            // 唤醒这个锁上面等待的所有线程
            mLock.notifyAll();
        }
    }

    public static void main(String[] args) {
        BlockQueue blockQueue = new BlockQueue();

        new Thread(() -> {
            for (; ; ) {
                blockQueue.add(ThreadLocalRandom.current().nextInt());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "生产者线程").start();

        // 消费者sleep的时长大于生产者sleep的时长，所以队列会被生产满，
        new Thread(() -> {
            for (; ; ) {
                blockQueue.take();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者线程1").start();
        // 消费者sleep的时长大于生产者sleep的时长，所以队列会被生产满，
        new Thread(() -> {
            for (; ; ) {
                blockQueue.take();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "消费者线程2").start();
    }
}
liu_12345_liu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【面经分享】字节抖音Android客户端3，今年Android面试必问的这些技术面
wq221aas的博客
01-26 781
二面（1 月 14 日，60 min） 1. 自我介绍 2. 项目介绍。用到了什么技术栈？ ViewModel 的作用是什么？ 你在 Fragment 之间传递数据的时候是怎么做的？ 为什么不用一个全局的静态变量呢？ 你有用 LiveData 自己封装了一个事件总线，讲一讲实现？ 对 Retrofit 的基本结构或者源代码了解吗？ Retrofit 有一个动态代理的过程，有听说过吗？ 3. Kotlin 和 Java 都是在做这个 Android 项目中学习的吗？ 在 Kot
超新鲜的字节客户端Android面经，附面试题答案解析
Androidbye的博客
04-02 2713
一、字节一面 2021.3.28 （不是按顺序写的，最后一个是代码题） 1、自我介绍 2、项目介绍 3、围绕项目（这一块儿问了很久） 4、代码题，深度优先搜索 给你一个二叉树和一个目标值，判断是否有一条路径的各节点之和等于这个目标值 5、tcp、udp区别以及用处 6、Http常见的状态码 7、GET、POST区别 8、GSON 9、RecyclerView的使用，复用机制，四级缓存 10、ListView、RecyclerView的区别 11、事件分发机制 12、记不得了++.
2020下半年，最接地气的字节跳动Android面经分享（已收offer，Android程序员如何有效提升学习效率
m0_64319112的博客
12-07 503
懂一点应用层方面的音视频编解码知识 我的字节面经： ================================================================== 字节一面 八十多分钟：（大多是技术问题） 自我介绍，项目介绍 一个activity启动另外一个activity的生命周期调用(这里扯到了allowtaskreparent和taskaffinity handle的原理，子线程为什么不能更新UI？ view的绘制过程 滑动冲突 接口和抽象类的区别 .
2020下半年，最接地气的字节跳动Android面经分享（已收offer）
Android 开发架构
11-27 3205
摘要： 开篇之前，首先说一下，博主曾经也只是尘世间一个迷途小开发，二流程序员。可能这篇文章并不像其他面经一样金光闪闪，只是一个二流Android攻城狮在市场的大潮之下，用一个月时间面试+复习+总结，最终拿到了自己喜欢公司offer(字节跳动Android开发岗，薪资也涨了40%多，对我来说已经很满意了)的故事。 出来社会摸爬滚打三年多，不得不承认人是分三六九等的。即便是专注度、努力这些颇为客观的因素，也是因人而异的。 说下我的个人背景吧： 双非本科，计算机专业。 工作三年，都是小厂，小组最多没超过4个人
5000字超详细字节跳动Android客户端面经
最新发布
Android23333的博客
07-22 871
字节的面试体验还是相当不错的。过程中面试官会很耐心地听你讲，对于答不太上来的问题，给出大体思路也是可以的。回答不上来的东西，面试官也会在面试过程中跟你简单介绍一下。大概这就是为什么最开始 HR 和邮件里都有说“不会的题也鼓励和面试官交流想法”吧。反问环节请面试官对面试过程进行评价，以及对个人能力提出一些建议的时候，面试官还是很乐意的，也很能抓住我的不足（废话不然为啥人家能是面试官呢）。在开始面试之后，HR 全程跟进的速度非常快。每场面试结束之后 HR 会询问一下面试感受，还会鼓励我复盘一下。
全面的Android view相关知识汇总整理
01-09
以下是对"全面的Android view相关知识汇总整理"的详细解读： 1. **View的滑动方式** - `layout(left, top, right, bottom)`：直接修改View的坐标来改变位置。 - `offsetLeftAndRight()`和`offsetTopAndBottom()`...
android知识点整理
09-09
### Android知识点整理 #### Java基础 1. **面向对象的理解** - 面向对象编程（OOP）是一种编程范式，它使用“对象”来设计软件。对象包括数据（即字段，也称为属性）和操作这些数据的方法。 - 封装：将对象的...
android基础知识整理版
03-24
本整理版主要涵盖了Android的核心概念，特别是关于应用程序组件的生命周期以及它们之间的交互。下面将详细阐述这些关键知识点。 首先，Android系统中的四大组件是Activity、Service、BroadcastReceiver和...
2022最新Android知识整理.pdf
07-05
在Android开发中，面试经常涉及到Java基础和多态等核心概念。以下是对这些知识点的详细解释： **静态内部类与非静态内部类的区别** 1. **静态内部类**可以在没有外部类实例的情况下被实例化，它只能访问外部类的...
字节跳动效率工程Android实习面经
weixin_45428761的博客
07-23 749
大概一个礼拜之前在字节跳动上海现场进行了Android开发的实习面试，在这里给大家分享一下面经。 一面（30分钟） 自我介绍 讲了一下简历上的安卓实习经历 然后开始问安卓有关的问题 讲一下Activity的生命周期 两个Activity A与B，A切到B，然后按返回键，B再切回A，请问两个Activity都经历了生命周期的哪几步 回答中提到了Activity的启动模式，接着...
新鲜的字节跳动实习面经（Android开发岗），Android面试Android基础
m0_66265052的博客
01-19 176
1.HTTP协议 2.TCP/IP协议 3.TCP的三次握手与四次挥手理解及面试题 4.网页中输入url，到渲染整个界面的整个过程，以及中间用了什么协议？ 5.TCP和UDP的区别？ 6.HTTP的几种请求方法具体介绍 7.HTTP请求和响应报文的格式，以及常用状态码 8.一个 TCP 连接上面能发多少个 HTTP 请求 第二章 Java面试题 1.HashMap 2.ArrayList 3.LinkedList 4.Hashset源码分析 5.内存模型 6.垃圾回收算法（JVM） 7.垃圾回收机制和调
字节跳动Android客户端实习 3+1 面经，内部面试官透露通关秘籍
小圆爱吃糖
10-28 2155
身边很多朋友知道我在字节担任面试官，写文章的初衷之一也是希望能多一个为团队网络人才的渠道。但是一段时间下来发现真正找我咨询、内推的人并不多，不少同学对字节的面试有所忌惮，总担心准备不够。 实际上字节特别是客户端的面试没有网上传说的那么可怕。碍于公司制度，我不能把我面试别人的具体内容写出来，但是可以分享一些候选人自己写的面经供大家参考。 比如今天分享的这个面经，内容靠谱，能够反映出抖音客户端面试的难度。当然面试内容是因人而异的，所以主要是帮大家了解面试范围和难度，无需拘泥于具体题目 背景介绍 我是一名本..
字节跳动面试必问：三年老Android经验面经，系列篇
m0_53537576的博客
02-04 170
最近我在接受采访时被问到我关于成为一名伟大的程序员见解。这是一个有趣的问题，我认为我们都可以是伟大的程序员，无论我们的天赋如何，如果我们遵循一些规则的话——我相信——这应该是常识。实际上，这些规则并不只适用于编程领域，也适合任何专业。 当然，这些要点中的所有内容并不都是完全正儿八经的，有些事情只是我的看法，你的情况可能会有所不同，所以如果出现矛盾的话，不要耿耿于怀。 Scudo是一种用户模式分配器，旨在提供额外的mitigation 来防止堆的漏洞的方法，同时保持良好的性能。它是开源的，是LLVM的edi
有了字节offer才有底气，不给我70w+年薪，我拿什么拒绝你（阿里,华为，腾讯)......
Android725的博客
03-03 445
不要有“自知之明” 先介绍一下大致情况，双一流非科班本科出身，大学期间就自学Java、Android相关东西，也跟着老师做了一个项目，说大其实也不大，就简历上能写上的程度吧。春招没怎么准备被怼到怀疑人生，当时发誓秋招竭尽全力，但是直到两个月前才买了操作系统、JVM 这类的书开始系统学习有关内容，也刷了lc 200+题 我大概从1月初开始准备春招，但是因为过年，二月初才投了第一份简历，自己也挺后悔投的挺晚的，有一些投了根本就没反应。前几天bigo hr面，让我终于看到了曙光，现在还有几家还在流程中，但是真的.
Android客户端面经总结
HaiyerLu的博客
08-21 648
一、Android操作系统架构 二、Android通信方式 三、Android权限系统详解及管理 四、Handler机制 五、Android视图绘制流程 六、Android的分发机制 七、Android四大组件 八、Context 九、系统稳定系列（Crash、ANR） 十、性能优化系列 十一、一些面试中问到的具体问题 ...
【面经分享】字节抖音Android客户端3，字节跳动历年Android中高级面试题全收录
flutter001的博客
12-12 398
MVVM 中的持有关系呢？ MVVM 中各个层在 Android 开发中的对应关系？ 你的 MVVM 用到了 Jetpack 里的 ViewModel，那么它是如何保持数据的呢？ ViewModel 是怎么做到在 Activity 销毁重建新实例之后还能保持不变的呢？ 4. 你有提到说用的 Kotlin，那讲讲 Kotlin 用起来相比 Java 的好处？ 如果用 Kotlin 去调用一个具有返回值的 Java 函数，那么这个返回值是可空的还是非空的呢？ Kotlin 中的可见性..
头条Android客户端开发面经分享
augfun的博客
11-19 318
一面 7月2日 1.C语言中全局变量和局部变量的声明周期 2.new和malloc产生的对象存储空间分配在哪里？对一个结构体数组使用malloc申请空间应该怎么写？ 3.Java的synchronized的用法。写一个生产者消费者模型 4.Android的消息队列，handler机制 5.消息队列是一个死循环，为什么不会发生ANR？ 6.了解哪些设计模式？ 7.算法题：合并两个有序数组 应该还问了一些东西，但是我记得不是很清楚了。总的来说，一面问的东西比较基础也比较浅，算是基础面了。面完后十
这都没挂，2021字节跳动的Android研发岗也太好进了吧？（面经+经验分享）
weixin_44339238的博客
07-12 626
背景 经历了各种尝试和挣扎，终于在今年入职了今日头条，简直是实现了人生一大梦想！！ 本人基本情况是：16年毕业于211院校本科，19-21年在oppo工作，算是有大厂经验了，面试的岗位是Android应用开发工程师。 职位描述： 1、负责手机端系统应用的功能开发，维护和问题修复； 2、负责所维护模块的性能优化，如冷热启动指标优化，滚动优化等； 3、负责所维护模块的内存问题处理，包括解决内存泄漏，内存调优等。 职位要求 1、本科以上学历，计算机或相关专业，3年以上Android实际开发经验 2、...
面经JAVA_Android客户端_研发岗面试基础知识点总结
GitChat
03-12 287
面经JAVAAndroid客户端研发岗面试基础知识点总结（鹅厂，华为，字节，小米，OV等大厂面试经验）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值