Android 如何实现搜索（编辑文本）功能？

我有一个从sqlite获取所有单词的listview和一个edittext（我想从数据库中筛选/搜索单词）

我想实现一个TextWatcher，它要好得多，但我不知道如何使用我的代码来实现它。我是个新手

public class DictionaryListActivity extends Activity {

TextView userTextView;
EditText searchEditText;

ListView dictionaryListView;

String logTagString="DICTIONARY";
ArrayList<WordDefinition> allWordDefinitions=new ArrayList<WordDefinition>();


DictionaryDatabaseHelper myDictionaryDatabaseHelper;
SharedPreferences sharedPreferences;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_dictionary_list);

    Log.d("DICTIONARY", "second activity started");


    userTextView=(TextView) findViewById(R.id.personTextView);
    userTextView.setText(getIntent().getStringExtra(MainActivity.USER_NAME_STRING)+"'s Dictionary");

    searchEditText=(EditText) findViewById(R.id.searchEditText);

    dictionaryListView=(ListView) findViewById(R.id.dictionaryListView);

    myDictionaryDatabaseHelper=new DictionaryDatabaseHelper(this, "Dictionary", null, 1);
    sharedPreferences=getSharedPreferences(MainActivity.SHARED_NAME_STRING, MODE_PRIVATE);


    boolean initialized=sharedPreferences.getBoolean("initialized", false);

    if (initialized==false) {
        //Log.d(logTagString, "initializing for the first time");
        initializeDatabase();
        SharedPreferences.Editor editor=sharedPreferences.edit();
        editor.putBoolean("initialized", true);
        editor.commit();

    }else {
        Log.d(logTagString, "db already initialized");
    }

    allWordDefinitions=myDictionaryDatabaseHelper.getAllWords();

    dictionaryListView.setAdapter(new BaseAdapter() {

        @Override
        public View getView(int position, View view, ViewGroup arg2) {
            if (view==null) {
                view=getLayoutInflater().inflate(R.layout.list_item, null);
            }
            TextView textView=(TextView) view.findViewById(R.id.listItemTextView);
            textView.setText(allWordDefinitions.get(position).word);

            return view;
        }

        @Override
        public long getItemId(int arg0) {
            // TODO Auto-generated method stub
            return 0;
        }

        @Override
        public Object getItem(int arg0) {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public int getCount() {
            // TODO Auto-generated method stub
            return allWordDefinitions.size();
        }
    });

    dictionaryListView.setOnItemClickListener(new OnItemClickListener() {

        @Override
        public void onItemClick(AdapterView<?> arg0, View view, int position,
                long arg3) {
            Intent intent =new Intent(DictionaryListActivity.this, WordDefinitionDetailActivity.class);
            intent.putExtra("word", allWordDefinitions.get(position).word);
            intent.putExtra("definition", allWordDefinitions.get(position).definition);

            startActivity(intent);
        }
    });



private void initializeDatabase() {
    InputStream inputStream=getResources().openRawResource(R.raw.dictionary);
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
    DictionaryLoader.loadData(bufferedReader, myDictionaryDatabaseHelper);

}

 }

公共类字典Stactivity扩展活动{
TextView用户TextView；
编辑文本搜索编辑文本；
ListView字典列表视图；
字符串logTagString=“字典”；
ArrayList allWordDefinitions=新建ArrayList（）；
DictionaryDatabaseHelper myDictionaryDatabaseHelper；
SharedReferences SharedReferences；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u dictionary\u list）；
Log.d（“字典”，“第二个活动已开始”）；
userTextView=（TextView）findViewById（R.id.personTextView）；
userTextView.setText（getIntent（）.getStringExtra（MainActivity.USER_NAME_STRING）+“的字典”）；
searchEditText=（EditText）findViewById（R.id.searchEditText）；
dictionaryListView=（ListView）findViewById（R.id.dictionaryListView）；
myDictionaryDatabaseHelper=新DictionaryDatabaseHelper（此“字典”，null，1）；
SharedReferences=GetSharedReferences（MainActivity.SHARED\u NAME\u STRING，MODE\u PRIVATE）；
boolean initialized=SharedReferences.getBoolean（“initialized”，false）；
如果（初始化==false）{
//Log.d（logTagString，“第一次初始化”）；
初始化为tabase（）；
SharedReferences.Editor=SharedReferences.edit（）；
编辑器.putBoolean（“已初始化”，true）；
commit（）；
}否则{
Log.d（logTagString，“db已初始化”）；
}
allWordDefinitions=myDictionaryDatabaseHelper.getAllWords（）；
setAdapter（新的BaseAdapter（）{
@凌驾
公共视图getView（内部位置、视图视图、视图组arg2）{
如果（视图==null）{
view=GetLayoutFlater（）.充气（R.layout.list_项，空）；
}
TextView TextView=（TextView）view.findViewById（R.id.listItemTextView）；
setText（allWordDefinitions.get（position.word））；
返回视图；
}
@凌驾
公共长getItemId（int arg0）{
//TODO自动生成的方法存根
返回0；
}
@凌驾
公共对象getItem（int arg0）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
public int getCount（）{
//TODO自动生成的方法存根
返回allWordDefinitions.size（）；
}
});
setOnItemClickListener（新的OnItemClickListener（）{
@凌驾
public void onItemClick（适配器视图arg0、视图视图、内部位置、，
长arg3）{
意向意向=新意向（DictionaryStactivity.this，WordDefinitionDetailActivity.class）；
intent.putExtra（“word”，allWordDefinitions.get（position.word）；
intent.putExtra（“定义”，allWordDefinitions.get（position.definition）；
星触觉（意向）；
}
});
private void initializeDatabase（）{
InputStream InputStream=getResources（）.openRawResource（R.raw.dictionary）；
BufferedReader BufferedReader=新的BufferedReader（新的InputStreamReader（inputStream））；
loadData（bufferedReader、myDictionaryDatabaseHelper）；
}
}

字典DatabaseHelper

public class DictionaryDatabaseHelper extends SQLiteOpenHelper {

final static String DICTIONARY_DATABASE="dictionary";
final static String ITEM_ID_COLUMN="id";
final static String WORD_COLUMN="word";
final static String DEFINITION_COLUMN="definition";


final static String CREATE_DATABASE_QUERY="CREATE TABLE "+DICTIONARY_DATABASE+" ( "+
ITEM_ID_COLUMN+" INTEGER PRIMARY KEY AUTOINCREMENT, "+
WORD_COLUMN+" TEXT , "+
DEFINITION_COLUMN+" TEXT)";


final static String ON_UPGRADE_QUERY="DROP TABLE "+DICTIONARY_DATABASE;

Context context;


public DictionaryDatabaseHelper(Context context, String name,
        CursorFactory factory, int version) {
    super(context, DICTIONARY_DATABASE, factory, version);
    this.context=context;

}

@Override
public void onCreate(SQLiteDatabase database) {
        database.execSQL(CREATE_DATABASE_QUERY);    
}

@Override
public void onUpgrade(SQLiteDatabase database, int oldVersion, int newVersion) {
    database.execSQL(ON_UPGRADE_QUERY);
    onCreate(database);

}

public long insertData(WordDefinition wordDefinition) {
    SQLiteDatabase database=this.getWritableDatabase();
    ContentValues values=new ContentValues();

    values.put(WORD_COLUMN, wordDefinition.word);
    values.put(DEFINITION_COLUMN, wordDefinition.definition);

    return database.insert(DICTIONARY_DATABASE, null, values);      

}

public long updateData(WordDefinition wordDefinition) {
    SQLiteDatabase database=this.getWritableDatabase();
    ContentValues values=new ContentValues();

    values.put(WORD_COLUMN, wordDefinition.word);
    values.put(DEFINITION_COLUMN, wordDefinition.definition);

    return database.update(DICTIONARY_DATABASE, values, WORD_COLUMN+" =?", new String[]{wordDefinition.word});  

}

public void deleteData(WordDefinition wordDefinition) {
    SQLiteDatabase database=this.getWritableDatabase();
    String queryString="DELETE FROM "+DICTIONARY_DATABASE+" WHERE "+WORD_COLUMN+" = '"+wordDefinition.word+"'";

    database.execSQL(queryString);
}

public ArrayList<WordDefinition> getAllWords() {
    ArrayList<WordDefinition> arrayList=new ArrayList<WordDefinition>();
    SQLiteDatabase database=this.getReadableDatabase();

    String selectAllQueryString="SELECT * FROM "+DICTIONARY_DATABASE;
    Cursor cursor=database.rawQuery(selectAllQueryString, null);

    if (cursor.moveToFirst()) {
        do {            
            WordDefinition wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(WORD_COLUMN)), cursor.getString(cursor.getColumnIndex(DEFINITION_COLUMN)));
            arrayList.add(wordDefinition);              
        } while (cursor.moveToNext());          
    }   
    return arrayList;
}

public WordDefinition getWordDefinition(String word) {
    SQLiteDatabase database=this.getReadableDatabase();
    WordDefinition wordDefinition=null;

    String selectQueryString="SELECT * FROM "+DICTIONARY_DATABASE+ " WHERE "+WORD_COLUMN+" = '"+word+ "'";
    Cursor cursor=database.rawQuery(selectQueryString, null);

    if (cursor.moveToFirst()) {
        wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(WORD_COLUMN)), cursor.getString(cursor.getColumnIndex(DEFINITION_COLUMN)));

    }   

    return wordDefinition;

}

public WordDefinition getWordDefinition(long id) {
    SQLiteDatabase database=this.getReadableDatabase();
    WordDefinition wordDefinition=null;

    String selectQueryString="SELECT * FROM "+DICTIONARY_DATABASE+ " WHERE "+ITEM_ID_COLUMN+" = '"+id+ "'";
    Cursor cursor=database.rawQuery(selectQueryString, null);

    if (cursor.moveToFirst()) {
        wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(WORD_COLUMN)), cursor.getString(cursor.getColumnIndex(DEFINITION_COLUMN)));

    }   

    return wordDefinition;

}

public void initializeDatabaseFortheFirstTime(ArrayList<WordDefinition> wordDefinitions) {
    SQLiteDatabase database=this.getWritableDatabase();
    database.execSQL("BEGIN");

    ContentValues contentValues=new ContentValues();

    for (WordDefinition wordDefinition : wordDefinitions) {
        contentValues.put(WORD_COLUMN, wordDefinition.word);
        contentValues.put(DEFINITION_COLUMN, wordDefinition.definition);            
        database.insert(DICTIONARY_DATABASE, null, contentValues);
    }
    database.execSQL("COMMIT");

}


}

公共类DictionaryDatabaseHelper扩展了SQLiteOpenHelper{
最终静态字符串字典\u DATABASE=“DICTIONARY”；
最终静态字符串项\u ID\u COLUMN=“ID”；
最后一个静态字符串WORD\u COLUMN=“WORD”；
最终静态字符串定义\u COLUMN=“DEFINITION”；
最后一个静态字符串CREATE\u DATABASE\u QUERY=“CREATE TABLE”+DICTIONARY\u DATABASE+”（“+
ITEM_ID_COLUMN+“整型主键自动递增，”+
WORD_列+文本，“+
定义_列+文本）；
_UPGRADE_QUERY=“DROP TABLE”+字典数据库上的最终静态字符串；
语境；
公共字典DatabaseHelper（上下文、字符串名称、，
游标工厂，int版本）{
超级（上下文、字典、数据库、工厂、版本）；
this.context=context；
}
@凌驾
public void onCreate（SQLiteDatabase）{
execSQL（创建数据库查询）；
}
@凌驾
public void onUpgrade（SQLiteDatabase数据库，int-oldVersion，int-newVersion）{
execSQL（在升级查询时）；
onCreate（数据库）；
}
公共长插入数据（WordDefinition WordDefinition）{
SQLiteDatabase=this.getWritableDatabase（）；
ContentValues=新的ContentValues（）；
value.put（WORD\u列，wordDefinition.WORD）；
value.put（DEFINITION\u列，wordDefinition.DEFINITION）；
返回database.insert（DICTIONARY\u database，null，value）；
}
公共长更新数据（WordDefinition WordDefinition）{
SQLiteDatabase=this.getWritableDatabase（）；
ContentValues=新的ContentValues（）；
value.put（WORD\u列，wordDefinition.WORD）；
value.put（DEFINITION\u列，wordDefinition.DEFINITION）；
返回database.update（DICTIONARY_数据库，值，WORD_列+“=？”，新字符串[]{wordDefinition.WORD}）；
}
公共void deleteData（WordDefinition WordDefinition）{
SQLiteDatabase=this.getWritableDatabase（）；
String queryString=“从“+DICTIONARY\u DATABASE+”中删除，其中“+WORD\u COLUMN+”='“+wordDefinition.WORD+””；
execSQL（queryString）；
}
公共数组列表getAllWords（）{
ArrayList ArrayList=新的ArrayList（）；
SQLiteDatabase=this.getReadableDatabase（）；
String selectAllQueryString=“SELECT*FROM”+字典\数据库；
Cursor Cursor=database.rawQuery（selectAllQueryString，null）；
if（cursor.moveToFirst（））{
做{
WordDefinition WordDefinition=newworddefinition（cursor.getString（cursor.getColumnIndex（WORD\u COLUMN）），cursor.getString（cursor.getColumnIndex（DEFINITION\u COLUMN
List<WordDefinition> searchProducts;  

searchEditText.addTextChangedListener(new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int start, int before,int count) {
        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count,int after) {
       }

       @Override
        public void afterTextChanged(Editable s) {
         String text = s.toString();
         getSearchResult(text);
        }
});

public void getSearchResult(String s) {
                    myDictionaryDatabaseHelper=new DictionaryDatabaseHelper(this, "Dictionary", null, 1);
                    allWordDefinitions=myDictionaryDatabaseHelper.getAllWords();
                    searchProducts = new ArrayList<WordDefinition>();

                    for (int i = 0; i < allWordDefinitions.size(); i++) {
                        if (s.equals("")) {
                        } else {
                        if (allWordDefinitions.get(i).YOUR_MODEL_METHODNAME
                                    .toLowerCase(Locale.getDefault()).contains(s)) {
                            searchProducts.add(allWordDefinitions.get(i));
                        }
                    }
                listUpdate(searchProducts);
            }

        }

        private void listUpdate(List<WordDefinition> searchProducts) {
          // Here you call your adapter.
        }