专栏名称: 开发者全社区
分享和推送Java/Android方向的技术和文章，让你成为这方面的大牛，让你每天都成长一点。同时，我们也会邀请BAT的大牛分享原创！
目录
相关文章推荐
鸿洋  ·  ActivityTaskManagerSer ... ·  16 小时前  
鸿洋  ·  关于 2025 副业探索，DeepSeek ... ·  昨天  
51好读  ›  专栏  ›  开发者全社区

金三银四，来一波Android面试(附答案)

开发者全社区  · 公众号  · android  · 2019-04-02 08:09

正文

热 文导读| 点击标题阅读

如何才能成为优秀的架构师？

来源：BlackFlag

https://www.jianshu.com/p/564b3920697a


JAVA面试题

1.GC机制

垃圾回收需要完成两件事：找到垃圾，回收垃圾。
找到垃圾一般的话有两种方法：

  • 引用计数法
    当一个对象被引用时，它的引用计数器会加一，垃圾回收时会清理掉引用计数为0的对象。但这种方法有一个问题，比方说有两个对象A和B，A引用了B，B又引用了A，除此之外没有别的对象引用A和B，那么A和B在我们看来已经是垃圾对象，需要被回收，但它们的引用计数不为0，没有达到回收的条件。正因为这个循环引用的问题，Java并没有采用引用计数法。

  • 可达性分析法
    我们把Java中对象引用的关系看做一张图，从根级对象不可达的对象会被垃圾收集器清除。根级对象一般包括Java虚拟机栈中的对象、本地方法栈中的对象、方法区中的静态对象和常量池中的常量。
    回收垃圾的话有这么四种方法：

  • 标记清除算法
    顾名思义分为两步，标记和清除。首先标记到需要回收的垃圾对象，然后回收掉这些垃圾对象。标记清除算法的缺点是清除垃圾对象后会造成内存的碎片化。

  • 复制算法
    复制算法是将存活的对象复制到另一块内存区域中，并做相应的内存整理工作。复制算法的优点是可以避免内存碎片化，缺点也显而易见，它需要两倍的内存。

  • 标记整理算法
    标记整理算法也是分两步，先标记后整理。它会标记需要回收的垃圾对象，清除掉垃圾对象后会将存活的对象压缩，避免了内存的碎片化。

  • 分代算法
    分代算法将对象分为新生代和老年代对象。那么为什么做这样的区分呢？主要是在Java运行中会产生大量对象，这些对象的生命周期会有很大的不同，有的生命周期很长，有的甚至使用一次之后就不再使用。所以针对不同生命周期的对象采用不同的回收策略，这样可以提高GC的效率。
    新生代对象分为三个区域：Eden区和两个Survivor区。新创建的对象都放在Eden区，当Eden区的内存达到阈值之后会触发Minor GC，这时会将存活的对象复制到一个Survivor区中，这些存活对象的生命存活计数会加一。这时Eden区会闲置，当再一次达到阈值触发Minor GC时，会将Eden区和之前一个Survivor区中存活的对象复制到另一个Survivor区中，采用的是我之前提到的复制算法，同时它们的生命存活计数也会加一。这个过程会持续很多遍，直到对象的存活计数达到一定的阈值后会触发一个叫做晋升的现象：新生代的这个对象会被放置到老年代中。
    老年代中的对象都是经过多次GC依然存活的生命周期很长的Java对象。当老年代的内存达到阈值后会触发Major GC，采用的是标记整理算法。


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

JVM的内存区域可以分为两类：线程私有和区域和线程共有的区域。
线程私有的区域：程序计数器、JVM虚拟机栈、本地方法栈
线程共有的区域：堆、方法区、运行时常量池

  • 程序计数器。每个线程有有一个私有的程序计数器，任何时间一个线程都只会有一个方法正在执行，也就是所谓的当前方法。程序计数器存放的就是这个当前方法的JVM指令地址。

  • JVM虚拟机栈。创建线程的时候会创建线程内的虚拟机栈，栈中存放着一个个的栈帧，对应着一个个方法的调用。JVM虚拟机栈有两种操作，分别是压栈和出站。栈帧中存放着局部变量表、方法返回值和方法的正常或异常退出的定义等等。

  • 本地方法栈。跟JVM虚拟机栈比较类似，只不过它支持的是Native方法。

  • 堆。堆是内存管理的核心区域，用来存放对象实例。几乎所有创建的对象实例都会直接分配到堆上。所以堆也是垃圾回收的主要区域，垃圾收集器会对堆有着更细的划分，最常见的就是把堆划分为新生代和老年代。

  • 方法区。方法区主要存放类的结构信息，比如静态属性和方法等等。

  • 运行时常量池。运行时常量池位于方法区中，主要存放各种常量信息。

其实除了程序计数器，其他的部分都会发生OOM。

  • 堆。通常发生的OOM都会发生在堆中，最常见的可能导致OOM的原因就是内存泄漏。

  • JVM虚拟机栈和本地方法栈。当我们写一个递归方法，这个递归方法没有循环终止条件，最终会导致StackOverflow的错误。当然，如果栈空间扩展失败，也是会发生OOM的。

  • 方法区。方法区现在基本上不太会发生OOM，但在早期内存中加载的类信息过多的情况下也是会发生OOM的。


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

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

加载。加载是将字节码数据从不同的数据源读取到JVM内存，并映射为JVM认可的数据结构，也就是Class对象的过程。数据源可以是Jar文件、Class文件等等。如果数据的格式并不是ClassFile的结构，则会报ClassFormatError。

链接。链接是类加载的核心部分，这一步分为3个步骤：验证、准备、解析。

  • 验证。验证是保证JVM安全的重要步骤。JVM需要校验字节信息是否符合规范，避免恶意信息和不规范数据危害JVM运行安全。如果验证出错，则会报VerifyError。

  • 准备。这一步会创建静态变量，并为静态变量开辟内存空间。

  • 解析。这一步会将符号引用替换为直接引用。
    初始化。初始化会为静态变量赋值，并执行静态代码块中的逻辑。

双亲委派模型。

类加载器大致分为3类：启动类加载器、扩展类加载器、应用程序类加载器。
启动类加载器主要加载 jre/lib下的jar文件。
扩展类加载器主要加载 jre/lib/ext 下的jar文件。
应用程序类加载器主要加载 classpath下的文件。

所谓的双亲委派模型就是当加载一个类时，会优先使用父类加载器加载，当父类加载器无法加载时才会使用子类加载器去加载。这么做的目的是为了避免类的重复加载。


4.HashMap的原理

HashMap的内部可以看做数组+链表的复合结构。数组被分为一个个的桶(bucket)。哈希值决定了键值对在数组中的寻址。具有相同哈希值的键值对会组成链表。需要注意的是当链表长度超过阈值(默认是8)的时候会触发树化，链表会变成树形结构。

把握HashMap的原理需要关注4个方法：hash、put、get、resize。

hash方法。将key的hashCode值的高位数据移位到低位进行异或运算。这么做的原因是有些key的hashCode值的差异集中在高位，而哈希寻址是忽略容量以上高位的，这种做法可以有效避免哈希冲突。

put方法。put方法主要有以下几个步骤：

  • 通过hash方法获取hash值，根据hash值寻址。

  • 如果未发生碰撞，直接放到桶中。

  • 如果发生碰撞，则以链表形式放在桶后。

  • 当链表长度大于阈值后会触发树化，将链表转换为红黑树。

  • 如果数组长度达到阈值，会调用resize方法扩展容量。

get方法。get方法主要有以下几个步骤：

  • 通过hash方法获取hash值，根据hash值寻址。

  • 如果与寻址到桶的key相等，直接返回对应的value。

  • 如果发生冲突，分两种情况。如果是树，则调用getTreeNode获取value；如果是链表则通过循环遍历查找对应的value。

resize方法。resize做了两件事：

  • 将原数组扩展为原来的2倍

  • 重新计算index索引值，将原节点重新放到新的数组中。这一步可以将原先冲突的节点分散到新的桶中。


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

6.sleep和wait的区别

  • sleep方法是Thread类中的静态方法，wait是Object类中的方法

  • sleep并不会释放同步锁，而wait会释放同步锁

  • sleep可以在任何地方使用，而wait只能在同步方法或者同步代码块中使用

  • sleep中必须传入时间，而wait可以传，也可以不传，不传时间的话只有notify或者notifyAll才能唤醒，传时间的话在时间之后会自动唤醒


7.join的用法

join方法通常是保证线程间顺序调度的一个方法，它是Thread类中的方法。比方说在线程A中执行线程B.join()，这时线程A会进入等待状态，直到线程B执行完毕之后才会唤醒，继续执行A线程中的后续方法。

join方法可以传时间参数，也可以不传参数，不传参数实际上调用的是join(0)。它的原理其实是使用了wait方法，join的原理如下： 


public final synchronized void




    
 join(long millis)
   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中生产者与消费者模式

生产者消费者模式要保证的是当缓冲区满的时候生产者不再生产对象，当缓冲区空时，消费者不再消费对象。实现机制就是当缓冲区满时让生产者处于等待状态，当缓冲区为空时让消费者处于等待状态。当生产者生产了一个对象后会唤醒消费者，当消费者消费一个对象后会唤醒生产者。

三种种实现方式：wait和notify、await和signal、BlockingQueue。

  • wait和notify 

//wait和notify
import java.util.LinkedList;

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

   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 mList    = new LinkedList();

   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 list     = new LinkedBlockingQueue(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区别

final可以修饰类、变量和方法。修饰类代表这个类不可被继承。修饰变量代表此变量不可被改变。修饰方法表示此方法不可被重写(override)。

finally是保证重点代码一定会执行的一种机制。通常是使用try-finally或者try-catch-finally来进行文件流的关闭等操作。

finalize是Object类中的一个方法，它的设计目的是保证对象在垃圾收集前完成特定资源的回收。finalize机制现在已经不推荐使用，并且在JDK 9已经被标记为deprecated。


14.Java中单例模式

Java中常见的单例模式实现有这么几种：饿汉式、双重判断的懒汉式、静态内部类实现的单例、枚举实现的单例。

这里着重讲一下双重判断的懒汉式和静态内部类实现的单例。

双重判断的懒汉式： 

public class SingleTon {
   //需要注意的是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;
   }
}


双重判断的懒汉式单例既满足了延迟初始化，又满足了线程安全。通过synchronized包裹代码来实现线程安全，通过双重判断来提高程序执行的效率。这里需要注意的是单例对象实例需要有volatile修饰，如果没有volatile修饰，在多线程情况下可能会出现问题。原因是这样的，mInstance=new SingleTon() 这一句代码并不是一个原子操作，它包含三个操作：

  1. 给mInstance分配内存

  2. 调用SingleTon的构造方法初始化成员变量

  3. 将mInstance指向分配的内存空间（在这一步mInstance已经不为null了）

我们知道JVM会发生指令重排，正常的执行顺序是1-2-3，但发生指令重排后可能会导致1-3-2。我们考虑这样一种情况，当线程A执行到1-3-2的3步骤暂停了，这时候线程B调用了getInstance，走到了最外层的if判断上，由于最外层的if判断并没有synchronized包裹，所以可以执行到这一句，这时候由于线程A已经执行了步骤3，此时mInstance已经不为null了，所以线程B直接返回了mInstance。但其实我们知道，完整的初始化必须走完这三个步骤，由于线程A只走了两个步骤，所以一定会报错的。

解决的办法就是使用volatile修饰mInstance，我们知道volatile有两个作用：保证可见性和禁止指令重排，在这里关键在于禁止指令重排，禁止指令重排后保证了不会发生上述问题。

静态内部类实现的单例： 

class SingletonWithInnerClass {

   private SingletonWithInnerClass() {

   }

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

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

}


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

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

Java中引用类型分为四类：强引用、软引用、弱引用、虚引用。

强引用：强引用指的是通过new对象创建的引用，垃圾回收器即使是内存不足也不会回收强引用指向的对象。

软引用：软引用是通过SoftRefrence实现的，它的生命周期比强引用短，在内存不足，抛出OOM之前，垃圾回收器会回收软引用引用的对象。软引用常见的使用场景是存储一些内存敏感的缓存，当内存不足时会被回收。

弱引用：弱引用是通过WeakRefrence实现的，它的生命周期比软引用还短，GC只要扫描到弱引用的对象就会回收。弱引用常见的使用场景也是存储一些内存敏感的缓存。

虚引用：虚引用是通过FanttomRefrence实现的，它的生命周期最短，随时可能被回收。如果一个对象只被虚引用引用，我们无法通过虚引用来访问这个对象的任何属性和方法。它的作用仅仅是保证对象在finalize后，做某些事情。虚引用常见的使用场景是跟踪对象被垃圾回收的活动，当一个虚引用关联的对象被垃圾回收器回收之前会收到一条系统通知。


16.Exception和Error的区别

Exception和Error都继承于Throwable，在Java中，只有Throwable类型的对象才能被throw或者catch，它是异常处理机制的基本组成类型。

Exception和Error体现了Java对不同异常情况的分类。Exception是程序正常运行中，可以预料的意外情况，可能并且应该被捕获，进行相应的处理。

Error是指在正常情况下，不大可能出现的情况，绝大部分Error都会使程序处于非正常、不可恢复的状态。既然是非正常，所以不便于也不需要捕获，常见的OutOfMemoryError就是Error的子类。

Exception又分为checked Exception和unchecked Exception。checked Exception在代码里必须显式的进行捕获，这是编译器检查的一部分。unchecked Exception也就是运行时异常，类似空指针异常、数组越界等，通常是可以避免的逻辑错误，具体根据需求来判断是否需要捕获，并不会在编译器强制要求。


17.volatile

一般提到volatile，就不得不提到内存模型相关的概念。我们都知道，在程序运行中，每条指令都是由CPU执行的，而指令的执行过程中，势必涉及到数据的读取和写入。程序运行中的数据都存放在主存中，这样会有一个问题，由于CPU的执行速度是要远高于主存的读写速度，所以直接从主存中读写数据会降低CPU的效率。为了解决这个问题，就有了高速缓存的概念，在每个CPU中都有高速缓存，它会事先从主存中读取数据，在CPU运算之后在合适的时候刷新到主存中。

这样的运行模式在单线程中是没有任何问题的，但在多线程中，会导致缓存一致性的问题。举个简单的例子：i=i+1 ,在两个线程中执行这句代码，假设i的初始值为0。我们期望两个线程运行后得到2，那么有这样的一种情况，两个线程都从主存中读取i到各自的高速缓存中，这时候两个线程中的i都为0。在线程1执行完毕得到i=1，将之刷新到主存后，线程2开始执行，由于线程2中的i是高速缓存中的0，所以在执行完线程2之后刷新到主存的i仍旧是1。

所以这就导致了对共享变量的缓存一致性的问题，那么为了解决这个问题，提出了缓存一致性协议：当CPU在写数据时，如果发现操作的是共享变量，它会通知其他CPU将它们内部的这个共享变量置为无效状态，当其他CPU读取缓存中的共享变量时，发现这个变量是无效的，它会从新从主存中读取最新的值。

在Java的多线程开发中，有三个重要概念：原子性、可见性、有序性。
原子性：一个或多个操作要么都不执行，要么都执行。
可见性：一个线程中对共享变量(类中的成员变量或静态变量)的修改，在其他线程立即可见。
有序性：程序执行的顺序按照代码的顺序执行。
把一个变量声明为volatile，其实就是保证了可见性和有序性。
可见性我上面已经说过了，在多线程开发中是很有必要的。这个有序性还是得说一下，为了执行的效率，有时候会发生指令重排，这在单线程中指令重排之后的输出与我们的代码逻辑输出还是一致的。但在多线程中就可能发生问题，volatile在一定程度上可以避免指令重排。

volatile的原理是在生成的汇编代码中多了一个lock前缀指令，这个前缀指令相当于一个内存屏障，这个内存屏障有3个作用：

  • 确保指令重排的时候不会把屏障后的指令排在屏障前，确保不会把屏障前的指令排在屏障后。

  • 修改缓存中的共享变量后立即刷新到主存中。

  • 当执行写操作时会导致其他CPU中的缓存无效。

网络相关面试题

1. http 状态码

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

http是超文本传输协议，而https可以简单理解为安全的http协议。https通过在http协议下添加了一层ssl协议对数据进行加密从而保证了安全。https的作用主要有两点：建立安全的信息传输通道，保证数据传输安全；确认网站的真实性。

http与https的区别主要如下：

  • https需要到CA申请证书，很少免费，因而需要一定的费用

  • http是明文传输，安全性低；而https在http的基础上通过ssl加密，安全性高

  • 二者的默认端口不一样，http使用的默认端口是80；https使用的默认端口是443

https的工作流程

提到https的话首先要说到加密算法，加密算法分为两类：对称加密和非对称加密。

对称加密：加密和解密用的都是相同的秘钥，优点是速度快，缺点是安全性低。常见的对称加密算法有DES、AES等等。

非对称加密：非对称加密有一个秘钥对，分为公钥和私钥。一般来说，私钥自己持有，公钥可以公开给对方，优点是安全性比对称加密高，缺点是数据传输效率比对称加密低。采用公钥加密的信息只有对应的私钥可以解密。常见的非对称加密包括RSA等。

在正式的使用场景中一般都是对称加密和非对称加密结合使用，使用非对称加密完成秘钥的传递，然后使用对称秘钥进行数据加密和解密。二者结合既保证了安全性，又提高了数据传输效率。

https的具体流程如下：

  1. 客户端（通常是浏览器）先向服务器发出加密通信的请求

  • 支持的协议版本，比如TLS 1.0版

  • 一个客户端生成的随机数 random1，稍后用于生成"对话密钥"

  • 支持的加密方法，比如RSA公钥加密

  • 支持的压缩方法

  • 服务器收到请求,然后响应

    • 确认使用的加密通信协议版本，比如TLS 1.0版本。如果浏览器与服务器支持的版本不一致，服务器关闭加密通信

    • 一个服务器生成的随机数random2，稍后用于生成"对话密钥"

    • 确认使用的加密方法，比如RSA公钥加密

    • 服务器证书

  • 客户端收到证书之后会首先会进行验证

    • 首先验证证书的安全性

    • 验证通过之后，客户端会生成一个随机数pre-master secret，然后使用证书中的公钥进行加密，然后传递给服务器端

  • 服务器收到使用公钥加密的内容，在服务器端使用私钥解密之后获得随机数pre-master secret，然后根据radom1、radom2、pre-master secret通过一定的算法得出一个对称加密的秘钥，作为后面交互过程中使用对称秘钥。同时客户端也会使用radom1、radom2、pre-master secret，和同样的算法生成对称秘钥。

  • 然后再后续的交互中就使用上一步生成的对称秘钥对传输的内容进行加密和解密。


    • 3.TCP三次握手流程

    Android面试题

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

    Android中动画大致分为3类：帧动画、补间动画（View Animation）、属性动画（Object Animation）。

    • 帧动画：通过xml配置一组图片，动态播放。很少会使用。

    • 补间动画（View Animation）：大致分为旋转、透明、缩放、位移四类操作。很少会使用。

    • 属性动画（Object Animation）：属性动画是现在使用的最多的一种动画，它比补间动画更加强大。属性动画大致分为两种使用类型，分别是ViewPropertyAnimator和ObjectAnimator。前者适合一些通用的动画，比如旋转、位移、缩放和透明，使用方式也很简单通过View.animate()即可得到ViewPropertyAnimator，之后进行相应的动画操作即可。后者适合用于为我们的自定义控件添加动画，当然首先我们应该在自定义View中添加相应的getXXX()和setXXX()相应属性的getter和setter方法，这里需要注意的是在setter方法内改变了自定义View中的属性后要调用invalidate()来刷新View的绘制。之后调用ObjectAnimator.of属性类型()返回一个ObjectAnimator，调用start()方法启动动画即可。







    请到「今天看啥」查看全文


    推荐文章
    鸿洋  ·  ActivityTaskManagerService端的“Activity”与App端的Activity
    16 小时前
    鸿洋  ·  关于 2025 副业探索，DeepSeek 回答很惊艳
    昨天
    总裁俱乐部  ·  你的形象里，藏着你的生活态度！
    8 年前
    韩国me2day  ·  就是要舒服！6款乐福鞋冬日搭配
    8 年前
    钱江晚报  ·  才十来分钟，两个孩子不见了！宁波两个要带孩子回家过年的父亲，求大家帮帮他们
    8 年前
    爆笑gif图  ·  发生在深圳！妹子路边玩手机被抢，却遭遇史上最快破案，全程仅10秒！
    7 年前
    月供商城  ·  愉粲农庄，月供宝商城合作农场，品质生鲜，新鲜直供
    7 年前
    Sov5搜索   ·   小百科   ·   今天看啥   ·   移动版
    51好读 - 好文章就要读起来!