ArrayList
Acesso por índice em O(1), inserção/remoção no meio em O(n).
List<Integer> list = []
List<Integer> list = [1, 2, 3]
list.add(4) // adiciona no final
list.add(0, 99) // adiciona no índice
list.remove(0) // remove por índice
list.indexOf(2) // retorna o índice do valor 2
list.contains(2)
list.sort()
// Iterar
for (int x : list) { }
list.each { println it }
list.eachWithIndex { val, i -> }
// Transformar
list.collect { it * 2 } // map
list.findAll { it > 2 } // filter
list.sum()
list.min()
list.max()
list.count { it > 2 }
// Sublista
list.subList(1, 3) // índices [1, 3)Mapas
HashMap
Sem ordem garantida.
Map<String, Integer> map = [:] // mapa vazio
Map<String, Integer> map = [a: 1, b: 2] // com valores iniciais
map["c"] = 3 // ou map.put("c", 3)
map["a"] // ou map.get("a")
map.remove("a")
map.containsKey("b")
map.containsValue(2)
map.keySet() // retorna as keys como um Set
map.values() // retorna os values como uma Collection
// Frequência de caracteres.
map.put(key, map.getOrDefault(key, 0) + 1)
// Iterar
map.each { k, v -> println "$k = $v" }
map.entrySet().each { println "${it.key} = ${it.value}" }LinkedHashMap
Igual ao HashMap mas mantém a ordem de inserção.
Map<String, Integer> map = new LinkedHashMap<>()TreeMap
Mantém as chaves em ordem natural. Acesso em O(log n).
TreeMap<Integer, String> map = new TreeMap<>()
map.firstKey() // menor chave
map.lastKey() // maior chave
map.floorKey(5) // maior chave <= 5
map.ceilingKey(5) // menor chave >= 5
map.headMap(5) // chaves < 5
map.tailMap(5) // chaves >= 5Conjuntos
HashSet
Inserção, remoção e busca em O(1). Sem duplicatas e sem ordem garantida.
Set<Integer> set = new HashSet<>()
Set<Integer> set = [1, 2, 3] as HashSet
set.add(4)
set.remove(1)
set.contains(2)
// Operações de conjunto
set1.intersect(set2) // interseção
set1.plus(set2) // união
set1.minus(set2) // diferençaTreeSet
Mantém os elementos em ordem. Inserção, remoção e busca em O(log n).
TreeSet<Integer> set = new TreeSet<>()
set.first() // menor elemento
set.last() // maior elemento
set.floor(5) // maior elemento <= 5
set.ceiling(5) // menor elemento >= 5
set.headSet(5) // elementos < 5
set.tailSet(5) // elementos >= 5
set.pollFirst() // remove e retorna o menor
set.pollLast() // remove e retorna o maiorFilas
Queue (FIFO)
Queue<Integer> queue = new LinkedList<>()
// ou
Queue<Integer> queue = new ArrayDeque<>()
queue.offer(1) // enfileira (não lança exceção se cheio)
queue.poll() // desenfileira (retorna null se vazia)
queue.peek() // vê o primeiro sem removerDeque (Double-Ended Queue)
Permite inserção e remoção em ambas as extremidades. Serve como pilha e fila.
Deque<Integer> deque = new ArrayDeque<>()
deque.offerFirst(1) // insere no início
deque.offerLast(2) // insere no final
deque.peekFirst() // vê o primeiro
deque.peekLast() // vê o último
deque.pollFirst() // remove o primeiro
deque.pollLast() // remove o últimoPriorityQueue (Heap)
Acesso ao menor (ou maior) elemento em O(1), inserção e remoção em O(log n).
// Min-heap (padrão)
PriorityQueue<Integer> minHeap = new PriorityQueue<>()
// Max-heap
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder())
minHeap.offer(3)
minHeap.offer(1)
minHeap.offer(2)
minHeap.peek() // 1 (menor)
minHeap.poll() // remove e retorna 1Pilhas
Usar Deque ao invés de Stack (mais eficiente).
Deque<Integer> stack = new ArrayDeque<>()
stack.push(1) // ou offerFirst — empilha
stack.push(2)
stack.peek() // 2 — vê o topo sem remover
stack.pop() // 2 — desempilha
stack.isEmpty()
stack.size()Strings
String s = "hello alice"
s[1..2] // substring
s.indexOf("l")
s.contains("ell")
s.startsWith("he")
s.endsWith("lo")
s.toUpperCase()
s.toLowerCase()
s.trim()
s.replace("l", "r")
s.split("") // array de caracteres (como Strings)
s.toCharArray() // array de chars
// Construir string a partir de chars
new String(charArray)
charArray.join("")
"42".toInteger()
42.toString()
// Concatenação
StringBuilder sb = new StringBuilder()
sb.append("hello")
sb.append(" world")
sb.insert(0, ">> ")
sb.deleteCharAt(0)
sb.reverse()
sb.setCharAt(0, 'H')