Java 从未对数据库显式调用Android Close（）

我不断收到错误消息，数据库中从未显式调用过

Close（）。据我所知，一旦活动被破坏，我不会关闭数据库，但我不知道如何实现它：

数据库帮助程序：

public class ResultsDatabase extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "results.db";
private static final int DATABASE_VERSION = 2;

public static final String TABLE_NAME = "results";
public static final String _ID = BaseColumns._ID;
public static final String SAVED_NAME = "name";
public static final String COLUMN_NAME_CREATE_DATE = "date";
public static final String RIGHT_EAR = "right_ear";
public static final String LEFT_EAR = "left_ear";

public ResultsDatabase(Context context) {
    // calls the super constructor, requesting the default cursor factory.
    super(context, DATABASE_NAME, null, DATABASE_VERSION);
}

@Override
public void onCreate(SQLiteDatabase db) {
    db.execSQL("CREATE TABLE " + TABLE_NAME + " ("
            + _ID + " INTEGER PRIMARY KEY,"
            + SAVED_NAME + " TEXT,"
            + COLUMN_NAME_CREATE_DATE + " INTEGER,"
            + RIGHT_EAR + " BLOB,"
            + LEFT_EAR + " BLOB"
            + ");");
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){
}

public void storeResults(String name, List<EarSrt> leftAnswerList, List<EarSrt> rightAnswerList){
    SQLiteDatabase db = getWritableDatabase();
    ContentValues values = new ContentValues();
    values.put(SAVED_NAME, name);
    Long now = Long.valueOf(System.currentTimeMillis());
    values.put(COLUMN_NAME_CREATE_DATE, now);
    values.put(RIGHT_EAR, serializeObject(rightAnswerList ));
    values.put(LEFT_EAR, serializeObject(leftAnswerList ));
    db.insert(TABLE_NAME, null, values);
}

public static byte[] serializeObject(Object o) { 
    ByteArrayOutputStream bos = new ByteArrayOutputStream(); 

    try { 
        ObjectOutput out = new ObjectOutputStream(bos); 
        out.writeObject(o); 
        out.close(); 

        // Get the bytes of the serialized object 
        byte[] buf = bos.toByteArray(); 

        return buf; 
    } catch(IOException ioe) { 
        Log.e("serializeObject", "error", ioe); 

        return null; 
    } 
}

public static Object deserializeObject(byte[] b) { 
    try { 
        ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(b)); 
        Object object = in.readObject(); 
        in.close(); 

        return object; 
    } catch(ClassNotFoundException cnfe) { 
        Log.e("deserializeObject", "class not found error", cnfe); 

        return null; 
    } catch(IOException ioe) { 
        Log.e("deserializeObject", "io error", ioe); 

        return null; 
    } 
} 
}

公共类ResultsDatabase扩展SQLiteOpenHelper{
私有静态最终字符串数据库\u NAME=“results.db”；
私有静态最终int数据库_VERSION=2；
公共静态最终字符串表\u NAME=“results”；
公共静态最终字符串_ID=BaseColumns.\u ID；
保存的公共静态最终字符串\u NAME=“NAME”；
公共静态最终字符串列\u NAME\u CREATE\u DATE=“DATE”；
公共静态最终字符串RIGHT\u EAR=“RIGHT\u EAR”；
公共静态最终字符串LEFT\u EAR=“LEFT\u EAR”；
公共结果数据库（上下文）{
//调用超级构造函数，请求默认的游标工厂。
super（上下文、数据库名称、null、数据库版本）；
}
@凌驾
public void onCreate（SQLiteDatabase db）{
db.execSQL（“创建表”+表名+”（“
+_ID+“整数主键，”
+已保存_NAME+“文本，”
+列名称创建日期+整数
+右耳+水滴
+左耳+水滴
+ ");");
}
@凌驾
public void onUpgrade（SQLiteDatabase db，int-oldVersion，int-newVersion）{
}
public void storeResults（字符串名称、列表leftAnswerList、列表rightAnswerList）{
SQLiteDatabase db=getWritableDatabase（）；
ContentValues=新的ContentValues（）；
value.put（保存的名称、名称）；
Long now=Long.valueOf（System.currentTimeMillis（））；
value.put（列名称、创建日期、现在）；
value.put（右耳，序列化对象（rightAnswerList））；
put（左耳，序列化对象（leftAnswerList））；
db.insert（表名称，空，值）；
}
公共静态字节[]序列化对象（对象o）{
ByteArrayOutputStream bos=新建ByteArrayOutputStream（）；
试试{
ObjectOutput out=新的ObjectOutputStream（bos）；
out.writeObject（o）；
out.close（）；
//获取序列化对象的字节数
字节[]buf=bos.toByteArray（）；
返回buf；
}捕获（ioe异常ioe）{
Log.e（“序列化对象”，“错误”，ioe）；
返回null；
} 
}
公共静态对象反序列化对象（字节[]b）{
试试{
ObjectInputStream in=新的ObjectInputStream（新的ByteArrayInputStream（b））；
Object Object=in.readObject（）；
in.close（）；
返回对象；
}catch（ClassNotFoundException cnfe）{
Log.e（“反序列化对象”，“未找到类错误”，cnfe）；
返回null；
}捕获（ioe异常ioe）{
Log.e（“反序列化对象”，“io错误”，ioe）；
返回null；
} 
} 
}

我在选项卡式结果活动中调用此助手，该活动以两个不同的片段显示数据，如下所示：

public class TabbedResultsActivity extends SherlockFragmentActivity{
TabHost mTabHost;
TabManager mTabManager;
public static final String IS_RIGHT_EAR = "is_right_ear";
private ArrayList<EarSrt> leftAnswerList;
private ArrayList<EarSrt> rightAnswerList;

private final static String TAG = "HearingTest";

private boolean isRightEarTab = true;

private boolean bothEarsBad;
private boolean leftEarBad;
private boolean rightEarBad;

@SuppressWarnings("unchecked")
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.tab_layout);

    ActionBar ab = this.getSupportActionBar();
    SherlockHelper.setupActionBar(ab, this);

    View infoButton = findViewById(R.id.info_button);
    infoButton.setVisibility(View.VISIBLE);

    Intent intent = getIntent();
    int rowId = intent.getIntExtra(ResultsDatabase._ID, -1);
    if ( rowId != -1 ) {
        ResultsDatabase db = new ResultsDatabase(this);
        String select = "(" + ResultsDatabase._ID + " == " + rowId + ")";
        Cursor c = db.getReadableDatabase().query(ResultsDatabase.TABLE_NAME, null, select, null, null, null,null);
        if ( c.moveToFirst() ) {
            int leftEarColumn = c.getColumnIndex(ResultsDatabase.LEFT_EAR);
            byte[] leftEarByteArray = c.getBlob(leftEarColumn);
            int rightEarColumn = c.getColumnIndex(ResultsDatabase.RIGHT_EAR);
            byte[] rightEarByteArray = c.getBlob(rightEarColumn);
            leftAnswerList = (ArrayList<EarSrt>) ResultsDatabase.deserializeObject(leftEarByteArray);
            rightAnswerList = (ArrayList<EarSrt>) ResultsDatabase.deserializeObject(rightEarByteArray);
        }

    } else {
        byte[] leftEarByteArray = getIntent().getByteArrayExtra(ResultsDatabase.LEFT_EAR);
        byte[] rightEarByteArray = getIntent().getByteArrayExtra(ResultsDatabase.RIGHT_EAR);
        leftAnswerList = (ArrayList<EarSrt>) ResultsDatabase.deserializeObject(leftEarByteArray);
        rightAnswerList = (ArrayList<EarSrt>) ResultsDatabase.deserializeObject(rightEarByteArray);
    }

    isRightEarTab = getIntent().getBooleanExtra(IS_RIGHT_EAR, true);

    GraphView graphView = new GraphView(this);

                graphView.setPoints(rightAnswerList);
                float leftAverage = calculateAverage(rightAnswerList);
                graphView.setAverage(leftAverage);

                graphView.setPoints(leftAnswerList);
                float rightAverage = calculateAverage(leftAnswerList);
                graphView.setAverage(rightAverage);

    setResults(leftAnswerList, rightAnswerList);

    String results = setResultCaption(bothEarsBad, leftEarBad, rightEarBad).toString();

        Log.d(TAG, "The results were " + results);

        Bundle leftbundle = new Bundle();
        leftbundle.putString("results", results);
        leftbundle.putParcelableArrayList("graph", leftAnswerList);
        leftbundle.putFloat("average", leftAverage);

        Bundle rightbundle = new Bundle();
        rightbundle.putString("results", results);
        rightbundle.putParcelableArrayList("graph", rightAnswerList);
        rightbundle.putFloat("average", rightAverage);

    mTabHost = (TabHost)findViewById(android.R.id.tabhost);
    mTabHost.setup();

    mTabManager = new TabManager(this, mTabHost, R.id.realtabcontent);

    mTabManager.addTab(mTabHost.newTabSpec(getString(R.string.Left_ear)).setIndicator(getString(R.string.Left_ear)),
            LeftEarResults.class, leftbundle);
    mTabManager.addTab(mTabHost.newTabSpec("contacts").setIndicator(getString(R.string.Right_ear)),
            RightEarResults.class, rightbundle);

    if (savedInstanceState != null) {
        mTabHost.setCurrentTabByTag(savedInstanceState.getString("tab"));
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putString("tab", mTabHost.getCurrentTabTag());
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    return MenuActivity.createMenu(this, menu);
}

private float calculateAverage(List<EarSrt> steps) {
    float srt = 0.0f;
    int length = steps.size();

    for (int i = (int)Math.ceil( (float)length/(float)2); i < length; i++) {
        EarSrt es = steps.get(i);
        srt += es.getSrt();
    }       
    srt = srt / (length-(float)Math.ceil( (float)length/(float)2));

    return srt;
}

private void setResults(List<EarSrt> leftEar, List<EarSrt> rightEar) {
    float esLeft = calculateAverage(leftEar);
    float esRight = calculateAverage(rightEar);

    leftEarBad = (esLeft > 24.0);
    rightEarBad = (esRight > 24.0);
    bothEarsBad = (leftEarBad && rightEarBad);
}

private StringBuilder setResultCaption(boolean bothEarsBad, boolean leftEarBad, boolean rightEarBad) {
    String resultCaption;
    StringBuilder resultsText = new StringBuilder();
    if (bothEarsBad) {
        resultsText.append(getString(R.string.The_test_indicates_a_possible_hearing_loss));
        resultsText.append(getString(R.string.We_recommend_that_you_visit_a_Hearing_Care_Professional_for_a_comprehensive_hearing_check));
    }else{
        if (leftEarBad) {
            resultsText.append(getString(R.string.The_test_indicates_a_possible_hearing_loss_for_your_left_ear));
            resultsText.append(getString(R.string.We_recommend_that_you_visit_a_Hearing_Care_Professional_for_a_comprehensive_hearing_check));
        } else if (rightEarBad) {
            resultsText.append(getString(R.string.The_test_indicates_a_possible_hearing_loss_for_your_Right_ear));
            resultsText.append(getString(R.string.We_recommend_that_you_visit_a_Hearing_Care_Professional_for_a_comprehensive_hearing_check));      
        }else {
            resultsText.append(getString(R.string.There_is_no_indication_of_hearing_loss));
        }                               
    }

    resultsText.append(getString(R.string.The_results_of_the_hearing_test_are_not_to_be_utilized_as_an_official_outcome_for_assessing_levels_of_hearing_loss_True_hearing_loss_assessments_can_only_be_determined_by_a_licensed_hearing_healthcare_provider));                                  

    Log.d(TAG, "The results were " + resultsText);

    return resultsText;
}

public void infoView(View aView) {
    Intent intent = new Intent(this, InfoActivity.class);
    startActivity(intent);
}
}

公共类选项卡ResultsActivity扩展了SherlockFragmentActivity{
TabHost-mTabHost；
TabManager-mTabManager；
公共静态最终字符串为\u RIGHT\u EAR=“IS\u RIGHT\u EAR”；
私有ArrayList leftAnswerList；
私人ArrayList rightAnswerList；
私有最终静态字符串TAG=“HearingTest”；
私有布尔值isRightEarTab=true；
私家布尔值不好；
私有布尔左耳坏；
私有布尔右耳巴德；
@抑制警告（“未选中”）
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.tab_布局）；
ActionBar ab=this.getSupportActionBar（）；
SherlockHelper.setupActionBar（ab，this）；
查看信息按钮=findViewById（R.id.info_按钮）；
infoButton.setVisibility（View.VISIBLE）；
Intent=getIntent（）；
int rowId=intent.getIntExtra（ResultsDatabase.\u ID，-1）；
如果（rowId！=-1）{
ResultsDatabase db=新的ResultsDatabase（此）；
字符串select=“（“+ResultsDatabase.\u ID+”==“+rowId+”）；
游标c=db.getReadableDatabase（）.query（ResultsDatabase.TABLE_NAME，null，select，null，null，null，null）；
if（c.moveToFirst（））{
int leftEarColumn=c.getColumnIndex（ResultsDatabase.leftear）；
字节[]leftEarByteArray=c.getBlob（leftEarColumn）；
int righterColumn=c.getColumnIndex（ResultsDatabase.RIGHT\u EAR）；
字节[]rightEarByteArray=c.getBlob（rightEarColumn）；
leftAnswerList=（ArrayList）ResultsDatabase.deserializeObject（leftEarByteArray）；
rightAnswerList=（ArrayList）ResultsDatabase.deserializeObject（rightEarByteArray）；
}
}否则{
字节[]leftearbytarray=getIntent（）.getByteArrayExtra（ResultsDatabase.leftear）；
字节[]rightEarByteArray=getIntent（）.getByteArrayExtra（ResultsDatabase.RIGHT_EAR）；
leftAnswerList=（ArrayList）ResultsDatabase.deserializeObject（leftEarByteArray）；
rightAnswerList=（ArrayList）ResultsDatabase.deserializeObject（rightEarByteArray）；
}
isRightEarTab=getIntent（）.getBooleanExtra（是右耳，真的）；
GraphView GraphView=新的GraphView（本）；
图形视图设定点（右侧应答列表）；
float leftAverage=calculateAverage（rightAnswerList）；
graphView.setAverage（leftAverage）；
图形视图设定点（左应答列表）；
float rightAverage=calculateAverage（leftAnswerList）；
graphView.setAverage（右平均）；
setResults（leftAnswerList、rightAnswerList）；
String results=setResultOption（bothEarsBad、leftEarBad、righearBad）；
Log.d（标签“结果为”+结果）；
Bundle leftbundle=新Bundle（）；
putString（“结果”，results）；
leftbundle.putParcelableArrayList（“图形”，leftAnswerList）；
leftbundle.putFloat（“平均”，leftAverage）；
Bundle rightbundle=新Bundle（）；
putString（“结果”，results）；
rightbundle.putParcelableArrayList（“图形”，
public void storeResults(String name, List<EarSrt> leftAnswerList, List<EarSrt> rightAnswerList){
    SQLiteDatabase db = getWritableDatabase(); // opens the database connection
    try {
        ContentValues values = new ContentValues();
        values.put(SAVED_NAME, name);
        Long now = Long.valueOf(System.currentTimeMillis());
        values.put(COLUMN_NAME_CREATE_DATE, now);
        values.put(RIGHT_EAR, serializeObject(rightAnswerList ));
        values.put(LEFT_EAR, serializeObject(leftAnswerList ));
        db.insert(TABLE_NAME, null, values);
    }
    catch(Exception e) {
        e.printStackTrace();
        // furher error handling
    }
    finally {
        db.close(); // closes the database every time after access
    }
}