一个简易的搜索框

  学之广在于不倦，不倦在于固志。 ——晋·葛洪­

 （学问的渊博在于学习时不知道厌倦，而学习不知厌倦在于有坚定的目标）

       前景：最经项目需要一个搜索框，于是各种搜索下来发现并不适合自己的项目，心里很不是滋味再三思量之后才自己手撸一个搜索框，项目中从需求分析到最终的效果实现用时一下午，但是写个整理出来发布到网上竟然用时1天，里面的搜索结果都是一些本地的假数据，真实数据来自服务器，记得是假数据 ......

       功能演示（模拟延迟，所以会有加载动画）（源码见文尾链接）：

   

       001.搜索框功能：

              ---->: 流式布局展示搜索的历史记录（并模拟了延迟）

                      >>> 可以点击搜索框里面的删除按钮删除输入框的所有内容，并展示相应的历史记录

                      >>> 点击历史记录删除图标删除历史记录，并展示空布局（此处是为了展示空布局效果，是搜索无记录时的展示，可以点击刷新或者其他操作，因为是假数据好多无法模拟就展示在此处）

                       >>> 历史记录最多有10条数据，不可重复，超过10条会删除第10条数据，将最新的数据添加到第一位            

              ---->: 根据搜索框的内容变化进行搜索，即关键字搜索

                       >>> 根据输入框的内容变化进行搜索（本Demo为造假数据，所以不会是你输入什么展示什么，假数据，真是数据来自于你们的服务器），并模拟了搜索延迟

                       >>> 点击关键字列表可以进行最终的条目搜索（本Demo为做实现，直接掉方法即可），并模拟了搜索延迟

              ---->: 根据软键盘点击搜索或者点击关键字的搜索结果执行最终的条目搜索并展示结果

                       >>> 执行最终的搜索，即对输入内容进行全局搜索展示内容

       002.开始实现功能：

              ----> 因为本Demo的数据都是本地的假数据，所有搜索的结果对不上，是正常的，项目中换为服务器数据即可

              ----> 由于整理出来比较耗时，简略MVP模式（项目都是封装好的），所以可能存在披露欢迎大家来找茬，欢迎指正

              ----> 罗列关键类，因为已给出源码，所以就不一一讲解

                     >>> 自定义流布局

/**
 * @author Okamiy
 * @date 2018\8\31 0031 11:38
 * 流式布局
 */
public class FlowLayout extends ViewGroup {
    private int horizontalSpacing = 13;
    private int verticalSpacing = 13;

    private ArrayList<Line> lineList = new ArrayList<Line>();

    public FlowLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public FlowLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public FlowLayout(Context context) {
        super(context);
    }

    public void setHorizontalSpacing(int horizontalSpacing) {
        this.horizontalSpacing = horizontalSpacing;
    }

    public void setVerticalSpacing(int verticalSpacing) {
        this.verticalSpacing = verticalSpacing;
    }

    /**
     * 遍历所有的子View，进行分行的逻辑操作，相当于定好座位表
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        lineList.clear();

        int width = MeasureSpec.getSize(widthMeasureSpec);
        int noPaddingWidth = width - getPaddingLeft() - getPaddingRight();

        Line line = new Line();
        for (int i = 0; i < getChildCount(); i++) {
            View childView = getChildAt(i);
            childView.measure(0, 0);

            if (line.getViewList().size() == 0) {
                line.addLineView(childView);
            } else if (childView.getMeasuredWidth() + line.getLineWidth() + horizontalSpacing > noPaddingWidth) {
                lineList.add(line);


                line = new Line();
                line.addLineView(childView);
            } else {

                line.addLineView(childView);
            }


            if (i == (getChildCount() - 1)) {
                lineList.add(line);
            }

        }


        int height = getPaddingTop() + getPaddingBottom();

        for (int i = 0; i < lineList.size(); i++) {
            height += lineList.get(i).getLineHeight();
        }

        height += (lineList.size() - 1) * verticalSpacing;


        setMeasuredDimension(width, height);
    }

    /**
     * 将所有的line中的子View摆放到指定的位置上
     */
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int paddingLeft = getPaddingLeft();
        int paddingTop = getPaddingTop();
        for (int i = 0; i < lineList.size(); i++) {
            Line line = lineList.get(i);

            if (i > 0) {
                paddingTop += lineList.get(i - 1).getLineHeight() + verticalSpacing;
            }

            ArrayList<View> viewList = line.getViewList();

            int remainSpacing = getLineRemainSpacing(line);
            float perSpacing = remainSpacing / viewList.size();
            for (int j = 0; j < viewList.size(); j++) {
                View child = viewList.get(j);
                if (lineList.size() > 1 && i < lineList.size() - 1) {

                    int widthSpec = MeasureSpec.makeMeasureSpec((int) (child.getMeasuredWidth() + perSpacing), MeasureSpec.EXACTLY);
                    child.measure(widthSpec, 0);
                } else {
                    child.measure(0, 0);
                }


                if (j == 0) {
                    child.layout(paddingLeft, paddingTop, paddingLeft + child.getMeasuredWidth()
                            , paddingTop + child.getMeasuredHeight());
                } else {
                    View preChild = viewList.get(j - 1);

                    int left = preChild.getRight() + horizontalSpacing;
                    child.layout(left, preChild.getTop(), left + child.getMeasuredWidth(), preChild.getBottom());
                }
            }
        }
    }

    /**
     * 获取指定line对象的留白值
     *
     * @param line
     * @return
     */
    private int getLineRemainSpacing(Line line) {
        return getMeasuredWidth() - getPaddingLeft() - getPaddingRight() - line.getLineWidth();
    }

    /**
     * 行对象，用来封装每一行的数据，包括子View，宽度和高度
     *
     * @author Administrator
     */
    class Line {
        private ArrayList<View> viewList = new ArrayList<View>();

        private int lineWidth;

        private int lineHeight;

        /**
         * 往viewList中添加view对象
         *
         * @param child
         */
        public void addLineView(View child) {
            if (!viewList.contains(child)) {
                viewList.add(child);

                if (viewList.size() == 1) {
                    lineWidth = child.getMeasuredWidth();
                } else {
                    lineWidth += horizontalSpacing + child.getMeasuredWidth();
                }

                lineHeight = Math.max(lineHeight, child.getMeasuredHeight());
            }
        }


        public ArrayList<View> getViewList() {
            return viewList;
        }

        public int getLineWidth() {
            return lineWidth;
        }


        public int getLineHeight() {
            return lineHeight;
        }
    }
}

                     >>> View层

public class SearchActivity extends AppCompatActivity implements ISearch {
    private static final String TAG = "SearchActivity";

    @BindView(R.id.ed_search)
    AppCompatEditText mEdSearch;
    @BindView(R.id.iv_clear)
    ImageView mIvClear;
    @BindView(R.id.app_search_cancel)
    TextView mAppSearchCancel;
    @BindView(R.id.top_ll_parents)
    LinearLayout mTopLlParents;
    @BindView(R.id.tv_search_recorder)
    TextView mTvSearchRecorder;
    @BindView(R.id.iv_clear_history)
    ImageView mIvClearHistory;
    @BindView(R.id.frame_layer)
    FrameLayout mFrameLayer;
    @BindView(R.id.rl_history)
    RelativeLayout mRlHistory;
    @BindView(R.id.change_recycler)
    XRecyclerView mChangeRecycler;
    @BindView(R.id.empty_view)
    FrameLayout mEmpty;
    @BindView(R.id.ll_empty)
    LinearLayout mLlEmpty;
    @BindView(R.id.iv_empty)
    ImageView mIvEmpty;
    @BindView(R.id.tv_empty)
    TextView mTvEmpty;
    private SearchResultAdapter mAdapter;
    private KeyWordsAdapter mKeyAdapter;
    private InputMethodManager mSoftManager;
    private String content;
    private String keyContent;
    private PSearch mPressent;
    private Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_search);
        ButterKnife.bind(this);
        mHandler = new Handler(getMainLooper());
        mPressent = new PSearch(this, mHandler);
        setSearchListener();
        initRecycler();
        showHistory();
    }

    /**
     * 搜索监听
     */
    private void setSearchListener() {
        mSoftManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        mEdSearch.setFocusable(true);
        mEdSearch.setFocusableInTouchMode(true);
        mEdSearch.requestFocus();

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                mSoftManager.showSoftInput(mEdSearch, InputMethodManager.SHOW_FORCED);
            }
        }, 300);
        mEdSearch.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                Log.i(TAG, "beforeTextChanged 打印：" + s);
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                Log.i(TAG, "onTextChanged 打印: " + s);
                clearAdapterData();
                keyContent = s.toString().trim();
                if (before != 0 && count == 0 && s.length() == 0) {
                    showHistory();
                }
                if (!TextUtils.isEmpty(keyContent)) {
                    mIvClear.setVisibility(View.VISIBLE);
                    mEmpty.setVisibility(View.GONE);
                    showRecycler();
                    clearAdapterData();
                    mPressent.getKeyWdSearch(SearchActivity.this);
                }
            }

            @Override
            public void afterTextChanged(Editable s) {
                Log.i(TAG, "afterTextChanged 打印：" + s.toString());
            }
        });
        mEdSearch.setOnEditorActionListener(new TextView.OnEditorActionListener() {
            @Override
            public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
                if (actionId == EditorInfo.IME_ACTION_SEARCH) {
                    content = mEdSearch.getText().toString().trim();
                    if (TextUtils.isEmpty(content)) {
                        Toast.makeText(SearchActivity.this, R.string.empty_content, Toast.LENGTH_SHORT).show();
                    } else {
                        searchPoems(content);
                    }
                    return true;
                }
                return false;
            }
        });
    }

    /**
     * 执行搜索
     */
    private void searchPoems(String text) {
        mSoftManager.hideSoftInputFromWindow(mEdSearch.getWindowToken(), 0);
        clearAdapterData();
        showRecycler();
        if (!TextUtils.isEmpty(text)) {
            mPressent.saveHistoryData(text);
        }
        mPressent.getSearchResult();
    }


    /**
     * 清除数据
     */
    private void clearAdapterData() {
        if (null != mAdapter) {
            mAdapter.clearData();
        }
        if (null != mKeyAdapter) {
            mKeyAdapter.clearData();
        }
    }

    /**
     * 显示Adapter
     */
    private void showRecycler() {
        mRlHistory.setVisibility(View.GONE);
        mEmpty.setVisibility(View.GONE);
        mChangeRecycler.setVisibility(View.VISIBLE);
    }

    /**
     * 显示历史记录
     */
    private void showHistory() {
        mEmpty.setVisibility(View.GONE);
        mIvClear.setVisibility(View.GONE);
        mChangeRecycler.setVisibility(View.GONE);
        mIvClearHistory.setVisibility(View.VISIBLE);
        mRlHistory.setVisibility(View.VISIBLE);
        mFrameLayer.setVisibility(View.VISIBLE);
        mEdSearch.setText("");
        mEdSearch.setHint(R.string.search_hint);

        mPressent.getHistoryData();
    }

    /**
     * 初始化Recyclerview
     */
    private void initRecycler() {
        mChangeRecycler.verticalLayoutManager(this);
        if (mAdapter == null) {
            mAdapter = new SearchResultAdapter(this);
            mAdapter.setRecItemClick(new RecyclerItemCallback<ResultModel, SearchResultAdapter.ViewHolder>() {
                @Override
                public void onItemClick(int position, ResultModel model, int tag, SearchResultAdapter.ViewHolder holder) {
                    if (Constant.ITEM_CLICK == tag) {
                        Toast.makeText(SearchActivity.this, model.getTitle() + model.getSort(), Toast.LENGTH_LONG).show();
                    }
                }
            });
        }

        if (mKeyAdapter == null) {
            mKeyAdapter = new KeyWordsAdapter(this);
            mKeyAdapter.setRecItemClick(new RecyclerItemCallback<KeyWordsModel, KeyWordsAdapter.ViewHolder>() {
                @Override
                public void onItemClick(int position, KeyWordsModel model, int tag, KeyWordsAdapter.ViewHolder holder) {
                    if (Constant.ITEM_CLICK == tag) {
                        Toast.makeText(SearchActivity.this, model.getKeyWord() + " 执行搜索", Toast.LENGTH_LONG).show();
                        searchPoems("");
                    }
                }
            });
        }
    }

    @OnClick({R.id.iv_clear, R.id.app_search_cancel, R.id.iv_clear_history, R.id.empty_view})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            //清除输入框的内容
            case R.id.iv_clear:
                showHistory();
                break;
            case R.id.app_search_cancel:
                finish();
                if (null != mSoftManager) {
                    mSoftManager.hideSoftInputFromWindow(mEdSearch.getWindowToken(), 0);
                }
                break;
            //清楚历史记录
            case R.id.iv_clear_history:
                LoadingUtil.show(this);
                mPressent.deleteHistoryData();
                break;
            //无网络刷新
            case R.id.empty_view:
                Toast.makeText(SearchActivity.this, "模拟刷新。。。", Toast.LENGTH_LONG).show();
                break;
            default:
                break;
        }
    }

    /**
     * 显示加载框
     */
    @Override
    public void showLoading() {
        LoadingUtil.show(this);
    }

    /**
     * 隐藏加载框
     */
    @Override
    public void hideLoading() {
        LoadingUtil.close();
    }

    /**
     * 关键字结果展示
     *
     * @param mList 数据源
     */
    @Override
    public void showData(List<KeyWordsModel> mList) {
        mKeyAdapter.setData(mList);
        mChangeRecycler.setAdapter(mKeyAdapter);
    }

    /**
     * 显示历史记录
     *
     * @param historyData
     */
    @Override
    public void showHistoryData(ArrayList<String> historyData) {
        final FlowLayout flowLayout = new FlowLayout(this);
        int vPadding = 60;
        int hPadding = 32;
        //1.设置padding值
        int padding = 50;
        flowLayout.setPadding(padding, padding, padding, padding);
        //2.设置水平和垂直间距
        flowLayout.setHorizontalSpacing(padding);
        flowLayout.setVerticalSpacing(padding);
        mFrameLayer.removeAllViews();
        mFrameLayer.addView(flowLayout);
        for (final String historyString : historyData) {

            final TextView textView = new TextView(this);
            textView.setText(historyString);
            textView.setTextColor(CommonUtil.getColor(R.color.app_text_58_color));
            textView.setBackgroundResource(R.drawable.shape_rec_round_gray_search);
            textView.setGravity(Gravity.CENTER);
            textView.setTextSize(13);
            textView.setPadding(vPadding, hPadding, vPadding, hPadding);
            flowLayout.addView(textView);
            textView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    //次处是做点击搜索的，不做假数据了累啊
                }
            });
        }
    }

    /**
     * 隐藏历史记录布局
     */
    @Override
    public void hideHistoryView() {
        mChangeRecycler.setVisibility(View.GONE);
        mIvClearHistory.setVisibility(View.GONE);
        mFrameLayer.setVisibility(View.GONE);
    }

    /**
     * 展示空历史记录布局
     */
    @Override
    public void showEmpty() {
        mRlHistory.setVisibility(View.GONE);
        mEmpty.setVisibility(View.VISIBLE);
    }

    /**
     * 搜索结果展示
     *
     * @param mList
     */
    @Override
    public void showResultData(List<ResultModel> mList) {
        mAdapter.setData(mList);
        mChangeRecycler.setAdapter(mAdapter);
    }
}

                     >>> P层

/**
 * @author Okamiy
 * @date 2018\8\31 0031 10:13
 * P层
 */
public class PSearch {
    private final ArrayList<ResultModel> mList;
    // View接口
    private ISearch mView;
    private Gson gson;
    private Handler mHandler;

    public PSearch(ISearch view, Handler handler) {
        this.mHandler = handler;
        this.mView = view;
        mList = new ArrayList<>();
        ResultModel model01 = new ResultModel("Okamiy", "火影忍者", "20~30", R.drawable.img_001);
        ResultModel model02 = new ResultModel("包容天下", "海贼王", "10~30", R.drawable.img_002);
        ResultModel model03 = new ResultModel("Okamiy", "妖精的尾巴", "22~32", R.drawable.img_003);
        ResultModel model04 = new ResultModel("今天的阳光", "西游记", "20~30", R.drawable.img_004);
        ResultModel model05 = new ResultModel("包容天下", "水浒传", "2~10", R.drawable.img_005);
        ResultModel model06 = new ResultModel("今天的阳光", "人名的名义", "26~30", R.drawable.img_006);
        ResultModel model07 = new ResultModel("今生缘来生续", "红楼梦", "21~30", R.drawable.img_009);
        ResultModel model08 = new ResultModel("Okamiy", "西游记", "20~31", R.drawable.img_007);
        ResultModel model09 = new ResultModel("包容天下", "火影忍者", "60~70", R.drawable.img_008);
        ResultModel model10 = new ResultModel("Okamiy", "海贼王", "20~30", R.drawable.img_010);
        ResultModel model12 = new ResultModel("今天的阳光", "海贼王", "20~30", R.drawable.img_011);
        ResultModel model13 = new ResultModel("世界之窗", "西游记", "10~310", R.drawable.img_011);
        ResultModel model14 = new ResultModel("三生三世", "西游记", "210~30", R.drawable.img_012);
        ResultModel model15 = new ResultModel("三生三世", "火影忍者", "206~360", R.drawable.img_013);
        ResultModel model16 = new ResultModel("Okamiy", "海贼王", "26~30", R.drawable.img_014);
        ResultModel model17 = new ResultModel("今生缘来生续", "红楼梦", "20~30", R.drawable.img_015);
        ResultModel model18 = new ResultModel("Okamiy", "火影忍者", "22~30", R.drawable.img_016);
        ResultModel model19 = new ResultModel("Okamiy", "红楼梦", "20~30", R.drawable.img_017);
        ResultModel model20 = new ResultModel("今天的阳光", "西游记", "20~30", R.drawable.img_018);
        ResultModel model21 = new ResultModel("Okamiy", "火影忍者", "40~30", R.drawable.img_019);
        ResultModel model22 = new ResultModel("包容天下", "红楼梦", "20~30", R.drawable.img_020);
        ResultModel model23 = new ResultModel("Okamiy", "火影忍者", "45~690", R.drawable.img_021);
        ResultModel model24 = new ResultModel("三生三世", "海贼王", "20~30", R.drawable.img_022);
        ResultModel model25 = new ResultModel("今天的阳光", "西游记", "2~30", R.drawable.img_023);
        ResultModel model26 = new ResultModel("Okamiy", "火影忍者", "20~30", R.drawable.img_024);
        ResultModel model27 = new ResultModel("Okamiy", "海贼王", "27~30", R.drawable.img_025);
        ResultModel model28 = new ResultModel("世界之窗", "海贼王", "20~30", R.drawable.img_026);
        ResultModel model29 = new ResultModel("世界之窗", "火影忍者", "2~34", R.drawable.img_027);
        ResultModel model30 = new ResultModel("世界之窗", "平凡的世界", "20~30", R.drawable.img_028);
        ResultModel model31 = new ResultModel("三生三世", "火影忍者", "20~30", R.drawable.img_029);
        ResultModel model32 = new ResultModel("Okamiy", "西游记", "2~30", R.drawable.img_016);
        ResultModel model33 = new ResultModel("世界之窗", "西游记", "14~30", R.drawable.img_020);
        ResultModel model34 = new ResultModel("三生三世", "平凡的世界", "20~30", R.drawable.img_029);
        ResultModel model35 = new ResultModel("Okamiy", "火影忍者", "20~30", R.drawable.img_014);
        ResultModel model36 = new ResultModel("今生缘来生续", "平凡的世界", "24~30", R.drawable.img_006);
        ResultModel model37 = new ResultModel("三生三世", "四季如春", "20~34", R.drawable.img_021);
        ResultModel model38 = new ResultModel("今生缘来生续", "平凡的世界", "20~40", R.drawable.img_008);
        ResultModel model39 = new ResultModel("Okamiy", "海棠花", "2~12", R.drawable.img_014);
        ResultModel model40 = new ResultModel("今生缘来生续", "超能勇士", "4~30", R.drawable.img_001);
        ResultModel model41 = new ResultModel("今生缘来生续", "火影忍者", "90~96", R.drawable.img_021);
        mList.add(model01);
        mList.add(model02);
        mList.add(model03);
        mList.add(model04);
        mList.add(model05);
        mList.add(model06);
        mList.add(model07);
        mList.add(model08);
        mList.add(model09);
        mList.add(model10);
        mList.add(model12);
        mList.add(model13);
        mList.add(model14);
        mList.add(model15);
        mList.add(model16);
        mList.add(model17);
        mList.add(model18);
        mList.add(model19);
        mList.add(model20);
        mList.add(model21);
        mList.add(model22);
        mList.add(model23);
        mList.add(model24);
        mList.add(model25);
        mList.add(model26);
        mList.add(model27);
        mList.add(model28);
        mList.add(model29);
        mList.add(model30);
        mList.add(model31);
        mList.add(model32);
        mList.add(model33);
        mList.add(model34);
        mList.add(model35);
        mList.add(model36);
        mList.add(model37);
        mList.add(model38);
        mList.add(model39);
        mList.add(model40);
        mList.add(model41);
        mList.add(model25);
        mList.add(model37);
        mList.add(model01);
        mList.add(model06);
        mList.add(model16);
        mList.add(model19);
        mList.add(model22);
        mList.add(model25);
        mList.add(model27);
    }

    /**
     * 关键字搜索
     * 此处数据造假：你们可以从服务器拉取数据
     */
    public void getKeyWdSearch(final Context context) {
        mView.showLoading();
        //模拟延迟
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                String[] strs = context.getResources().getStringArray(R.array.str_list);
                //随机索引
                int id = (int) (Math.random() * (strs.length - 1));
                KeyWordsModel model = new KeyWordsModel(strs[id]);
                List<KeyWordsModel> mList = new ArrayList<>();
                mList.add(model);
                mView.hideLoading();
                mView.showData(mList);
            }
        }, 1600);

    }

    /**
     * 结果搜索
     */
    public void getSearchResult() {
        mView.showLoading();
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                Random random = new Random();
                int num = random.nextInt(44);
                int num1 = random.nextInt(44);
                int num2 = random.nextInt(44);
                List<ResultModel> models = new ArrayList<>();
                models.add(mList.get(num));
                models.add(mList.get(num1));
                models.add(mList.get(num2));
                mView.hideLoading();
                mView.showResultData(models);
            }
        }, 1300);
    }

    /**
     * 获取搜索记录
     */
    public void getHistoryData() {
        mView.showLoading();
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                String searchDtaJson = SpUtils.getPoemSearchData();
                if (gson == null) {
                    gson = new Gson();
                }
                if (!TextUtils.isEmpty(searchDtaJson)) {
                    try {
                        SearchModel shopSearchData = gson.fromJson(searchDtaJson, SearchModel.class);
                        if (shopSearchData != null) {
                            ArrayList<String> searchArrayList = shopSearchData.getSearchList();
                            if (searchArrayList != null) {
                                mView.hideLoading();
                                mView.showHistoryData(searchArrayList);
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        mView.hideLoading();
                    }
                } else {
                    mView.hideLoading();
                    mView.showEmpty();
                }
            }
        }, 700);
    }

    /**
     * 删除搜索记录
     */
    public void deleteHistoryData() {
        mView.showLoading();
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                String searchDtaJson = SpUtils.getPoemSearchData();
                if (gson == null) {
                    gson = new Gson();
                }
                if (!TextUtils.isEmpty(searchDtaJson)) {
                    try {
                        SearchModel shopSearchData = gson.fromJson(searchDtaJson, SearchModel.class);
                        if (shopSearchData != null) {
                            ArrayList<String> searchArrayList = shopSearchData.getSearchList();
                            if (searchArrayList != null) {
                                searchArrayList.clear();
                                SpUtils.putPoemSearchData("");
                                mView.hideLoading();
                                mView.showEmpty();
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        mView.hideLoading();
                        mView.showEmpty();
                    }
                } else {
                    mView.hideLoading();
                    mView.showEmpty();
                }
            }
        }, 1500);
    }

    /**
     * 保存搜索记录
     *
     * @param query
     */
    public void saveHistoryData(final String query) {
        mView.showLoading();
        mHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                String searchDtaJson = SpUtils.getPoemSearchData();
                SearchModel shopSearchData = null;
                if (gson == null) {
                    gson = new Gson();
                }
                if (!TextUtils.isEmpty(searchDtaJson)) {
                    try {
                        shopSearchData = gson.fromJson(searchDtaJson, SearchModel.class);
                        if (shopSearchData != null) {

                            ArrayList<String> searchArrayList = shopSearchData.getSearchList();
                            if (searchArrayList != null) {
                                int num = searchArrayList.size();
                                if (num > 1) {
                                    if (num < 10) {
                                        if (!deleteSame(searchArrayList, query)) {
                                            searchArrayList.add(0, query);
                                        }
                                    } else {
                                        if (!deleteSame(searchArrayList, query)) {
                                            searchArrayList.remove(num - 1);
                                            searchArrayList.add(0, query);
                                        }
                                    }
                                } else {
                                    searchArrayList.add(query);
                                }
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        mView.hideLoading();
                    }
                } else {
                    ArrayList<String> searchArrayList = new ArrayList<>(10);
                    searchArrayList.add(query);
                    shopSearchData = new SearchModel();
                    shopSearchData.setSearchList(searchArrayList);
                    mView.hideLoading();
                }

                if (shopSearchData != null) {
                    if (gson == null) {
                        gson = new Gson();
                    }
                    try {
                        String shopSearchDataJson = gson.toJson(shopSearchData);
                        SpUtils.putPoemSearchData(shopSearchDataJson);
                    } catch (Exception e) {
                        e.printStackTrace();
                        mView.hideLoading();
                    }
                }
            }
        }, 1600);
    }

    /**
     * 是否有相同的数据
     */
    private boolean deleteSame(ArrayList<String> searchArrayList, String newName) {
        boolean isSame = false;
        for (String name : searchArrayList) {
            if (newName.equals(name)) {
                isSame = true;
                break;
            }
        }
        return isSame;
    }
}

                     >>> View接口

/**
 * @author Okamiy
 * @date 2018\8\31 0031 10:11
 * View层
 */
public interface ISearch {
    /**
     * 显示正在加载进度框
     */
    void showLoading();

    /**
     * 隐藏正在加载进度框
     */
    void hideLoading();

    /**
     * 关键字搜索
     *
     * @param mList 数据源
     */
    void showData(List<KeyWordsModel> mList);

    /**
     * 显示历史记录
     *
     * @param searchArrayList
     */
    void showHistoryData(ArrayList<String> searchArrayList);

    /**
     * 隐藏历史记录相关
     */
    void hideHistoryView();

    /**
     * 显示历史记录空布局
     */
    void showEmpty();

    /**
     * 搜索结果
     *
     * @param mList
     */
    void showResultData(List<ResultModel> mList);
}

           003.源码：

                  CSDN下载页：https://download.csdn.net/download/demo006/10642945

                  Github下载页：https://github.com/OkamiyGit/OkamiySearch

           004.欢迎大家指正，探讨......造假数据好累好累，好累！