Jython Using Java Collections Tutorial: ArrayList, HashMap, HashSet & More

Introduction

One of the biggest advantages of Jython is its ability to work directly with the Java Collections Framework (JCF). Since Jython runs on the Java Virtual Machine (JVM), you can import and use Java collection classes just as easily as Python's built-in data structures.

The Java Collections Framework provides high-performance, well-tested data structures that are widely used in enterprise software. By combining Python's readable syntax with Java's powerful collections, Jython allows developers to build scalable and maintainable applications.

In this tutorial, you'll learn:

• What the Java Collections Framework is
• Why use Java Collections in Jython
• Importing collection classes
• Using ArrayList
• Using LinkedList
• Using HashMap
• Using TreeMap
• Using HashSet
• Using TreeSet
• Working with Queue
• Iterators
• Sorting collections
• Converting between Python and Java collections
• Best practices
• Common mistakes
• Frequently asked questions

---

What Is the Java Collections Framework?

The Java Collections Framework (JCF) is a set of interfaces and classes designed to store, organize, and manipulate groups of objects efficiently.

Some of the most commonly used collection classes include:

Collection	Description
ArrayList	Dynamic array
LinkedList	Doubly linked list
HashMap	Key-value storage
TreeMap	Sorted key-value storage
HashSet	Collection of unique elements
TreeSet	Sorted unique elements
Queue	FIFO (First In, First Out) structure
Stack	LIFO (Last In, First Out) structure

---

Why Use Java Collections in Jython?

Although Jython supports Python lists, tuples, dictionaries, and sets, Java collections provide additional capabilities.

Advantages include:

• Seamless integration with Java applications.
• Compatibility with Java APIs.
• High performance in enterprise systems.
• Access to specialized collection classes.
• Mature, well-tested implementations.
• Easy interoperability with existing Java code.

---

Importing Java Collections

Import collection classes from the java.util package.

from java.util import ArrayList
from java.util import HashMap
from java.util import HashSet

You can import multiple classes at once:

from java.util import ArrayList, LinkedList, HashMap, TreeMap

---

Using ArrayList

ArrayList is one of the most commonly used collection classes.

Creating an ArrayList

from java.util import ArrayList

fruits = ArrayList()

---

Adding Elements

fruits.add("Apple")
fruits.add("Orange")
fruits.add("Banana")

print(fruits)

Output

[Apple, Orange, Banana]

---

Accessing Elements

print(fruits.get(0))
print(fruits.get(2))

Output

Apple
Banana

---

Updating Elements

fruits.set(1, "Mango")

print(fruits)

Output

[Apple, Mango, Banana]

---

Removing Elements

fruits.remove("Apple")

print(fruits)

Output

[Mango, Banana]

---

Getting the Size

print(fruits.size())

Output

2

---

Looping Through an ArrayList

for fruit in fruits:
    print(fruit)

Output

Mango
Banana

---

Using LinkedList

A LinkedList stores elements as linked nodes and is efficient for frequent insertions and deletions.

from java.util import LinkedList

numbers = LinkedList()

numbers.add(10)
numbers.add(20)
numbers.add(30)

print(numbers)

Output

[10, 20, 30]

---

Adding to the Beginning

numbers.addFirst(5)

---

Adding to the End

numbers.addLast(40)

Output

[5, 10, 20, 30, 40]

---

Using HashMap

A HashMap stores key-value pairs.

from java.util import HashMap

student = HashMap()

---

Adding Data

student.put("Name", "Alice")
student.put("Age", 22)
student.put("Major", "Computer Science")

---

Accessing Values

print(student.get("Name"))
print(student.get("Age"))

Output

Alice
22

---

Updating Values

student.put("Age", 23)

---

Removing Entries

student.remove("Major")

---

Checking Keys

print(student.containsKey("Name"))

Output

True

---

Iterating Through a HashMap

for key in student.keySet():
    print(key, student.get(key))

Example output

Name Alice
Age 23

---

Using TreeMap

TreeMap automatically keeps keys sorted.

from java.util import TreeMap

scores = TreeMap()

scores.put("John", 80)
scores.put("Alice", 95)
scores.put("Bob", 88)

Printing the map produces entries ordered by key.

---

Using HashSet

A HashSet stores unique values.

from java.util import HashSet

colors = HashSet()

colors.add("Red")
colors.add("Blue")
colors.add("Green")
colors.add("Red")

Duplicate values are ignored.

print(colors)

Possible output

[Blue, Green, Red]

(The display order is not guaranteed.)

---

Checking Membership

print(colors.contains("Blue"))

Output

True

---

Removing Items

colors.remove("Green")

---

Using TreeSet

A TreeSet stores unique elements in sorted order.

from java.util import TreeSet

numbers = TreeSet()

numbers.add(20)
numbers.add(5)
numbers.add(15)

print(numbers)

Output

[5, 15, 20]

---

Using Queue

Queues process elements in First In, First Out (FIFO) order.

from java.util import LinkedList

queue = LinkedList()

queue.offer("Task A")
queue.offer("Task B")
queue.offer("Task C")

Remove the first element:

print(queue.poll())

Output

Task A

---

Using Stack

Java provides a Stack class.

from java.util import Stack

stack = Stack()

stack.push("A")
stack.push("B")
stack.push("C")

Retrieve the top element:

print(stack.pop())

Output

C

---

Using Iterators

Java collections provide iterators for traversing elements.

iterator = fruits.iterator()

while iterator.hasNext():
    print(iterator.next())

---

Sorting Collections

Java provides the Collections utility class.

from java.util import ArrayList
from java.util import Collections

numbers = ArrayList()

numbers.add(30)
numbers.add(10)
numbers.add(20)

Collections.sort(numbers)

print(numbers)

Output

[10, 20, 30]

---

Reversing a Collection

Collections.reverse(numbers)

print(numbers)

Output

[30, 20, 10]

---

Finding the Maximum Value

print(Collections.max(numbers))

Output

30

---

Finding the Minimum Value

print(Collections.min(numbers))

Output

10

---

Converting a Python List to an ArrayList

from java.util import ArrayList

python_list = ["A", "B", "C"]

java_list = ArrayList()

for item in python_list:
    java_list.add(item)

print(java_list)

---

Converting an ArrayList to a Python List

python_copy = []

for item in java_list:
    python_copy.append(item)

print(python_copy)

Output

['A', 'B', 'C']

---

Using Java Collections with Java Methods

Because these are native Java collections, they can be passed directly to Java APIs.

from java.util import ArrayList

items = ArrayList()

items.add("Book")
items.add("Laptop")
items.add("Phone")

This makes Jython an excellent choice when integrating with existing Java applications.

---

Performance Considerations

Choose the right collection for your use case:

Collection	Best Use Case
ArrayList	Fast random access and general-purpose lists
LinkedList	Frequent insertions and removals
HashMap	Fast key-value lookups
TreeMap	Automatically sorted key-value pairs
HashSet	Fast storage of unique values
TreeSet	Sorted unique values
Queue	Task processing and messaging
Stack	Undo operations, expression evaluation

---

Best Practices

To write efficient Jython code with Java collections:

• Import only the classes you need.
• Choose the appropriate collection for your workload.
• Use descriptive variable names.
• Close related resources when collections hold external objects.
• Prefer iterating with for loops when possible.
• Avoid unnecessary conversions between Python and Java collections.
• Keep collection operations simple and readable.
• Document collection usage when working in mixed Java/Jython projects.

---

Common Mistakes

Using the Wrong Collection Type

For example, using an ArrayList when frequent insertions at the beginning are required may reduce performance. A LinkedList is often more suitable.

---

Expecting HashSet Ordering

HashSet does not preserve insertion order or sorted order.

If ordering matters, consider using a TreeSet or another ordered collection.

---

Forgetting Java Methods

Java collections use methods such as:

add()
remove()
get()
put()
contains()
size()

These differ from Python's list and dictionary methods.

---

Mixing Java and Python APIs Incorrectly

Remember that Java collections and Python collections have different method names and behaviors, even though they can often be used together.

---

Frequently Asked Questions (FAQ)

Can I use Java collections instead of Python lists?

Yes. Jython fully supports Java collections, and they are often preferred when interacting with Java libraries.

Which collection should I use?

It depends on your requirements:

• Use ArrayList for general-purpose lists.
• Use HashMap for key-value storage.
• Use HashSet for unique values.
• Use TreeMap or TreeSet when sorted order is required.

Can Java methods accept Jython collections?

Java methods typically expect Java collection types. When necessary, convert Python collections into the appropriate Java collection class.

Are Java collections faster than Python collections?

Performance depends on the specific operation and workload. Java collections are optimized for JVM applications and integrate naturally with Java APIs.

Can I sort an ArrayList?

Yes. Use the Collections.sort() method from the Java Collections Framework.

---

Conclusion

The Java Collections Framework is one of the strongest reasons to use Jython in JVM-based projects. It provides powerful, efficient, and well-tested data structures that integrate seamlessly with Java applications while allowing developers to write clean, Python-style code.

By understanding how to use ArrayList, HashMap, HashSet, TreeMap, LinkedList, queues, stacks, and collection utilities, you can build applications that take full advantage of both Python's simplicity and Java's enterprise-grade ecosystem.