怎么办我解决抛出：IllegalArgumentException？ [英] How to do i resolve IllegalArgumentException?

问题描述

我到Android一个小白。并用SQLite表时我得到一个非法参数异常。在logcat中表示，这是由于我的光标没有被关闭，所以我关闭我所有的游标。现在，我仍然得到不带详细消息抛出诸如IllegalArgumentException和我的logcat没有显示任何错误消息只调试和警告信息。没有任何错误消息指出我在正确的方向，我不知道如何甚至开始解决这个问题。任何帮助是极大的AP preciated。

这是code，我和光标的问题预先固定：

 公共静态最后弦乐KEY_ROWID =_id;
公共静态最后弦乐KEY_NAME =cointype_name;
公共静态最后弦乐KEY_QUANTITY =cointype_quantity;
公共静态最后弦乐KEY_OUNCES =cointype_ounces;
公共静态最后弦乐KEY_VALUE =cointype_value;私有静态最后弦乐DATABASE_NAME =PortfolioDatabase;
私有静态最后弦乐DATABASE_TABLE =cointypeTable;
私有静态最终诠释DATABASE_VERSION = 1;私人DbHelper ourHelper;
私人最终上下文ourContext;
私人SQLiteDatabase ourDatabase;私有静态类DbHelper扩展SQLiteOpenHelper {    公共DbHelper（上下文的背景下）{
        超（背景下，DATABASE_NAME，空，DATABASE_VERSION）;
        // TODO自动生成构造函数存根
    }    @覆盖
    公共无效的onCreate（SQLiteDatabase DB）{
        // TODO自动生成方法存根
        db.execSQL（CREATE TABLE+ DATABASE_TABLE +（+
                KEY_ROWID +INTEGER PRIMARY KEY AUTOINCREMENT，+
                KEY_NAME +TEXT NOT NULL，+
                KEY_QUANTITY +TEXT NOT NULL，+
                KEY_OUNCES +TEXT NOT NULL，+
                KEY_VALUE +TEXT NOT NULL）;
        ）;
    }    @覆盖
    公共无效onUpgrade（SQLiteDatabase分贝，INT oldVersion，诠释静态网页）{
        // TODO自动生成方法存根
        db.execSQL（DROP TABLE IF EXISTS+ DATABASE_TABLE）;
        的onCreate（DB）;
    }
}公共PortfolioDatabase（上下文C）{
    ourContext = C;
}公共PortfolioDatabase的open（）抛出的SQLException {
    ourHelper =新DbHelper（ourContext）;
    ourDatabase = ourHelper.getWritableDatabase（）;
    返回此;
}
 公共无效的close（）{
     ourHelper.close（）;
}众长createEntry（字符串硬币，数量字符串，字符串盎司，字符串值）{
    // TODO自动生成方法存根
    ContentValues​​ CV =新ContentValues​​（）;
    cv.put（KEY_NAME，硬币）;
    cv.put（KEY_QUANTITY，数量）;
    cv.put（KEY_OUNCES，盎司）;
    cv.put（KEY_VALUE，值）;
    返回ourDatabase.insert（DATABASE_TABLE，空，CV）;
}公共字符串的getData（）{
    // TODO自动生成方法存根
    的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
    光标C = ourDatabase.query（DATABASE_TABLE，列，NULL，NULL，NULL，NULL，NULL）;
    字符串结果=;    INT iRow = c.getColumnIndex（KEY_ROWID）;
    INT INAME = c.getColumnIndex（KEY_NAME）;
    INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
    INT iOunces = c.getColumnIndex（KEY_OUNCES）;
    INT iValue = c.getColumnIndex（KEY_VALUE）;    为（c.moveToFirst（）;！c.isAfterLast（）; c.moveToNext（））{
        结果=结果+ /*c.getString(iRow）++ * / c.getString（INAME）++ c.getString（iQuantity）++ c.getString（iOunces）++ C。的getString（iValue）+\\ n;    }
    c.close（）;
    返回结果;}公共字符串getCoin（）{
    // TODO自动生成方法存根
    的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
    光标C = ourDatabase.query（DATABASE_TABLE，列，NULL，NULL，NULL，NULL，NULL）;
    字符串结果=;    INT iRow = c.getColumnIndex（KEY_ROWID）;
    INT INAME = c.getColumnIndex（KEY_NAME）;
    INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
    INT iOunces = c.getColumnIndex（KEY_OUNCES）;
    INT iValue = c.getColumnIndex（KEY_VALUE）;    为（c.moveToFirst（）;！c.isAfterLast（）; c.moveToNext（））{
        结果=结果+ /*c.getString(iRow）++ * / c.getString（INAME）.substring（0，Math.min（18，c.getString（INAME）。长度（）））+\\ N的;
    }
    c.close（）;
    返回结果;
}    公共字符串getQty（）{
        // TODO自动生成方法存根
        的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
        光标C = ourDatabase.query（DATABASE_TABLE，列，NULL，NULL，NULL，NULL，NULL）;
        字符串结果=;        INT iRow = c.getColumnIndex（KEY_ROWID）;
        INT INAME = c.getColumnIndex（KEY_NAME）;
        INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
        INT iOunces = c.getColumnIndex（KEY_OUNCES）;
        INT iValue = c.getColumnIndex（KEY_VALUE）;        为（c.moveToFirst（）;！c.isAfterLast（）; c.moveToNext（））{
            结果=结果+ /*c.getString(iRow）++ * / c.getString（iQuantity）+\\ n;
        }
    c.close（）;
    返回结果;
}    公共字符串getOunces（）{
        // TODO自动生成方法存根
        的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
        光标C = ourDatabase.query（DATABASE_TABLE，列，NULL，NULL，NULL，NULL，NULL）;
        字符串结果=;        INT iRow = c.getColumnIndex（KEY_ROWID）;
        INT INAME = c.getColumnIndex（KEY_NAME）;
        INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
        INT iOunces = c.getColumnIndex（KEY_OUNCES）;
        INT iValue = c.getColumnIndex（KEY_VALUE）;        为（c.moveToFirst（）;！c.isAfterLast（）; c.moveToNext（））{
            结果=结果+ /*c.getString(iRow）++ * / c.getString（iOunces）+\\ n;
        }
        c.close（）;
        返回结果;
    }    公共字符串的getValue（）{
        // TODO自动生成方法存根
        的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
        光标C = ourDatabase.query（DATABASE_TABLE，列，NULL，NULL，NULL，NULL，NULL）;
        字符串结果=;        INT iRow = c.getColumnIndex（KEY_ROWID）;
        INT INAME = c.getColumnIndex（KEY_NAME）;
        INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
        INT iOunces = c.getColumnIndex（KEY_OUNCES）;
        INT iValue = c.getColumnIndex（KEY_VALUE）;        为（c.moveToFirst（）;！c.isAfterLast（）; c.moveToNext（））{
            结果=结果+ /*c.getString(iRow）++ * / c.getString（iValue）+\\ n;
        }
        c.close（）;
    返回结果;
}公共字符串getSingleValue（字符串aCoin）抛出的SQLException {
    // TODO自动生成方法存根
    的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_OUNCES，KEY_VALUE};
    光标C = ourDatabase.query（DATABASE_TABLE，列KEY_NAME +=+ aCoin，NULL，NULL，NULL，NULL）;
    字符串结果=;    INT iRow = c.getColumnIndex（KEY_ROWID）;
    INT INAME = c.getColumnIndex（KEY_NAME）;
    INT iQuantity = c.getColumnIndex（KEY_QUANTITY）;
    INT iOunces = c.getColumnIndex（KEY_OUNCES）;
    INT iValue = c.getColumnIndex（KEY_VALUE）;    如果（C！= NULL）{
        c.moveToFirst（）;
        结果= c.getString（0）;
        返回结果;
    }
    c.close（）;
    返回null;
}/ *公共字符串getHotness（长升）抛出的SQLException {
    // TODO自动生成方法存根
    的String [] =列新的String [] {KEY_ROWID，KEY_NAME，KEY_QUANTITY，KEY_VALUE};
    光标C = ourDatabase.query（DATABASE_TABLE，列KEY_ROWID +=+ 1，NULL，NULL，NULL，NULL）;
    如果（C！= NULL）{
        c.moveToFirst（）;
        串辣味= c.getString（2）;
        返回的辣味;
    }
    c.close（）;
    返回null;
} * /公共无效updateEntry（字符串mCoin，字符串mQuantity，字符串mOunces，字符串mValue）抛出的SQLException {
    // TODO自动生成方法存根
    的String [] = whereArgs新的String [] {} mCoin;
    ContentValues​​ cvUpdate =新ContentValues​​（）;
    cvUpdate.put（KEY_NAME，mCoin）;
    cvUpdate.put（KEY_QUANTITY，mQuantity）;
    cvUpdate.put（KEY_OUNCES，mOunces）;
    cvUpdate.put（KEY_VALUE，mValue）;
    ourDatabase.update（DATABASE_TABLE，cvUpdate，KEY_NAME +=？，whereArgs）;
}公共无效changeCurrency（字符串mCoin，字符串mValue）抛出的SQLException {
    // TODO自动生成方法存根
    的String [] = whereArgs新的String [] {} mCoin;
    ContentValues​​ cvUpdate =新ContentValues​​（）;
    cvUpdate.put（KEY_NAME，mCoin）;
    cvUpdate.put（KEY_VALUE，mValue）;
    ourDatabase.update（DATABASE_TABLE，cvUpdate，KEY_NAME +=？，whereArgs）;
}公共无效deleteEntry（字符串硬币）抛出的SQLException {
    的String [] = whereArgs新的String [] {}硬币;
    ourDatabase.delete（DATABASE_TABLE，KEY_NAME +=？，whereArgs）;
}公共无效的removeAll（）
{
    / * // db.delete（字符串tableName值，字符串whereClause，字符串[] whereArgs）;
    //如果whereClause为null，它将删除所有行。
    SQLiteDatabase分贝= helper.getWritableDatabase（）; //助手是对象扩展SQLiteOpenHelper
    db.delete（DatabaseHelper.TAB_USERS，NULL，NULL）;
    db.delete（DatabaseHelper.TAB_USERS_GROUP，NULL，NULL）; * /
    ourDatabase.delete（DATABASE_TABLE，NULL，NULL）;}}
 

在code原因的错误。

 公共无效的add（）{
    布尔didItWork = TRUE;
    尝试{
        //字符串名称= sqlName.getText（）的toString（）;
        //字符串辣味= sqlHotness.getText（）的toString（）。
        calculateaddentry（）;
        。字符串币= addcoinselection.getSelectedItem（）的toString（）;
        串数量= sqlAddCoin.getText（）的toString（）。
        字符串盎司= entryounces;
        字符串值=面值+ newentryvalue;
        // PortfolioDatabase进入=新PortfolioDatabase（Portfolio.this）;
        info.open（）;
        info.createEntry（硬币，数量，盎司，价值）;
        info.close（）;        info.open（）;
        字符串数据= info.getData（）;
        串ccoin = info.getCoin（）;
        串cqty = info.getQty（）;
        串counces = info.getOunces（）;
        串cvalue = info.getValue（）;
        info.close（）;        currentcoin.setText（ccoin）;
        currentqty.setText（cqty）;
        currentounces.setText（counces）;
        currentvalue.setText（cvalue）;    }赶上（例外五）{
        didItWork = FALSE;
        字符串错误= e.toString（）;
        对话D =新的对话框（本）;
        d.setTitle（该死！）;
        TextView的电视=新的TextView（本）;
        tv.setText（错误）;
        d.setContentView（电视）;
        d.show（）;
    } {最后
        如果（didItWork）{
            / *对话D =新的对话框（本）;
            d.setTitle（见鬼啊！）;
            TextView的电视=新的TextView（本）;
            tv.setText（成功）;
            d.setContentView（电视）;
            d.show（）; * /
        }
    }}
 

解决方案

尝试 DATABASE_VERSION 值更改为 2 当您更改表结构，添加列或数据库中的类添加表增量。

在更改 DATABASE_VERSION 触发调用 onUpgrade（）而你的情况将会删除表和创建一个新的。只要 DATABASE_VERSION 是一样的， onUpgrade（）或的onCreate（）不会被称为因此结构将不会受到影响，因此不更新数据库的结构。这可能是为什么你所得到的抛出：IllegalArgumentException，因为它可能无法找到该设备的数据库中的列，因为该列是不存在的原因。这是当它说，文件是指什么：

  

请注意：此类假定为单调增加的升级版本号

。

的http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html

因此​​，如果你犯了一个简单的数据库，运行它，然后添加在的onCreate（）方法一栏不改变数据库版本，数据库类方法的onCreate（）或 onUpgrade（）将不会被调用，因为就它而言，该数据库是一样的。

您必须记住，一个Android本地数据库是的永久的。它会留在你的设备超出了应用程序的运行上。因此，数据库保存从应用程序到另一个的一个运行信息。数据库的不会重置每次的运行应用程序。这不仅包括保存的数据，但也的数据库结构，如表和列。

当您运行code首先，它会检查数据库是否已经被创建。这是实际的设备上。如果它存在，它将检查设备上的数据库版本的 DATABASE_VERSION 中的辅助类相匹配。如果是这样，它不会做任何事情。如果 DATABASE_VERSION 数据库类比设备上的数据库版本高，那么 onUpgrade（）方法打电话的定义将调整数据库。

I'm a noob to android. and I am getting an illegal argument exception when working with a SQLite table. The logcat indicated that this was due to my cursor not being closed so i closed all my cursors. Now i am still getting the IllegalArgumentException with no detail message and my logcat isn't showing any error messages just debug and warning messages. Without any error messages to point me in the right direction i don't know how to even begin to fix this issue. Any help is greatly appreciated.

This is the code that i fixed beforehand with the cursor issue:

public static final String KEY_ROWID = "_id";
public static final String KEY_NAME = "cointype_name";
public static final String KEY_QUANTITY = "cointype_quantity";
public static final String KEY_OUNCES = "cointype_ounces";
public static final String KEY_VALUE = "cointype_value";

private static final String DATABASE_NAME = "PortfolioDatabase";
private static final String DATABASE_TABLE = "cointypeTable";
private static final int DATABASE_VERSION = 1;

private DbHelper ourHelper;
private final Context ourContext;
private SQLiteDatabase ourDatabase;

private static class DbHelper extends SQLiteOpenHelper{

    public DbHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // TODO Auto-generated method stub
        db.execSQL("CREATE TABLE " + DATABASE_TABLE + " (" +
                KEY_ROWID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
                KEY_NAME + " TEXT NOT NULL, " +
                KEY_QUANTITY  + " TEXT NOT NULL, " +
                KEY_OUNCES + " TEXT NOT NULL, " +
                KEY_VALUE + " TEXT NOT NULL);"
        );  
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // TODO Auto-generated method stub
        db.execSQL("DROP TABLE IF EXISTS " + DATABASE_TABLE);
        onCreate(db);
    }       
}

public PortfolioDatabase(Context c){
    ourContext = c;
}

public PortfolioDatabase open() throws SQLException{
    ourHelper = new DbHelper(ourContext);
    ourDatabase = ourHelper.getWritableDatabase();      
    return this;
}
 public void close(){
     ourHelper.close();
}

public long createEntry(String coin, String quantity, String ounces, String value) {
    // TODO Auto-generated method stub
    ContentValues cv = new ContentValues();
    cv.put(KEY_NAME, coin);
    cv.put(KEY_QUANTITY, quantity);
    cv.put(KEY_OUNCES, ounces);
    cv.put(KEY_VALUE, value);
    return ourDatabase.insert(DATABASE_TABLE, null, cv);
}

public String getData() {
    // TODO Auto-generated method stub
    String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE };        
    Cursor c = ourDatabase.query(DATABASE_TABLE, columns, null, null, null, null, null);
    String result = "";

    int iRow = c.getColumnIndex(KEY_ROWID);
    int iName = c.getColumnIndex(KEY_NAME);
    int iQuantity = c.getColumnIndex(KEY_QUANTITY);
    int iOunces = c.getColumnIndex(KEY_OUNCES);
    int iValue = c.getColumnIndex(KEY_VALUE);

    for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()){
        result = result + /*c.getString(iRow) + " " +*/ c.getString(iName) + " " + c.getString(iQuantity) + " " + c.getString(iOunces) + " " + c.getString(iValue) + "\n";

    }
    c.close();
    return result;

}

public String getCoin() {
    // TODO Auto-generated method stub
    String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE };
    Cursor c = ourDatabase.query(DATABASE_TABLE, columns, null, null, null, null, null);
    String result = "";

    int iRow = c.getColumnIndex(KEY_ROWID);
    int iName = c.getColumnIndex(KEY_NAME);
    int iQuantity = c.getColumnIndex(KEY_QUANTITY);
    int iOunces = c.getColumnIndex(KEY_OUNCES);
    int iValue = c.getColumnIndex(KEY_VALUE);

    for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()){
        result = result + /*c.getString(iRow) + " " +*/ c.getString(iName).substring(0, Math.min(18, c.getString(iName).length())) + "\n";
    }
    c.close();
    return result;
}

    public String getQty() {
        // TODO Auto-generated method stub
        String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE };
        Cursor c = ourDatabase.query(DATABASE_TABLE, columns, null, null, null, null, null);
        String result = "";

        int iRow = c.getColumnIndex(KEY_ROWID);
        int iName = c.getColumnIndex(KEY_NAME);
        int iQuantity = c.getColumnIndex(KEY_QUANTITY);
        int iOunces = c.getColumnIndex(KEY_OUNCES);
        int iValue = c.getColumnIndex(KEY_VALUE);

        for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()){
            result = result + /*c.getString(iRow) + " " +*/ c.getString(iQuantity) + "\n";
        }           
    c.close();
    return result;
}

    public String getOunces() {
        // TODO Auto-generated method stub
        String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE };
        Cursor c = ourDatabase.query(DATABASE_TABLE, columns, null, null, null, null, null);
        String result = "";

        int iRow = c.getColumnIndex(KEY_ROWID);
        int iName = c.getColumnIndex(KEY_NAME);
        int iQuantity = c.getColumnIndex(KEY_QUANTITY);
        int iOunces = c.getColumnIndex(KEY_OUNCES);
        int iValue = c.getColumnIndex(KEY_VALUE);

        for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()){
            result = result + /*c.getString(iRow) + " " +*/  c.getString(iOunces) + "\n";
        }
        c.close();
        return result;
    }

    public String getValue() {
        // TODO Auto-generated method stub
        String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE };
        Cursor c = ourDatabase.query(DATABASE_TABLE, columns, null, null, null, null, null);
        String result = "";

        int iRow = c.getColumnIndex(KEY_ROWID);
        int iName = c.getColumnIndex(KEY_NAME);
        int iQuantity = c.getColumnIndex(KEY_QUANTITY);
        int iOunces = c.getColumnIndex(KEY_OUNCES);
        int iValue = c.getColumnIndex(KEY_VALUE);

        for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()){
            result = result + /*c.getString(iRow) + " " +*/ c.getString(iValue) + "\n";
        }           
        c.close();
    return result;
}



public String getSingleValue(String aCoin) throws SQLException{
    // TODO Auto-generated method stub
    String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_OUNCES, KEY_VALUE};     
    Cursor c = ourDatabase.query(DATABASE_TABLE, columns, KEY_NAME + "=" + aCoin, null, null, null, null);
    String result = "";

    int iRow = c.getColumnIndex(KEY_ROWID);
    int iName = c.getColumnIndex(KEY_NAME);
    int iQuantity = c.getColumnIndex(KEY_QUANTITY);
    int iOunces = c.getColumnIndex(KEY_OUNCES);
    int iValue = c.getColumnIndex(KEY_VALUE);

    if (c != null){
        c.moveToFirst();
        result= c.getString(0);
        return result;
    }
    c.close();
    return null;
}

/*public String getHotness(long l) throws SQLException{
    // TODO Auto-generated method stub
    String[] columns = new String[]{ KEY_ROWID, KEY_NAME, KEY_QUANTITY, KEY_VALUE };
    Cursor c = ourDatabase.query(DATABASE_TABLE, columns, KEY_ROWID + "=" + l, null, null, null, null);
    if (c != null){
        c.moveToFirst();
        String hotness = c.getString(2);
        return hotness;
    }
    c.close();
    return null;
}*/



public void updateEntry(String mCoin, String mQuantity, String mOunces, String mValue) throws SQLException{
    // TODO Auto-generated method stub
    String[] whereArgs = new String[] { mCoin };
    ContentValues cvUpdate = new ContentValues();
    cvUpdate.put(KEY_NAME, mCoin);
    cvUpdate.put(KEY_QUANTITY, mQuantity);
    cvUpdate.put(KEY_OUNCES, mOunces);
    cvUpdate.put(KEY_VALUE, mValue);
    ourDatabase.update(DATABASE_TABLE, cvUpdate, KEY_NAME + "=?", whereArgs);   
}

public void changeCurrency(String mCoin, String mValue) throws SQLException{
    // TODO Auto-generated method stub
    String[] whereArgs = new String[] { mCoin };
    ContentValues cvUpdate = new ContentValues();
    cvUpdate.put(KEY_NAME, mCoin);      
    cvUpdate.put(KEY_VALUE, mValue);
    ourDatabase.update(DATABASE_TABLE, cvUpdate, KEY_NAME + "=?", whereArgs);   
}



public void deleteEntry(String coin) throws SQLException{
    String[] whereArgs = new String[] { coin };
    ourDatabase.delete(DATABASE_TABLE, KEY_NAME + "=?", whereArgs);
}

public void removeAll()
{
    /*// db.delete(String tableName, String whereClause, String[] whereArgs);
    // If whereClause is null, it will delete all rows.
    SQLiteDatabase db = helper.getWritableDatabase(); // helper is object extends SQLiteOpenHelper
    db.delete(DatabaseHelper.TAB_USERS, null, null);
    db.delete(DatabaseHelper.TAB_USERS_GROUP, null, null);*/
    ourDatabase.delete(DATABASE_TABLE, null, null);

}

}

The code the causes the error.

public void add(){
    boolean didItWork = true;
    try {
        //String name = sqlName.getText().toString();
        //String hotness = sqlHotness.getText().toString();
        calculateaddentry();
        String coin = addcoinselection.getSelectedItem().toString();
        String quantity = sqlAddCoin.getText().toString();
        String ounces = entryounces;
        String value = denomination + newentryvalue;


        //PortfolioDatabase entry = new PortfolioDatabase(Portfolio.this);
        info.open();
        info.createEntry(coin, quantity, ounces, value);
        info.close();

        info.open();
        String data = info.getData();       
        String ccoin = info.getCoin();      
        String cqty = info.getQty();        
        String counces = info.getOunces();          
        String cvalue = info.getValue();
        info.close();

        currentcoin.setText(ccoin);
        currentqty.setText(cqty);
        currentounces.setText(counces);
        currentvalue.setText(cvalue);

    } catch (Exception e) {
        didItWork = false;
        String error = e.toString();
        Dialog d = new Dialog(this);
        d.setTitle("Dang it!");
        TextView tv = new TextView(this);
        tv.setText(error);
        d.setContentView(tv);
        d.show();
    } finally {
        if (didItWork) {
            /*Dialog d = new Dialog(this);
            d.setTitle("Heck Yea!");
            TextView tv = new TextView(this);
            tv.setText("Success");
            d.setContentView(tv);
            d.show();*/
        }
    }}

解决方案

Try changing the DATABASE_VERSION value to 2 and increment when you change the table structure, add columns or add tables in the database class.

The change in the DATABASE_VERSION triggers the call to onUpgrade() which in your case will drop the table and create a new one. As long as the DATABASE_VERSION is the same, onUpgrade() or onCreate() won't be called therefore the structure won't be affected and therefore not updating the database structure. This could be the reason why you are getting the IllegalArgumentException as it probably can't find a column in the device's database because the column isn't there. This is what the documentation means when it says:

Note: this class assumes monotonically increasing version numbers for upgrades.

http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html

Thus, if you make a simple database, run it, then add a column in the onCreate() method without changing the database version, the database class methods onCreate() or the onUpgrade() won't be called, because as far as it's concerned, the database is the same.

You must remember that an Android local database is persistent. It will stay on your device beyond the app running. Thus the database holds information from one run of the app to another. The database does not reset every time you run the application. This not only includes the data it holds but also the database structure, such as tables and columns.

When you run the code first is that it will check if a database has been created already. This is on the actual device. If it exists it will check if the database version on the device matches the DATABASE_VERSION in the helper class. If it does, it doesn't do anything. If the DATABASE_VERSION in the database class is greater than the database version on the device, then the onUpgrade() method is called and will adjust the database as defined.

这篇关于怎么办我解决抛出：IllegalArgumentException？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！