Hibernate allows to set any property to "lazy". It will then instrument the class bytecode to load these fields on demand. As you noticed, that can be pretty expensive.
One solution is to split your objects into two classes A and B where B extends A. For the simple tasks, you tell the framework to load A (with only a few fields). Then you select all those elements you need and use the IDs to load the B's. Since you use the primary key, this is pretty fast. But you will have the overhead that the fields in A will be loaded twice.
Another solution is to use HQL to load the properties you need. If you mention a column in HQL, it will be loaded, no matter what the lazy option says. But you will get a new list of objects where just those properties are set. That means you will have to merge manually.
Conclusion: There is no simple, out-of-the-box solution that makes everyone happy. The reason for this is that Java is no DB (you can't run selects against your object model in RAM) and the DB works completely different than Java when it comes to managing rows. This schism is unresolvable and all OR mappers suffer from it.
Object DBs are a bit better in this regard but they need hacks to search objects (like "all elements in a list which have the name 'John'.")
NoSQL DBs don't have the problem because each row is "key:value" and you have to emulate the concept of "column" by building the "key" in a useful way (like "User:1:name" which is the name of a User instance with the ID 1). Here, joining values is hard.
Q: Why do we have more than one database?
A: Because they all suck.
-- A. Digulla