Firestore查询结果中随机选取指定数量数据的实现方案咨询

Hey there! Let's figure out how to grab 3 random items from your 20-item Firestore query results for your RecyclerView. I've got a couple of solid, easy-to-implement approaches for you:

1. First, Get Your Full Firestore Result Set #

Start with your standard Firestore query to fetch the 20 items you need. Once you get the QuerySnapshot, convert it into a list of your data model (replace Item with your actual model class):

FirebaseFirestore db = FirebaseFirestore.getInstance();
db.collection("your_target_collection")
  // Add your query filters here (e.g., whereEqualTo, orderBy)
  .limit(20) // Restrict to 20 results as you mentioned
  .get()
  .addOnSuccessListener(querySnapshot -> {
      // Convert Firestore documents to your model objects
      List<Item> fullItemList = querySnapshot.toObjects(Item.class);
      
      // Grab 3 random items from the full list
      List<Item> randomSelectedItems = getRandomItems(fullItemList, 3);
      
      // Pass the random items to your RecyclerView adapter
      yourRecyclerViewAdapter.updateItems(randomSelectedItems);
      yourRecyclerViewAdapter.notifyDataSetChanged();
  })
  .addOnFailureListener(e -> {
      // Handle query errors (log them or show a user message)
      Log.e("FirestoreError", "Failed to fetch items", e);
  });

2. Implement the Random Selection Logic #

Choose one of these two methods to pick your random items—both work great, pick the one that fits your use case:

Method 1: Shuffle & Slice (Simple & Intuitive) #

This method creates a copy of your full list, shuffles it, then takes the first 3 items. It's super straightforward and avoids duplicate selections:

private List<Item> getRandomItems(List<Item> sourceList, int numberOfItemsToPick) {
    // If we have fewer items than requested, return all of them
    if (sourceList.size() <= numberOfItemsToPick) {
        return new ArrayList<>(sourceList);
    }
    
    // Create a copy to avoid modifying the original list
    List<Item> shuffledList = new ArrayList<>(sourceList);
    Collections.shuffle(shuffledList);
    
    // Return the first N random items
    return shuffledList.subList(0, numberOfItemsToPick);
}

Method 2: Random Indices with Duplicate Prevention #

If you don't want to shuffle the entire list (for performance with very large datasets, though 20 items is trivial), you can generate unique random indices instead:

private List<Item> getRandomItems(List<Item> sourceList, int numberOfItemsToPick) {
    if (sourceList.size() <= numberOfItemsToPick) {
        return new ArrayList<>(sourceList);
    }
    
    List<Item> randomItems = new ArrayList<>();
    Random randomGenerator = new Random();
    Set<Integer> pickedIndices = new HashSet<>();
    
    // Keep picking until we have the desired number of unique items
    while (pickedIndices.size() < numberOfItemsToPick) {
        int randomIndex = randomGenerator.nextInt(sourceList.size());
        // Only add if the index hasn't been picked before
        if (pickedIndices.add(randomIndex)) {
            randomItems.add(sourceList.get(randomIndex));
        }
    }
    
    return randomItems;
}

Quick Tips #

• Always use a copy of the original list: Modifying the original result set could cause unexpected issues if you need to reuse it later.
• Handle edge cases: The checks for sourceList.size() <= numberOfItemsToPick prevent index out-of-bounds errors if Firestore returns fewer than 3 items.
• Fresh randomness every time: Each time you run the query and call getRandomItems(), you'll get a new set of random items—perfect for your use case!

内容的提问来源于stack exchange，提问作者Spike Johnson