Brownies-Collections BigList is an in-memory Java list for large collections that still fit in heap memory. It stores elements in fixed-size blocks organized through a tree, so edits need not move the entire collection; copy-on-write sharing can also make list copies efficient. It is not the same as fastutil’s separate BigList API, which is explicitly designed for 64-bit indices.
What Brownies-Collections BigList is—and is not
The Brownies-Collections project describes BigList as a list optimized for large numbers of elements. It presents BigList and GapList as implementations of standard list interfaces intended as drop-in replacements, and also provides primitive-specialized lists such as IntBigList. The project is Apache-2.0 licensed. Its repository lists Maven coordinate org.magicwerk.brownies:brownies-collections:0.9.24 and Gradle declaration api 'org.magicwerk.brownies:brownies-collections:0.9.24'; treat that version as the repository’s stated version, not a guarantee of the latest release. Brownies-Collections repository
The name is ambiguous. Brownies-Collections BigList is a block-based collection implementation. fastutil separately defines it.unimi.dsi.fastutil.BigList<K> as a list with 64-bit indices; its API uses long-oriented operations for indexing, size, searches, iterators, and sublists. If your central requirement is addressing positions beyond ordinary int indexing, the fastutil interface is the BigList relevant to that requirement—not the Brownies-Collections class. fastutil BigList source
How its block-and-tree design works
Instead of keeping all elements in one contiguous backing array, BigList divides them among fixed-size blocks and maintains references to those blocks in a tree. Blocks can be split or merged as the list grows, shrinks, or is edited. The structure limits how much element data must move for many edits, although it does not make every operation constant-time or remove the cost of traversing the tree.
Free tools Windows power users keep installed
One-click scans. No signup required.
A 2014 design article describes blocks backed by GapList, reference counts for sharing, a tree of blocks, and a cache for the current block. It reports a default block size of 1,000 and says instances could choose a block size. These details are historical documentation; the article does not establish that current releases retain every implementation detail. Thomas Mauch, “BigList: a Scalable High-Performance List for Java,” DZone, November 3, 2014
Where BigList can help—and where it may not
Large lists with edits
For a large in-memory list that must grow or shrink, a block structure can avoid shifting one huge contiguous range on every relevant change. The historical design article identifies single-element and bulk operations, predictable overhead, and avoiding large block copies during growth or shrinkage as design goals. Those goals are not a substitute for measuring the operations your application actually performs.
Rank #2
Sequential and nearby access
Walking through nearby elements can take advantage of locality and the implementation’s current-block cache. In the 2014 benchmark discussion, access to nearby elements performed better than totally random access.
Totally random access
With scattered index lookups, the tree must be traversed repeatedly to find the appropriate block. The DZone article describes random access as the moderate case in its tests. That is a workload warning, not a current comparative ranking: no newer independent benchmark is established here.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Copies and snapshots
Brownies-Collections documents copy-on-write for BigList. This can make a copy efficient because blocks can be shared instead of duplicating all element storage immediately. Sharing also means mutation behavior deserves deliberate review: understand when a write causes a shared block to be copied, and assess the memory and latency effects for your copy-and-mutate pattern. The available project description does not establish a thread-safety guarantee, so do not infer concurrent safety from copy-on-write alone.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.BigList versus IntBigList memory
BigList stores references to objects. For integer data represented as BigList<Integer>, the list holds references to boxed values; IntBigList stores primitive integers in primitive arrays and avoids that boxing-and-reference representation. This can materially reduce memory use for primitive data.
Rank #4
The following figures are the DZone article’s historical measurements for one million elements, not current JVM estimates or a reproduction. The article’s test environment details beyond 32-bit versus 64-bit are not stated in the cited summary.
| Representation and test | 64-bit reported memory | 32-bit reported memory |
|---|---|---|
| BigList with one million null elements | 8,544,254 bytes (DZone, 2014) | 4,298,466 bytes (DZone, 2014) |
| ArrayList with one million null elements | 9,723,964 bytes (DZone, 2014) | not stated (DZone, 2014) |
| BigList<Integer> with one million integer values | 28,544,234 bytes (DZone, 2014) | 16,298,454 bytes (DZone, 2014) |
| IntBigList with one million integer values | 4,570,432 bytes (DZone, 2014) | 4,534,840 bytes (DZone, 2014) |
In that article’s environment, IntBigList used about 14% of the memory reported for BigList<Integer> on the 64-bit test and about 25% on the 32-bit test. Actual memory use depends on JVM, data, and implementation version; use these historical results to understand the object-versus-primitive trade-off, not to size a modern deployment. DZone benchmark and design article
Quick Recap
Best Value
Choosing between BigList, IntBigList, ArrayList, and fastutil
| Option | Index and API consideration | Access and edit consideration | Memory and copying consideration |
|---|---|---|---|
| Brownies-Collections BigList | Presented by its project as a standard-list-interface implementation; the cited material does not establish 64-bit indexing. | Block tree is intended to limit data moved for edits; repeated random lookups traverse the tree. | Supports copy-on-write sharing; stores object references. |
| Brownies-Collections IntBigList | Primitive-specialized list; confirm the API that fits your code. | Block-based family; benchmark your access and edit pattern. | Primitive storage can avoid the overhead of boxed Integer values; the 2014 benchmark shows this distinction. |
| Java ArrayList | Standard java.util.List implementation. |
Contiguous-array behavior can suit workloads where its access profile fits; resizing or interior edits can entail moving elements. | Stores references to objects; the cited historical null-list measurement was close to BigList’s, but is not a current comparison. |
| fastutil BigList | Separate fastutil interface with 64-bit indices and long-oriented methods. | Evaluate its own implementation and workload characteristics; Brownies-Collections benchmark results do not apply to it. | Not interchangeable with Brownies-Collections BigList; memory and copy figures are not established by the cited sources. |
How to decide whether it fits
- Choose Brownies-Collections BigList when the collection must remain in heap memory and you want a block-based list rather than one large contiguous element array.
- Consider IntBigList when the elements are primitive integers and reducing boxed-object overhead matters.
- Benchmark before switching if your application performs frequent scattered random lookups, depends on a particular mutation pattern, or needs predictable latency.
- Check the API and index-width requirement explicitly. Do not assume a class called BigList supports 64-bit indices; that property belongs to the separate fastutil interface documented above.
- Review the project version, compatibility with your Java version, and any production support requirements directly. The cited material does not provide a current compatibility matrix or production-support policy.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
