"items list" or "item list"

English is not my native language and I can't understand how to write the specified samples right. When you say something what aggregates plural object such as "collection of stamps" you can say alternatively: "stamps collection", am I right? If you will say "stamp collection" it will mean some "collection" which is a single "stamp".

But often I see classes with names like "ItemList" - doesn't it mean that such class is a list which is an item of something else? Such sample is more flaring:

class ItemList: List<Item>

Isn't it have to be so?:

class ItemsList: List<Item>

Why is it rarely written so? Or is it some programming languages naming convention? Or just proper english sentences? :)

In English, a "collection of stamps" is a "stamp collection". (At best, "stamps collection" would be understood).

In programming, I'm not entirely sure why, but we¹ do sometimes use the form "StampsCollection".

It may be because we try to use more precise and logical lingo than traditional English provides; we start with the name "Item", pluralise it to "Items", then be precise by stating that our collection of "Items" is a "List" rather than an "Array" or some other implementation.

You're likely to see both variants, though, and it doesn't really matter.

Certainly, neither in English nor in programming would ItemsList imply a list of collections of Items, at least not to most people.

---

¹ ... for some value of "we". Naming choices are, of course, down to personal preference. However, I've personally seen this as a tendency.

I find ItemList much more descriptive. It is a list of objects of type Item.

On the other hand, if you had a collection of Item objects, you could call it Items, and ItemsList would designate a list of collections.

class Items: List<Item>

And more readable, in general I do a typedef

// C++98
typedef List<Item> Items;

// since C++11 you can write it also this way, and I prefer this:
using Items = List<Item>;

It is often good practice (clean code) to think about a more specialized class that hides the List. "Prefer composition by aggregation over inheritance" is common idiom in OOP (quoting Sutter/Alexandrescu: C++ Coding Standards: 101 Rules, Guidelines, and Best Practices)

Encapsulation of a collection is most of the time a good practice which lowers the complexity of calling code:

class Encapsulation
{
    Items m_items;
    public: 
    void AddItem(const Item&);
    void RemoveAllItems();
    // ... all the functions about managing the List that would be otherwise boilerplate code spread all over your codebase
}