diff --git a/code/src/main/java/com/raorao/interview/haoweilai/t1/Main.java b/code/src/main/java/com/raorao/interview/haoweilai/t1/Main.java
new file mode 100644
index 00000000..3b857ebc
--- /dev/null
+++ b/code/src/main/java/com/raorao/interview/haoweilai/t1/Main.java
@@ -0,0 +1,38 @@
+package com.raorao.interview.haoweilai.t1;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-28-19:01
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    String input = scanner.nextLine();
+    System.out.println(process(input));
+  }
+
+  private static int process(String str) {
+    if (str == null || str.length() == 0) {
+      return 0;
+    }
+    if(str.length() == 1 && Integer.parseInt(str) == 0){
+      return 1;
+    }
+    int len = str.length();
+    int count = 0;
+    int sum = 0;
+    for (int i = 0; i < len; i++) {
+      sum += str.charAt(i) - '0';
+      if (sum % 3 == 0) {
+        count++;
+        sum = 0;
+      }
+    }
+    return count;
+  }
+}
diff --git a/code/src/main/java/com/raorao/interview/haoweilai/t1/Main2.java b/code/src/main/java/com/raorao/interview/haoweilai/t1/Main2.java
new file mode 100644
index 00000000..d7f39dba
--- /dev/null
+++ b/code/src/main/java/com/raorao/interview/haoweilai/t1/Main2.java
@@ -0,0 +1,47 @@
+package com.raorao.interview.haoweilai.t1;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-28-19:01
+ */
+public class Main2 {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    String input = scanner.nextLine();
+    System.out.println(process(input));
+  }
+
+
+  private static boolean isOk(String input, int start, int end) {
+    int k = 0;
+    for (int i = start; i < end; i++) {
+      k = 10 * k + input.charAt(i) - '0';
+    }
+    return (k % 3 == 0);
+  }
+
+  private static int process(String str) {
+    if (str == null || str.length() == 0) {
+      return 0;
+    }
+    int len = str.length();
+    int[] v = new int[len + 1];
+    for (int i = 1; i <= len; i++) {
+      int j = i - 1;
+      while (!isOk(str, j, i) && j > 0) {
+        j--;
+      }
+      if (isOk(str, j, i)) {
+        v[i] = Math.max(v[i - 1], v[j] + 1);
+      } else {
+        v[i] = v[i - 1];
+      }
+    }
+    return v[len];
+  }
+}
diff --git a/code/src/main/java/com/raorao/interview/haoweilai/t2/Main.java b/code/src/main/java/com/raorao/interview/haoweilai/t2/Main.java
new file mode 100644
index 00000000..63079e1d
--- /dev/null
+++ b/code/src/main/java/com/raorao/interview/haoweilai/t2/Main.java
@@ -0,0 +1,47 @@
+package com.raorao.interview.haoweilai.t2;
+
+import java.util.Scanner;
+
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-28-19:12
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    int t = Integer.parseInt(scanner.nextLine());
+    int[] res = new int[t];
+    int[][] input = new int[t][2];
+    for (int i = 0; i < t; i++) {
+      String[] tmp = scanner.nextLine().split(" ");
+      input[i][0] = Integer.parseInt(tmp[0]);
+      input[i][1] = Integer.parseInt(tmp[1]);
+    }
+    for (int i = 0; i < t; i++) {
+      res[i] = process(input[i][0], input[i][1]);
+    }
+    for (int i = 0; i < res.length; i++) {
+      System.out.println(res[i]);
+    }
+
+  }
+
+  private static int process(int x, int k) {
+    int y = 1;
+    while (k > 0) {
+      boolean bool = x + y == (x | y);
+      if (bool) {
+        y++;
+        k--;
+      } else {
+        y++;
+      }
+    }
+    return y-1;
+  }
+
+}
diff --git a/code/src/main/java/com/raorao/interview/haoweilai/t3/Main.java b/code/src/main/java/com/raorao/interview/haoweilai/t3/Main.java
new file mode 100644
index 00000000..d52ad087
--- /dev/null
+++ b/code/src/main/java/com/raorao/interview/haoweilai/t3/Main.java
@@ -0,0 +1,56 @@
+package com.raorao.interview.haoweilai.t3;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-28-19:57
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    int[] arr = new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    int[] bool = new int[] {0, 1, 1, 1, 1, 1, 1, 1, 1, 0};
+    process(arr, bool);
+  }
+
+  private static void process(int[] arr, int[] bool) {
+    List<String> res = new ArrayList<>();
+    List<int[]> boolList = new ArrayList<>();
+
+    List<Integer> zeros = new ArrayList<>();
+    for (int i = 0; i < bool.length; i++) {
+      if (bool[i] == 0) {
+        zeros.add(i);
+      }
+    }
+
+    back(zeros,bool, boolList, 0);
+
+    for (int i = 0; i < boolList.size(); i++) {
+      StringBuilder sb = new StringBuilder();
+      for (int j = 0; j < boolList.get(i).length; j++) {
+        if (bool[j] == 1) {
+          sb.append(arr[j]);
+        }
+      }
+      res.add(sb.toString());
+    }
+    res.forEach(e -> System.out.println(e));
+  }
+
+  private static void back(List<Integer> zeros, int[] bool, List<int[]> res, int k) {
+
+  }
+
+  private static int[] arrCopy(int[] arr) {
+    int n = arr.length;
+    int[] res = new int[n];
+    System.arraycopy(arr, 0, res, 0, n);
+    return res;
+  }
+
+}
diff --git a/code/src/main/java/com/raorao/interview/haoweilai/t4/Main.java b/code/src/main/java/com/raorao/interview/haoweilai/t4/Main.java
new file mode 100644
index 00000000..32754d66
--- /dev/null
+++ b/code/src/main/java/com/raorao/interview/haoweilai/t4/Main.java
@@ -0,0 +1,32 @@
+package com.raorao.interview.haoweilai.t4;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-28-20:47
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    String[] line1 = scanner.nextLine().split(" ");
+    int n = Integer.parseInt(line1[0]);
+    int m = Integer.parseInt(line1[1]);
+    String[] line2 = scanner.nextLine().split(" ");
+    int[] score = new int[n];
+    for (int i = 0; i < n; i++) {
+      score[i] = Integer.parseInt(line2[i]);
+    }
+
+    float sum = 0, k;
+    for (int i = 0; i < n; i++) {
+      sum += score[i];
+    }
+    sum /= n - m;
+    System.out.printf("%.2f", sum);
+  }
+
+}
diff --git a/code/src/main/java/com/raorao/java/A.java b/code/src/main/java/com/raorao/java/A.java
index 91dd2598..1c0f279d 100644
--- a/code/src/main/java/com/raorao/java/A.java
+++ b/code/src/main/java/com/raorao/java/A.java
@@ -1,5 +1,10 @@
 package com.raorao.java;
 
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
 /**
  * .
  *
@@ -8,4 +13,24 @@ package com.raorao.java;
  */
 public class A {
 
+  public static void main(String[] args) {
+    ByteBuffer bb = ByteBuffer.wrap(new byte[12]);
+
+    bb.asCharBuffer().put("abcdef");
+    System.out.println(Arrays.toString(bb.array()));
+
+    // 反转缓冲区
+    bb.rewind();
+    // 设置字节存储次序
+    bb.order(ByteOrder.BIG_ENDIAN);
+    bb.asCharBuffer().put("abcdef");
+    System.out.println(Arrays.toString(bb.array()));
+
+    // 反转缓冲区
+    bb.rewind();
+    // 设置字节存储次序
+    bb.order(ByteOrder.LITTLE_ENDIAN);
+    bb.asCharBuffer().put("abcdef");
+    System.out.println(Arrays.toString(bb.array()));
+  }
 }
diff --git a/interview/answer.md b/interview/answer.md
index da5e5feb..3be52061 100644
--- a/interview/answer.md
+++ b/interview/answer.md
@@ -7,6 +7,7 @@
         - [foreach与正常for循环效率对比](#foreach与正常for循环效率对比)
         - [java反射的作用于原理](#java反射的作用于原理)
         - [java 动态代理](#java-动态代理)
+        - [foreach与正常for循环效率对比](#foreach与正常for循环效率对比-1)
 - [数据库](#数据库)
     - [truncate与 delete区别](#truncate与-delete区别)
     - [B+树索引和哈希索引的区别](#b树索引和哈希索引的区别)
@@ -19,6 +20,7 @@
 - [Linux](#linux-1)
     - [Buffer和Cache的区别](#buffer和cache的区别)
         - [个人理解](#个人理解)
+    - [什么是大小端模式](#什么是大小端模式)
 - [计算机网络](#计算机网络)
     - [UDP为什么不可靠](#udp为什么不可靠)
 
@@ -77,7 +79,94 @@ Java 反射是可以让我们在运行时，通过一个类的Class对象来获
 
 ### java 动态代理
 
+实现InvocationHandler接口，重写invoke方法来调用被代理的类的方法。
+client端通过Proxy.newProxyInstance来获取代理后的对象（这里使用了代理模式）
 
+``` java
+public class RealSubject implements Subject
+{
+    @Override
+    public void rent()
+    {
+        System.out.println("I want to rent my house");
+    }
+    
+    @Override
+    public void hello(String str)
+    {
+        System.out.println("hello: " + str);
+    }
+}
+```
+
+``` java
+public class DynamicProxy implements InvocationHandler
+{
+    //　这个就是我们要代理的真实对象
+    private Object subject;
+    
+    //    构造方法，给我们要代理的真实对象赋初值
+    public DynamicProxy(Object subject)
+    {
+        this.subject = subject;
+    }
+    
+    @Override
+    public Object invoke(Object object, Method method, Object[] args)
+            throws Throwable
+    {
+        //　　在代理真实对象前我们可以添加一些自己的操作
+        System.out.println("before rent house");
+        
+        System.out.println("Method:" + method);
+        
+        //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
+        method.invoke(subject, args);
+        
+        //　　在代理真实对象后我们也可以添加一些自己的操作
+        System.out.println("after rent house");
+        
+        return null;
+    }
+
+}
+```
+
+``` java
+public class Client
+{
+    public static void main(String[] args)
+    {
+        //    我们要代理的真实对象
+        Subject realSubject = new RealSubject();
+
+        //    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
+        InvocationHandler handler = new DynamicProxy(realSubject);
+
+        /*
+         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
+         * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
+         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
+         * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
+         */
+        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
+                .getClass().getInterfaces(), handler);
+        
+        System.out.println(subject.getClass().getName());
+        subject.rent();
+        subject.hello("world");
+    }
+}
+```
+
+
+### foreach与正常for循环效率对比
+
+在java中进行测试发现：
+
+需要循环数组结构的数据时，建议使用普通for循环，因为for循环采用下标访问，对于数组结构的数据来说，采用下标访问比较好。
+
+需要循环链表结构的数据时，一定不要使用普通for循环，这种做法很糟糕，数据量大的时候有可能会导致系统崩溃。
 
 # 数据库
 
@@ -233,6 +322,12 @@ Cache就是加快读取的速度，分为磁盘缓存和CPU缓存。
 动态RAM： 计算机内存。
 静态RAM： CPU高速缓存。
 
+## 什么是大小端模式
+
+大端模式（高尾），是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；
+
+小端模式（低尾），是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。
+
 # 计算机网络
 
 ## UDP为什么不可靠
diff --git a/interview/java/img/工厂方法.png b/interview/java/img/工厂方法.png
new file mode 100644
index 00000000..c5bb3ad4
Binary files /dev/null and b/interview/java/img/工厂方法.png differ
diff --git a/interview/java/img/简单工厂模式.png b/interview/java/img/简单工厂模式.png
new file mode 100644
index 00000000..e4d94143
Binary files /dev/null and b/interview/java/img/简单工厂模式.png differ
diff --git a/interview/java/设计模式.md b/interview/java/设计模式.md
new file mode 100644
index 00000000..502f595f
--- /dev/null
+++ b/interview/java/设计模式.md
@@ -0,0 +1,92 @@
+<!-- TOC -->
+
+- [快速理解设计模式](#快速理解设计模式)
+- [创建型模式](#创建型模式)
+    - [单例模式](#单例模式)
+    - [简单工厂模式](#简单工厂模式)
+    - [工厂方法](#工厂方法)
+    - [抽象工厂模式](#抽象工厂模式)
+    - [建造者（生成器）模式](#建造者生成器模式)
+
+<!-- /TOC -->
+
+# 快速理解设计模式
+
+设计模式主要分为3大类，分别是创建型模式、行为型模式和结构型模式。
+
+# 创建型模式
+
+创建型模式主要是和创建对象相关的一些设计模式
+
+## 单例模式
+
+目的：确保某个类在jvm中只有一个实例，提供该实例的全局访问点。
+
+类图：使用一个私有构造函数、私有静态变量，和一个共有的静态函数来实现
+
+懒汉式（线程不安全）、饿汉式、懒汉式（线程安全）
+
+双重校验锁（注意volatile): 
+
+``` java
+public class Singleton {
+
+    private volatile static Singleton uniqueInstance;
+
+    private Singleton() {
+    }
+
+    public static Singleton getUniqueInstance() {
+        if (uniqueInstance == null) {
+            synchronized (Singleton.class) {
+                if (uniqueInstance == null) {
+                    uniqueInstance = new Singleton();
+                }
+            }
+        }
+        return uniqueInstance;
+    }
+}
+```
+
+为什么要使用volatile？
+uniqueInstance = new Singleton(); 这段代码其实是分三步执行：
+
+1. 分配内存空间
+2. 初始化对象
+3. 将 uniqueInstance 指向分配的内存地址
+
+JVM的指令重排序可能导致执行顺序编程1-3-2, 在多线程情况下，可能获取一个没有初始化的实例，导致程序出错。
+
+使用volatile 可以禁止JVM的指令重排序，保证多线程的环境下程序的正常运行。
+
+静态内部类：
+
+实现延迟加载，也能实现一次加载，线程安全、相当于同步的懒汉式
+
+枚举类型：单例模式的最佳实践，实现简单，并且能在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次。
+
+## 简单工厂模式
+
+目的：创建对象的时候隐藏内部细节，提供一个创建对象的通用接口。
+
+类图：在简单工厂模式中，根据传入type类型来决定到底生产哪种具体的产品类
+
+![](img/简单工厂模式.png)
+
+## 工厂方法
+
+目的：工厂方法把类的实例化操作放到子类来执行，本身抽象化。
+
+类图：在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
+
+![](img/工厂方法.png)
+
+## 抽象工厂模式
+
+目的： 抽象工厂模式使用抽象工厂类来产生多个具体的工厂，由具体的工厂来生产各自的产品，最终关联到抽象产品类中，client通过抽象工厂来生产具体的产品。
+
+![](/pics/8668a3e1-c9c7-4fcb-98b2-a96a5d841579.png)
+
+## 建造者（生成器）模式
+
diff --git a/interview/note.md b/interview/note.md
index e9a29c06..74c17fa0 100644
--- a/interview/note.md
+++ b/interview/note.md
@@ -41,7 +41,7 @@ Java后端开发（大数据、分布式应用等）
 华为 |8.1 | 8.21
 百度 | 8.22 | 8.22(新投递) | 
 网易 | 8.22 | 8.22(新投递) |  
-腾讯 | 8.22 | 8.22(新投递) | 电面 | 一面已经挂了
+腾讯 | 8.22 | 8.22(新投递) | 电面 | 一面已经挂了<li> 8.28 第二次一面也挂了
 Intel | 8.23 | 8.23(新投递) | 电面 | 8.24一面
 美团点评 | 8.6 | 8.27 | 
 
@@ -60,6 +60,8 @@ Intel | 8.23 | 8.23(新投递) | 电面 | 8.24一面
 
 > [Java并发和多线程](java/thread.md)
 
+> [快速理解设计模式](java/设计模式.md)
+
 ## 数据结构和算法
 
 > [排序](http://xraorao.top/2018/07/11/%E5%B8%B8%E8%A7%81%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/#more)