因此，现在数据库设计看起来很合适，然后可以将其转换为供ROOM使用。

Question

背景：我正在尝试为Cardgame构建Deckbuilder。不同的套牌基于我想在本地安全的一个Arraylist。这意味着您可以创建您的卡座，然后让我希望它能够安全，然后创建一个新卡座，然后能够再次保存它... ->这会产生多个我想要安全的阵列列表同一班。

问题： 在知道我不仅要有一个数组列表的同时，将数组列表存储在房间中的最佳方法是什么？

从我现在所知道的是，我必须创建一个实体类，该实体类将基本上创建一个one（？）表，在该表中彼此之间必须保存数组列表？

有更好的方法吗？

奖金： 我也很想知道如何做一个基本的例子，因为这似乎是我自己很难做到的。

非常感谢！

编辑：

代码示例

所以我用代码样本中的基线实现了以下内容：

我创建了SaveDeck类，该类应该能够保存具有给定Deckname的Deck ：：-

@实体公共类SaveDeck实现了Serializable { @PrimaryKey（autoGenerate = true） private int _id;

public SaveDeck(int _id, String deckName, int cardImage, int typeImage, Integer cardCost, String cardName, Integer cardNumber) {
    this._id = _id;
    DeckName = deckName;
    CardImage = cardImage;
    TypeImage = typeImage;
    CardCost = cardCost;
    CardName = cardName;
    CardNumber = cardNumber;
}

@ColumnInfo(name = "DeckName")
private String DeckName;

@ColumnInfo(name = "CardImage")
private int CardImage;

@ColumnInfo(name = "TypeImage")
private int TypeImage;

@ColumnInfo(name = "CardCost")
private Integer CardCost;

@ColumnInfo(name = "CardName")
private String CardName;

@ColumnInfo(name = "CardNumber")
private Integer CardNumber;

}

我创建了Dao类，如下所示：：-

@道公共接口DeckBuilderDao {

@Insert(onConflict = OnConflictStrategy.IGNORE)
public long[] insertCards(SaveDeck... saveDecks);

@Insert(onConflict = OnConflictStrategy.IGNORE)
public long insertCard(SaveDeck saveDecks);

@Update
public int updateCardBaseEntries(SaveDeck... saveDecks);

@Update
public int updateCardBaseEntry(SaveDeck saveDecks);

@Delete
public int deleteCardBaseEntried(SaveDeck... saveDecks);

@Delete
public int deleteCardBaseEntry(SaveDeck saveDecks);

@Query("SELECT * FROM SaveDeck")
public SaveDeck[] getAllDecks();

//probably I do not need the getAllDecks Query. Right now I only need the following one:
@Query("SELECT * FROM SaveDeck WHERE DeckName = :NameOfDeck ORDER  BY DeckName, CardName")
public SaveDeck getOneDeck(String NameOfDeck);

}

进一步创建了数据库类：

@Database（实体= {SaveDeck.class}，版本= 1）公共抽象类SaveDecksDataBase扩展RoomDatabase { 公共抽象DeckBuilderDao deckBuilderDao（）; }

最后尝试在我各自的片段中创建设置，这是我苦苦挣扎的地方：：-

公共类review_fragment扩展了片段{

private List<TransferDeck> mTransferDeck = DataHolder.getInstance().savedDecklistTransfer;
SaveDecksDataBase mSavedDecksDB;
Cursor mCursor;

public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
//return super.onCreateView(inflater, container, savedInstanceState);
    View view = inflater.inflate(R.layout.review_fragment, container, false);

    /*Introduce Cards Recycler*/

    RecyclerView rvCards = view.findViewById(R.id.rv_review_cardlist);
    rvCards.setLayoutManager(new GridLayoutManager(getActivity(), 5));
    review_RViewAdapter_Cards adapterCards = new review_RViewAdapter_Cards(getContext(), mTransferDeck);
    rvCards.setAdapter(adapterCards);



    /*Init Room database*/
    mSavedDecksDB = Room.databaseBuilder(getActivity(),SaveDecksDataBase.class,"SavedDecksDB.db").build();
    populateDB(mTransferDeck);





    return view;
}

private void populateDB(final List<TransferDeck> mTransferDeck) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            List<SaveDeck> mSaveDeck = new ArrayList<>();
            for(int i = 0; i<mTransferDeck.size(); i++){
                mSaveDeck.add(new SaveDeck(i, "FirstSavedDeck", mTransferDeck.get(i).getCardImage() ,mTransferDeck.get(i).getTypeImage(), mTransferDeck.get(i).getCost(), mTransferDeck.get(i).getName(), mTransferDeck.get(i).getNumber()));
            }
            mSavedDecksDB.deckBuilderDao().insertCards(mSaveDeck);

        }
    }).start();
}

}

因此，现在我不知道如何正确地将新实例添加到我的类SaveDeck中。我习惯将Arraylists与构造函数一起使用。因此，我尝试了这种方法。您可以看看一下，请帮帮我吗？

Answer 1

知道房间中存储阵列列表的最佳方法是什么我想不仅只有一个Arraylist出现？

可以说，没有办法是最好的办法。

ArrayList不会仅仅出现，数据和元素结构（如果每个元素存在多个值）来自某个地方，即它们只是容器，而不是分组数据的持久容器。由于最终结果似乎是一个持久的结构化数据集，因此主要利用数据库可能会更简单。

我正在尝试为Cardgame构建Deckbuilder。不同的甲板基于我想在本地安全的一个Arraylist。

这听起来像是纸牌的基础，即游戏可用的纸牌。因此，听起来好像您想要在数据库中的 cards 卡表。

这意味着您可以创建甲板，而我希望您能够保护它，然后创建一个新的甲板，

听起来您想在数据库中找到牌组的表格，并且牌组可以有一张牌列表。那么有几张卡？ 10、20、3000？好吧，如果您利用了Realtional Database Manager的关系功能（SQLite以及Room（因为后者是SQLite的抽象层））。因此，很有可能是所谓的映射表（同一事物的引用，关系和其他名称）。

主要存储关系，该关系由可以标识关系的一部分的列和可以标识关系的另一列组成。将其应用到您的情况下，DECK与许多卡有关系，那么CARD可能会出现在许多DECK中。这是映射表所满足的许多关系。因此，您可能需要一个映射表。

作为进一步解释的基础，我们假设我们正在谈论纸牌（黑桃王牌，红桃皇后等）。

因此，我们需要三个表：一个 Card 表，一个 Deck 表以及一个将卡映射到甲板的表（因此反之亦然），一个 Card_Deck_Map < / strong>表。

卡表保持简单，卡名只有一列。甲板表将在甲板名称中有一列为了有效，将使用作为特殊列 rowid 的别名的标识符进行映射。因此，上述表格中的每个表格都会有一个额外的列，称为 _id （将该列命名为 _id ，这对于Android可能是有益的）。

假设您不希望重复使用卡名或卡组名称，因此将施加一个UNIQUE约束，不允许重复使用这些名称。

简而言之，这就是SQL中的样子（这最终是大多数数据存储，操作和提取完成的方式）：-

-- Delete the tables if they exist (just in case) DROP TABLE IF EXISTS card_deck_map; DROP TABLE IF EXISTS card; DROP TABLE IF EXISTS deck; -- Create the tables CREATE TABLE IF NOT EXISTS card (_id INTEGER PRIMARY KEY, cardname UNIQUE); CREATE TABLE IF NOT EXISTS deck (_id INTEGER PRIMARY KEY, deckname UNIQUE); CREATE TABLE IF NOT EXISTS card_deck_map ( card_reference INTEGER REFERENCES card(_id), deck_reference INTEGER REFERENCES deck(_id), PRIMARY KEY(card_reference,deck_reference) ); -- Add 3 cards to the card table INSERT INTO card (cardname) VALUES ('CARD001'),('CARD002'),('CARD003'); -- Add 3 decks to the deck table INSERT INTO deck (deckname) VALUES ('DECK001'),('DECK002'); -- Create some mapping entries (aka put some cards into each deck) INSERT INTO card_deck_map VALUES (1,2), -- _id value for CARD001 should be 1, _id value for DECK002 should be 2 (3,2), -- CARD003 is in DECK002 (2,1), -- CARD002 is in DECK001 (1,1) -- CARD001 is also in DECK002 ; -- Have a look at what we have (ignore the id values they mean little to the user) SELECT deckname, cardname FROM deck JOIN card_deck_map ON deck._id = deck_reference JOIN card ON card_deck_map.card_reference = card._id ORDER BY deckname, cardname ;

以上内容的输出为：-

因此，现在数据库设计看起来很合适，然后可以将其转换为供ROOM使用。

首先是3个实体Defining data using Room entities

Card.java

：-

@Entity (indices = {@Index(value = {"cardname"}, unique = true)}) public class Card { @PrimaryKey(autoGenerate = true) public long _id; @ColumnInfo(name = "cardname") public String cardname; }

Deck.java

：-

@Entity(indices = {@Index(value = "deckname", unique = true)}) public class Deck { @PrimaryKey(autoGenerate = true) public long _id; @ColumnInfo(name = "deckname") public String deckname; }

Card_Deck_Map.java

：-

@Entity( primaryKeys = {"card_reference","deck_reference"}, foreignKeys = { @ForeignKey(entity = Card.class,parentColumns = "_id",childColumns = "card_reference"), @ForeignKey(entity = Deck.class, parentColumns = "_id",childColumns = "deck_reference")} ) public class Card_Deck_Map { @ColumnInfo (name="card_reference") public long card_reference; @ColumnInfo(name="deck_reference") public long deck_reference; }

现在，您需要数据访问对象定义Accessing data using Room DAOs

DeckBuildeDao

：-

@道公共接口DeckBuilderDao {

@Insert(onConflict = OnConflictStrategy.IGNORE) public long[] insertCards(Card... cards); @Insert(onConflict = OnConflictStrategy.IGNORE) public long insertCard(Card card); @Update public int updateCardBaseEntries(Card... cards); @Update public int updateCardBaseEntry(Card card); @Delete public int deleteCardBaseEntried(Card... cards); @Delete public int deleteCardBaseEntry(Card card); @Query("SELECT * FROM card") public Card[] getAllCards(); @Query("SELECT * FROM card WHERE _id = :id") public Card getACard(long id); @Insert(onConflict = OnConflictStrategy.IGNORE) public long[] insertDecks(Deck... decks); @Insert(onConflict = OnConflictStrategy.IGNORE) public long insertDeck(Deck deck); @Update public int updateDeckEntries(Deck... decks); @Update public int updateDeckEntry(Deck deck); @Delete public int deleteDeckEntries(Deck... decks); @Delete public int deleteDeckEntry(Deck deck); @Query("SELECT * FROM deck") public int getAllDecks(); @Query("SELECT * FROM deck WHERE _id = :id") public Deck getADeck(long id); @Insert(onConflict = OnConflictStrategy.IGNORE) public long[] addCardDeckEntries(Card_Deck_Map... cardDeckMaps); @Insert(onConflict = OnConflictStrategy.IGNORE) public long addCardDeckEntry(Card_Deck_Map cardDeckMap); @Query("SELECT Deck._id,Card.cardname, Deck.deckname " + "FROM deck " + "JOIN card_deck_map ON deck._id = card_deck_map.deck_reference " + "JOIN card ON card_deck_map.card_reference = card._id " + "ORDER BY deckname, cardname") public Cursor getAllDecksWithCards();

}

将实体和DAO绑定在一起的数据库类

DeckBuilderDatabase.java

：-

@Database(entities = {Card.class, Deck.class, Card_Deck_Map.class}, version = 1) public abstract class DeckBuilderDatabase extends RoomDatabase { public abstract DeckBuilderDao deckBuilderDao(); }

现在是使用数据库的活动。

在这个工作示例中；

该数据库将根据一副纸牌（不包括小丑）的扑克牌基数填充2个Decks（Deck001和Deck002）。

纸牌的名称将像黑桃A（红桃2）一样。

卡片组将装有一些卡片（映射）

带有所有52张卡片的Deck002。

带有3张卡片的Deck001。

卡片组和卡片组将从数据库中提取，并用于填充ListView。

MainActivity.java

public class MainActivity extends AppCompatActivity { public static final String[] SUITS = new String[]{"Spades","Hearts","Clubs","Diamons"}; public static final int CARDS_IN_A_SUIT = 13; DeckBuilderDatabase mDBDB; SimpleCursorAdapter mSCA; ListView mDecks_and_Cards_List; Cursor mCursor; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mDecks_and_Cards_List = this.findViewById(R.id.decksandcards); mDBDB = Room.databaseBuilder(this,DeckBuilderDatabase.class,"deckbuilder.db").build(); populateDB(); } /** * Populate the DB with some data, extract the data in the DB and setup the ListView */ private void populateDB() { new Thread(new Runnable() { @Override public void run() { Card_Deck_Map currentcdm = new Card_Deck_Map(); Deck[] decks_to_add = new Deck[]{new Deck(), new Deck()}; decks_to_add[0].deckname = "DECK001"; decks_to_add[1].deckname= "DECK002"; mDBDB.deckBuilderDao().insertDecks(decks_to_add); // Build Card base pack of 52 (no Jokers) Card[] cardstoadd = new Card[CARDS_IN_A_SUIT * SUITS.length]; int counter = 0; for (int suit = 0; suit < SUITS.length; suit++) { for (int cardval = 0; cardval < CARDS_IN_A_SUIT; cardval++) { Card thiscard = new Card(); String thiscardname = generateCardValueDescription(cardval+1,suit); thiscard.cardname = thiscardname; cardstoadd[counter++] = thiscard; } } mDBDB.deckBuilderDao().insertCards(cardstoadd); // Populate the decks with cards Deck002 has full pack of 52 Deck001 has 3 cards Card_Deck_Map[] mappings = new Card_Deck_Map[55]; for (int cardid = 1; cardid < 53; cardid++) { Card_Deck_Map cdm = new Card_Deck_Map(); cdm.deck_reference = 2; cdm.card_reference = cardid; mappings[cardid-1] = cdm; } Card_Deck_Map cdm53 = new Card_Deck_Map(); cdm53.card_reference = 19; cdm53.deck_reference = 1; mappings[52] = cdm53; Card_Deck_Map cdm54 = new Card_Deck_Map(); cdm54.card_reference = 10; cdm54.deck_reference = 1; mappings[53] = cdm54; Card_Deck_Map cdm55 = new Card_Deck_Map(); cdm55.card_reference = 23; cdm55.deck_reference = 1; mappings[54] = cdm55; mDBDB.deckBuilderDao().addCardDeckEntries(mappings); // Get the Decks and cards in the decks mCursor = mDBDB.deckBuilderDao().getAllDecksWithCards(); setupOrRefeshListView(); } }).start(); } /** * Handles the ListView (also write data to the log for debugging) */ private void setupOrRefeshListView() { int rowcount = mCursor.getCount(); Log.d("ROWS","Number of rows in the Cursor is " + String.valueOf(rowcount)); while (mCursor.moveToNext()) { Log.d( "ROWS", "Row " + String.valueOf(mCursor.getPosition()) + " Has a deck called " + mCursor.getString(mCursor.getColumnIndex("deckname")) + " and a card called " + mCursor.getString(mCursor.getColumnIndex("cardname")) ); } if (mSCA == null) { mSCA = new SimpleCursorAdapter( this, android.R.layout.simple_list_item_2, mCursor, new String[]{ "deckname", "cardname"}, new int[]{ android.R.id.text1, android.R.id.text2}, 0 ); mDecks_and_Cards_List.setAdapter(mSCA); } else { mSCA.swapCursor(mCursor); } } /** * Converts numeric cardvalue (1-13) and suit to a decriptive name * @param cardvalue * @param suit * @return */ private String generateCardValueDescription(int cardvalue, int suit) { String rv; switch (cardvalue) { case 1: rv = "Ace of " + SUITS[suit]; break; case 11: rv = "Jack of " + SUITS[suit]; break; case 12: rv = "Queen of " + SUITS[suit]; break; case 13: rv = "King of " + SUITS[suit]; break; default: rv = String.valueOf(cardvalue) + " of " + SUITS[suit]; } return rv; } }

结果迷你应用程序：-

在会议室数据库中保存多个数组列表-最佳方法是什么？

1 个答案:

因此，现在数据库设计看起来很合适，然后可以将其转换为供ROOM使用。

Card.java

Deck.java

Card_Deck_Map.java

DeckBuildeDao

DeckBuilderDatabase.java

MainActivity.java

结果迷你应用程序：-