日期时间显示不出来日期、时间、不出来
2023-09-03 21:54:04
作者：囚念
我想获得时间戳显示─我曾尝试以不同的方式的onCreate 查询，也试图让更新时间在 addPrime 的值。似乎没有任何工作。我的目的是让该应用显示previous素数，他们被发现的时间。其目的为应用程序是为用户能够关闭/杀应用程序，并继续从最后重新启动应用程序时，如果您有任何提示怎么也这是有可能，我将不胜感激发现的素数计算。
这是PrimeDBManager类
公共类PrimeDBManager扩展SQLiteOpenHelper {
私有静态最终诠释DATABASE_VERSION = 1;
私有静态最后弦乐DATABASE_NAME =prime.db;
公共静态最后弦乐TABLE_PRIME =素;
公共静态最后弦乐COLUMN_ID =_id;
公共静态最后弦乐COLUMN_PRIMENO =primeno;
公共静态最后弦乐COLUMN_DATETIME =日期时间;
公共PrimeDBManager（上下文的背景下，字符串名称，SQLiteDatabase.CursorFactory工厂，INT版）{
超（背景下，DATABASE_NAME，工厂，DATABASE_VERSION）;
}
@覆盖
公共无效的onCreate（SQLiteDatabase DB）{
查询字符串=CREATE TABLE+ TABLE_PRIME +（+ COLUMN_ID +INTEGER PRIMARY KEY AUTOINCREMENT，+ COLUMN_PRIMENO +TEXT+ COLUMN_DATETIME +DATETIME DEFAULT CURRENT_TIMESTAMP+）;
db.execSQL（查询）;
}
@覆盖
公共无效onUpgrade（SQLiteDatabase分贝，INT oldVersion，诠释静态网页）{
db.execSQL（DROP TABLE IF EXISTS+ TABLE_PRIME）;
的onCreate（DB）;
}
//添加新总理到数据库
公共无效addPrime（总理素）{
ContentValues值=新ContentValues（）;
values.put（COLUMN_PRIMENO，prime.get_primeno（））;
SQLiteDatabase DB = getWritableDatabase（）;
db.insert（TABLE_PRIME，空，价值观）;
}
公共无效添加时间（总理素）{
ContentValues值=新ContentValues（）;
values.put（COLUMN_DATETIME，prime.get_datetime（））;
SQLiteDatabase DB = getWritableDatabase（）;
db.insert（TABLE_PRIME，空，价值观）;
}
公共字符串databaseToString（）{
字符串dbString =;
SQLiteDatabase DB = getWritableDatabase（）;
查询字符串=SELECT * FROM+ TABLE_PRIME +WHERE 1;
光标C = db.rawQuery（查询，NULL）;
c.moveToFirst（）;
而（！c.isAfterLast（））{
如果（c.getString（c.getColumnIndex（primeno））！= NULL）{
dbString + = c.getString（c.getColumnIndex（primeno））;
dbString + =\ N的;
}
c.moveToNext（）;
}
db.close（）;
返回dbString;
}
}
总理级
公共类总理{
私人诠释_id;
私人字符串_primeno;
私人字符串_datetime;
公共素（）{}
公共总理（字符串_primeno）{
this._primeno = _primeno;
}
公共无效set_id（INT _id）{
this._id = _id;
}
公共无效set_primeno（字符串_primeno）{
this._primeno = _primeno;
}
公众诠释get_id（）{
返回_id;
}
公共字符串get_primeno（）{
返回_primeno;
}
公共无效set_datetime（字符串_datetime）{
this._datetime = _datetime;
}
公共字符串get_datetime（）{
返回_datetime;
}
}
和最后的MainActivity类
公共类MainActivity扩展ActionBarActivity {
按钮primeButton;
INT最大= 500;
TextView的primeText;
INT J = 2;
TextView的previousPrime;
PrimeDBManager dbManager;
@覆盖
保护无效的onCreate（包savedInstanceState）{
super.onCreate（savedInstanceState）;
的setContentView（R.layout.activity_main）;
primeButton =（按钮）findViewById（R.id.primeButton）;
primeText =（TextView中）findViewById（R.id.primeText）;
previousPrime =（TextView中）findViewById（R.id. previousPrime）;
dbManager =新PrimeDBManager（这一点，NULL，NULL，1）;
printDatabase（）;
primeButton.setOnClickListener（新View.OnClickListener（）{
@覆盖
公共无效的onClick（视图v）{
// TODO自动生成方法存根
对于（INT I = j的;我＆LT; = MAX;我++）{
如果（isPrimeNumber（i））的{
primeText.setText第（i +）;
J = 1 + 1;
打破;
}
}
总理素=新总理（primeText.getText（）的toString（））;
dbManager.addPrime（总理）;
dbManager.addTime（总理）;
printDatabase（）;
}
}）;
}
公共无效printDatabase（）{
串dbString = dbManager.databaseToString（）;
previousPrime.setText（dbString）;
}
公共布尔isPrimeNumber（INT编号）{
的for（int i = 2; I＆LT; =号/ 2;我++）{
如果（编号％我== 0）{
返回false;
}
}
返回true;
}
}
解决方案
好吧，既然你上传你的项目我的认为的我得到了它的工作，你想要的方式。这是工作仍然。
有几个错误 - 大多与逻辑。我想发表评论，就像我可以这样你就可以明白/为什么我做的一切。
有一件事情我不发表意见是， AndroidManifest 所需的权限：
＆LT;使用-权限的Android：名称=android.permission.WRITE_EXTERNAL_STORAGE/＆GT;
您可以这里下载项目，或者只是看看在片段：
MainActivity
我添加了一个的ListView ，所以你可以看到所有的素数。同时改变了/我们从DB获得的数据，以及我们如何保存到数据库中。
公共类MainActivity扩展ActionBarActivity {
私有静态最后字符串变量= MainActivity.class.getSimpleName（）;
私人INT最大= 500;
私人TextView的primeText;
私人诠释previousPrimeNumber;
私人列表＆LT;总理＆GT;素数;
私人PrimeAdapter适配器;
私人MyDBHandler dbManager;
@覆盖
保护无效的onCreate（包savedInstanceState）{
super.onCreate（savedInstanceState）;
的setContentView（R.layout.activity_main）;
primeText =（TextView中）findViewById（R.id.primeText）;
//得到previous会话对象。请记住，这些都是按日期排序
dbManager =新MyDBHandler（本）;
素数= dbManager.getPrimeObjects（）;
//得到第一个素数。 （AKA最后一个加）
如果（primes.size（）！= 0）{
previousPrimeNumber = primes.get（0）.get_primeno（）; //得到第一个项目
primeText.setText（将String.valueOf（previousPrimeNumber））;
} 其他 {
previousPrimeNumber = 2;
}
//创建列表视图和适配器来显示数据
ListView控件的ListView =（ListView控件）findViewById（R.id.listView）;
适配器=新PrimeAdapter（这一点，素数）;
listView.setAdapter（适配器）;
findViewById（R.id.primeButton）.setOnClickListener（新View.OnClickListener（）{
@覆盖
公共无效的onClick（视图v）{
INT primeNumber = -1;
//增量previousPrimeNumber接一个，所以我们不会继续使用previousPrimeNumber
对于（INT I = previousPrimeNumber + 1; I＆LT; = MAX;我++）{
如果（isPrimeNumber（i））的{
primeNumber =我;
primeText.setText（将String.valueOf（一））;
previousPrimeNumber = I + 1;
打破;
}
}
如果（primeNumber！= -1）{
总理素=新总理（primeNumber）;
dbManager.addPrime（总理）;
/ *是的，它保存到我们的数据库。但是，没有任何理由让我们从阅读
*它太当我们的主要目的就在这里。因此，只要将它添加到
*适配器和做* /
//适配器被看着清单素数。所以它添加到顶部，并通知
primes.add（0，素数）;
adapter.notifyDataSetChanged（）;
} 其他 {
Log.e（TAG，哎呀，有一个错误无效的素数。）;
}
}
}）;
}
公共布尔isPrimeNumber（INT编号）{
的for（int i = 2; I＆LT; =号/ 2;我++）{
如果（编号％我== 0）{
返回false;
}
}
返回true;
}
/ **
*如果这是太混乱了，你可以忽略它。
*但是，我建议您了解潜水前的android用户界面到数据库存储。
*看看这个链接：
* http://www.vogella.com/tutorials/AndroidListView/article.html
* /
私有类PrimeAdapter扩展ArrayAdapter＆LT;总理＆GT; {
公共PrimeAdapter（上下文的背景下，名单，其中，总理＆GT;质数）{
//我只是用机器人的看法。 （android.R.id ...）
超（背景下，android.R.layout.simple_list_item_2，素数）;
}
@覆盖
公共查看getView（INT的立场，观点来看，一个ViewGroup父）{
/ *这个方法将自动地被调用列表中的每一个项目。
*这是一个数组适配器。因此它具有我们通过在对数据的列表
*构造。因此，通过调用这个我们正在访问它喜欢它是一个列表
*它确实是。 * /
最后总理素= this.getItem（位置）;
如果（查看== NULL）{
鉴于= LayoutInflater.from（MainActivity.this）
.inflate（android.R.layout.simple_list_item_2，NULL）;
}
/ *如果你simple_list_item_2，你会看到两个textViews。文本1和文本。
*通常你会创建这个视图自己，但就像我说的，这是不
*原因，我在这里* /
//注意我引用android.R.id。而不是R.id.那是因为我懒惰，
//没有创造我自己的看法。
TextView的TV1 =（TextView中）view.findViewById（android.R.id.text1）;
TextView的TV2 =（TextView中）view.findViewById（android.R.id.text2）;
tv1.setText（将String.valueOf（prime.get_primeno（）））;
tv2.setText（prime.getDateTimeFormatted（））;
//现在回到视图，使列表视图知道，以显示它
返回查看;
}
}
MyDBHandler：
改变了查询，并添加两个方法，将其转换总理到 ContentValues 对象和光标来的黄金。
公共类MyDBHandler扩展SQLiteOpenHelper {
私有静态最终诠释DATABASE_VERSION = 1;
私有静态最后弦乐DATABASE_NAME =prime.db;
公共静态最后弦乐TABLE_PRIME =素;
公共静态最后弦乐COLUMN_ID =_id;
公共静态最后弦乐COLUMN_PRIMENO =primeno;
公共静态最后弦乐COLUMN_DATETIME =日期时间;
公共MyDBHandler（上下文的背景下）{
超（背景下，DATABASE_NAME，空，DATABASE_VERSION）;
}
@覆盖
公共无效的onCreate（SQLiteDatabase DB）{
查询字符串=CREATE TABLE+ TABLE_PRIME +（+
/ *这必须是在同一顺序无处不在！ * /
COLUMN_ID +INTEGER PRIMARY KEY AUTOINCREMENT，+ // ID将是指数0
COLUMN_PRIMENO +INTEGER，+ //总理将指数1
COLUMN_DATETIME +LONG）;; //日期将是指数2
db.execSQL（查询）;
/ *别的东西要注意：我改变了列类型。你有文本这些，
*这是罚款。但要存储在每个这些对象不是
*一个字符串。因此，对于一致性存储的对象作为其原始类的类型：
* PrimeNo ==整数
*日期时间==长（毫秒）
*这也使得它如此排序是非常容易* /
}
@覆盖
公共无效onUpgrade（SQLiteDatabase分贝，INT oldVersion，诠释静态网页）{
db.execSQL（DROP TABLE IF EXISTS+ TABLE_PRIME）;
的onCreate（DB）;
}
/ **
*您想保存一次整个总理对象。不是的点点滴滴。
*
* @参数素
* /
公共无效addPrime（总理素）{
ContentValues值= writePrime（总理）;
SQLiteDatabase DB = getWritableDatabase（）;
db.insert（TABLE_PRIME，空，价值观）;
/ *不要忘记关闭数据库！ * /
db.close（）;
}
/ **
*同样，你要接受一次全首要对象。不是位。
*
* @返回previous主要对象的列表
* /
公开名单＆LT;总理＆GT; getPrimeObjects（）{
最后的名单，其中，总理＆GT;素数=新的ArrayList＆LT;总理＆GT;（）;
最后SQLiteDatabase DB = getWritableDatabase（）;
/ *通常我会用这条线的code：
最后光标C = db.rawQuery（SELECT * FROM+ TABLE_PRIME，NULL）;
但是，你要确保你会得到他们排序按日期，所以你知道
在列表中的第一原是最后添加。所以我切换查询到这一点：
* /
最后光标C = db.query（TABLE_PRIME，
新的String [] {COLUMN_ID，COLUMN_PRIMENO，COLUMN_DATETIME}，
NULL，NULL，NULL，NULL，//很多空。因此，哇。
COLUMN_DATETIME +降序）; //顺序递减。
/ *查询后的第一个项目将是我们的出发点* /
c.moveToFirst（）;
而（c.moveToNext（））{
素数p = buildPrime（C）;
//检查NOT NULL
如果（P！= NULL）
primes.add（对）; //添加到列表
}
/ *不要忘记关闭数据库和光标！ * /
c.close（）;
db.close（）;
返回素数;
}
/ **
*转换光标对象返回到一个素数
*
* @参数光标光标
返回：总理
* /
私人总理buildPrime（光标指针）{
最后总理素=新总理（）;
prime.set_id（cursor.getInt（0））; //如上所述的id索引
prime.set_primeno（cursor.getInt（1））; //如上所述主要指数
prime.setDateTime（cursor.getLong（2））;如上所述//日期索引
返回素数;
}
/ **
*转换的主要对象，以ContentValues写入到数据库
*
* @参数总理素
* @返回ContentValues
* /
私人ContentValues writePrime（总理素）{
ContentValues值=新ContentValues（）;
values.put（COLUMN_PRIMENO，prime.get_primeno（））; //必须先插入
values.put（COLUMN_DATETIME，prime.getDateTime（））; //必须插入第二
返回值;
}
}
总理：
我只是改变了值类型。 总理的用途是存储一个素数。那么，为什么不使该领域的整数？
公共类总理{
私有静态最后字符串格式=YYYY-MM-DD HH：MM：SS;
私有静态最后的SimpleDateFormat格式化=新的SimpleDateFormat（格式，Locale.ENGLISH）;
私人诠释_id;
私人诠释_primeno;
专用长日期时间= 0; //这是毫秒。使得它更容易管理
公共素（）{}
公共总理（INT primeNumber）{
//创建与已知的黄金新总理对象。设置日期，而我们是在它
this._primeno = primeNumber;
this.dateTime = System.currentTimeMillis的（）;
}
公共无效set_id（INT _id）{
this._id = _id;
}
公共无效set_primeno（INT _primeno）{
this._primeno = _primeno;
}
公众诠释get_id（）{
返回_id;
}
公众诠释get_primeno（）{
返回_primeno;
}
众长getDateTime（）{
返回日期时间;
}
公共字符串getDateTimeFormatted（）{
如果（日期时间== 0）{
日期时间= System.currentTimeMillis的（）;
}
日期日期=新的日期（日期时间）;
返回formatter.format（日期）;
}
公共无效setDateTime（长日期时间）{
this.dateTime =日期时间;
}
}
I am trying to get timestamp to show- I have tried the onCreate query in different ways and also tried to to have addTime as a value in addPrime. Nothing seems to work. My intention is for the app to show previous primes and the time that they were found. The intention for the app is for the user to be able to close/kill the app and resume counting from last found prime number when restarting the app, if you have any hints how also this would be possible I would be grateful.
This is the PrimeDBManager class
public class PrimeDBManager extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
private static final String DATABASE_NAME = "prime.db";
public static final String TABLE_PRIME = "prime";
public static final String COLUMN_ID = "_id";
public static final String COLUMN_PRIMENO = "primeno";
public static final String COLUMN_DATETIME = "datetime";
public PrimeDBManager(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
super(context, DATABASE_NAME, factory, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
String query = "CREATE TABLE " + TABLE_PRIME + "(" + COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_PRIMENO + " TEXT " + COLUMN_DATETIME + " DATETIME DEFAULT CURRENT_TIMESTAMP " + ");";
db.execSQL(query);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_PRIME);
onCreate(db);
}
//Add a new prime to the database
public void addPrime(Prime prime){
ContentValues values = new ContentValues();
values.put(COLUMN_PRIMENO, prime.get_primeno());
SQLiteDatabase db = getWritableDatabase();
db.insert(TABLE_PRIME, null, values);
}
public void addTime(Prime prime) {
ContentValues values = new ContentValues();
values.put(COLUMN_DATETIME, prime.get_datetime());
SQLiteDatabase db = getWritableDatabase();
db.insert(TABLE_PRIME, null, values);
}
public String databaseToString(){
String dbString = "";
SQLiteDatabase db = getWritableDatabase();
String query = "SELECT * FROM " + TABLE_PRIME + " WHERE 1";
Cursor c = db.rawQuery(query, null);
c.moveToFirst();
while(!c.isAfterLast()) {
if (c.getString(c.getColumnIndex("primeno"))!=null){
dbString += c.getString(c.getColumnIndex("primeno"));
dbString += "\n";
}
c.moveToNext();
}
db.close();
return dbString;
}
}
Prime class
public class Prime {
private int _id;
private String _primeno;
private String _datetime;
public Prime(){ }
public Prime(String _primeno) {
this._primeno = _primeno;
}
public void set_id(int _id) {
this._id = _id;
}
public void set_primeno(String _primeno) {
this._primeno = _primeno;
}
public int get_id() {
return _id;
}
public String get_primeno() {
return _primeno;
}
public void set_datetime(String _datetime) {
this._datetime = _datetime;
}
public String get_datetime() {
return _datetime;
}
}
And lastly the MainActivity class
public class MainActivity extends ActionBarActivity {
Button primeButton;
int max = 500;
TextView primeText;
int j = 2;
TextView previousPrime;
PrimeDBManager dbManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
primeButton = (Button) findViewById(R.id.primeButton);
primeText = (TextView) findViewById(R.id.primeText);
previousPrime = (TextView) findViewById(R.id.previousPrime);
dbManager = new PrimeDBManager(this, null, null, 1);
printDatabase();
primeButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
for (int i = j; i <= max; i++) {
if (isPrimeNumber(i)) {
primeText.setText(i+"");
j = i+1;
break;
}
}
Prime prime = new Prime(primeText.getText().toString());
dbManager.addPrime(prime);
dbManager.addTime(prime);
printDatabase();
}
});
}
public void printDatabase () {
String dbString = dbManager.databaseToString();
previousPrime.setText(dbString);
}
public boolean isPrimeNumber(int number) {
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}
解决方案
Ok, since you uploaded your project I think I got it working the way you want. It is working nonetheless.
There were several errors - mostly with logic. I tried to comment as much as I could so you can understand what/why I was doing everything.
One thing I did not comment was that the AndroidManifest needed permission:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
You can download the project here, or just look at the snippets:
MainActivity
I added a ListView so you can see all the primes. Also changed how/where we get the data from the DB, and how we save to DB.
public class MainActivity extends ActionBarActivity {
private static final String TAG = MainActivity.class.getSimpleName();
private int max = 500;
private TextView primeText;
private int previousPrimeNumber;
private List<Prime> primes;
private PrimeAdapter adapter;
private MyDBHandler dbManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
primeText = (TextView) findViewById(R.id.primeText);
//get the object from previous session. Remember these are sorted by date
dbManager = new MyDBHandler(this);
primes = dbManager.getPrimeObjects();
//get the first prime. (AKA the last one added)
if (primes.size() != 0) {
previousPrimeNumber = primes.get(0).get_primeno(); //get the first item
primeText.setText(String.valueOf(previousPrimeNumber));
} else {
previousPrimeNumber = 2;
}
//create list view and adapter to display the data
ListView listView = (ListView) findViewById(R.id.listView);
adapter = new PrimeAdapter(this, primes);
listView.setAdapter(adapter);
findViewById(R.id.primeButton).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
int primeNumber = -1;
//increment previousPrimeNumber by one so we wont keep using previousPrimeNumber
for (int i = previousPrimeNumber + 1; i <= max; i++) {
if (isPrimeNumber(i)) {
primeNumber = i;
primeText.setText(String.valueOf(i));
previousPrimeNumber = i + 1;
break;
}
}
if (primeNumber != -1) {
Prime prime = new Prime(primeNumber);
dbManager.addPrime(prime);
/* Yes, it saved to our database. But there is no reason for us to read from
* it too when we have the prime object right here. So just add it to the
* adapter and be done */
//The adapter is looking at the list primes. So add it to the top and notify
primes.add(0, prime);
adapter.notifyDataSetChanged();
} else {
Log.e(TAG, "Oops, there was an error. Invalid prime number");
}
}
});
}
public boolean isPrimeNumber(int number) {
for (int i = 2; i <= number / 2; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
/**
* If this is too confusing you can ignore it for now.
* However, I recommend understanding the android UIs before diving in to database storage.
* Take a look at this link:
* http://www.vogella.com/tutorials/AndroidListView/article.html
*/
private class PrimeAdapter extends ArrayAdapter<Prime> {
public PrimeAdapter(Context context, List<Prime> primes) {
// I am just using androids views. (android.R.id...)
super(context, android.R.layout.simple_list_item_2, primes);
}
@Override
public View getView(int position, View view, ViewGroup parent) {
/* This method will automagically get called for every item in the list.
* This is an ARRAY adapter. So it has a list of the data we passed in on
* the constructor. So by calling "this" we are accessing it like it were a list
* which it really is. */
final Prime prime = this.getItem(position);
if (view == null) {
view = LayoutInflater.from(MainActivity.this)
.inflate(android.R.layout.simple_list_item_2, null);
}
/* if you look at simple_list_item_2, you will see two textViews. text1 and text2.
* Normally you would create this view yourself, but like i said, that is not the
* reason I am here */
// Notice I am referencing android.R.id. and not R.id. That is cause I am lazy and
// didn't create my own views.
TextView tv1 = (TextView) view.findViewById(android.R.id.text1);
TextView tv2 = (TextView) view.findViewById(android.R.id.text2);
tv1.setText(String.valueOf(prime.get_primeno()));
tv2.setText(prime.getDateTimeFormatted());
//now return the view so the listView knows to show it
return view;
}
}
MyDBHandler:
Changed the queries and added two methods that will convert Prime to a ContentValues object and from Cursor to a prime.
public class MyDBHandler extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
private static final String DATABASE_NAME = "prime.db";
public static final String TABLE_PRIME = "prime";
public static final String COLUMN_ID = "_id";
public static final String COLUMN_PRIMENO = "primeno";
public static final String COLUMN_DATETIME = "datetime";
public MyDBHandler(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
String query = "CREATE TABLE " + TABLE_PRIME + "(" +
/* This must be in same order everywhere! */
COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + // ID will be index 0
COLUMN_PRIMENO + " INTEGER, " + // Prime will be index 1
COLUMN_DATETIME + " LONG);"; // Date will be index 2
db.execSQL(query);
/* Something else to note: I changed the column types. You had text for these,
* which is fine. But the object that you are storing in each of these is not
* a string. So for consistency store the object as its original class type:
* PrimeNo == integer
* Datetime == long (milliseconds)
* This also makes it so sorting is much easier */
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_PRIME);
onCreate(db);
}
/**
* You want to save the entire Prime object at once. Not bits and pieces.
*
* @param prime
*/
public void addPrime(Prime prime) {
ContentValues values = writePrime(prime);
SQLiteDatabase db = getWritableDatabase();
db.insert(TABLE_PRIME, null, values);
/* DON'T FORGET TO CLOSE YOUR DATABASE! */
db.close();
}
/**
* Again, you want to receive the entire prime object at once. Not bits.
*
* @return List of previous prime objects
*/
public List<Prime> getPrimeObjects() {
final List<Prime> primes = new ArrayList<Prime>();
final SQLiteDatabase db = getWritableDatabase();
/* Normally i would use this line of code:
final Cursor c = db.rawQuery("SELECT * FROM " + TABLE_PRIME, null);
but, you want to be sure you will get them order by DATE so you know
the first prime in the list is the last added. so I switched the query to this:
*/
final Cursor c = db.query(TABLE_PRIME,
new String[]{COLUMN_ID, COLUMN_PRIMENO, COLUMN_DATETIME},
null, null, null, null, //much null. So wow.
COLUMN_DATETIME + " DESC"); //order in descending.
/* After queried the first item will be our starting point */
c.moveToFirst();
while (c.moveToNext()) {
Prime p = buildPrime(c);
//check not null
if (p != null)
primes.add(p); //add to list
}
/* DON'T FORGET TO CLOSE YOUR DATABASE AND CURSOR! */
c.close();
db.close();
return primes;
}
/**
* Convert the Cursor object back in to a prime number
*
* @param cursor Cursor
* @return Prime
*/
private Prime buildPrime(Cursor cursor) {
final Prime prime = new Prime();
prime.set_id(cursor.getInt(0)); // id index as stated above
prime.set_primeno(cursor.getInt(1)); // prime index as stated above
prime.setDateTime(cursor.getLong(2)); // date index as stated above
return prime;
}
/**
* Convert the prime object in to ContentValues to write to DB
*
* @param prime prime
* @return ContentValues
*/
private ContentValues writePrime(Prime prime) {
ContentValues values = new ContentValues();
values.put(COLUMN_PRIMENO, prime.get_primeno()); //must insert first
values.put(COLUMN_DATETIME, prime.getDateTime()); //must insert second
return values;
}
}
Prime:
I just changed the value types. Prime's purpose is to store a prime integer. So why not make that field a integer?
public class Prime {
private static final String format = "yyyy-MM-dd HH:mm:ss";
private static final SimpleDateFormat formatter = new SimpleDateFormat(format, Locale.ENGLISH);
private int _id;
private int _primeno;
private long dateTime = 0; //this is in milliseconds. Makes it easier to manage
public Prime() { }
public Prime(int primeNumber) {
//create a new prime object with a prime already known. set the date while we are at it
this._primeno = primeNumber;
this.dateTime = System.currentTimeMillis();
}
public void set_id(int _id) {
this._id = _id;
}
public void set_primeno(int _primeno) {
this._primeno = _primeno;
}
public int get_id() {
return _id;
}
public int get_primeno() {
return _primeno;
}
public long getDateTime() {
return dateTime;
}
public String getDateTimeFormatted() {
if (dateTime == 0) {
dateTime = System.currentTimeMillis();
}
Date date = new Date(dateTime);
return formatter.format(date);
}
public void setDateTime(long dateTime) {
this.dateTime = dateTime;
}
}
相关推荐
猜您喜欢
精彩图集
