Collection
List
Iterator
, Iterable
Set
Map
Collection
¶add
addAll
remove
removeAll
retainAll
clear
isEmpty
Collection
cd.¶size
contains
containsAll
toArray
singleton
iterator
class Car {}
class Rocket {}
Collection cars = new LinkedList();
Car car1 = new Car();
Rocket rocket1 = new Rocket();
cars.add(car1);
cars.add(rocket1);
System.out.println(cars.contains(car1));
System.out.println(cars.contains(rocket1));
System.out.println(cars.contains(new Rocket()));
class Car {
public void drive(){}
}
class Rocket {}
var cars = new LinkedList<Car>();
Car car1 = new Car();
Rocket rocket1 = new Rocket();
cars.add(car1);
//cars.add(rocket1);
Car car2 = cars.get(0);
car2.drive();
add
, addAll
, remove
, removeAll
¶Collection<Car> cars1 = new LinkedList<>();
cars1.add(new Car());
cars1.add(new Car());
cars1.add(new Car());
Collection<Car> cars2 = new LinkedList<>();
for(Car car : cars1){
cars2.add(car);
}
// prościej
cars2.addAll(cars1);
for(Car car : cars1){
cars2.remove(car);
}
// prościej
cars2.removeAll(cars1);
cars2.remove(cars1);
remove
, size
, isEmpty
i singleton
¶Collection<Car> cars1 = new LinkedList<>();
Car car = new Car();
cars1.add(car);
cars1.add(car);
cars1.remove(car);
cars1.size();
Collection<Car> cars1 = new LinkedList<>();
Car car = new Car();
cars1.add(car);
cars1.add(car);
cars1.removeAll(Collections.singleton(car));
cars1.isEmpty();
toArray
¶Collection<Car> cars1 = new LinkedList<>();
Car car = new Car();
cars1.add(car);
cars1.add(car);
cars1.add(new Car());
Car[] carsAsArray1 = cars1.toArray();
Object[] carsAsArray2 = cars1.toArray();
Car[] carsAsArray3 = cars1.toArray(new Car[0]);
singleton
i opcjonalne metody¶Collection<Car> oneCar = Collections.singleton(new Car());
oneCar.add(new Car());
List
¶List
¶List
get
set
indexOf
lastIndexOf
subList
Collections
sort
min
, max
Arrays
asList
List<String> words = Arrays.asList("jeden", "dwa", "trzy");
System.out.println(words.get(0));
System.out.println(words.set(0,"zero"));
System.out.println(words.get(0));
System.out.println(words.add("dwa"));
words.get(5)
List<String> words = Arrays.asList("jeden", "dwa", "jeden");
System.out.println(words.indexOf("jeden"));
System.out.println(words.lastIndexOf("jeden"));
List<String> words = new LinkedList<>();
words.add("jeden");
words.add("dwa");
words.add("trzy");
System.out.println(words);
words.subList(1,3).clear();
System.out.println(words);
words.subList(0,1).add("sześć");
System.out.println(words);
Collections
: sort
, min
, max
¶List<String> words = Arrays.asList("jeden", "dwa", "trzy");
Collections.sort(words);
words
Collections.sort(words, new Comparator<String>() {
public int compare(String a, String b) {
if(a.length() == b.length()){
return a.compareTo(b);
}
return a.length() - b.length();
}
});
System.out.println(Collections.min(words));
System.out.println(Collections.max(words));
List<Integer> numbers = new LinkedList<>();
numbers.add(3);
numbers.add(2);
numbers.add(1);
numbers.add(0);
numbers.add(0);
//numbers.remove(0);
numbers.remove(new Integer(0));
numbers
List
¶Klasa | Reprezentacja | Uwagi |
---|---|---|
ArrayList | tablica | implementacja ogólnego przeznaczenia |
LinkedList | lista dwukierunkowa | efektywne wstawianie i usuwanie |
CopyOnWriteArrayList | tablica | bezpieczna zw. na wątki |
Vector | tablica | synchronizowane metody, przestarzała |
Stack | tablica | dodaje metody push, pop, peek, przestarzała |
Iterator
¶Collection<Car> cars1 = new LinkedList<>();
Car car = new Car();
cars1.add(car);
cars1.add(car);
Iterator<Car> iterator = cars1.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
// krócej
for(Car car : cars1){
System.out.println(car);
}
Iterator<E>
¶public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
default void forEachRemaining(Consumer<? super E> action){ ... }
}
Iterable<E>
¶public interface Iterable<E> {
Iterator<E> iterator();
default Spliterator<T> spliterator();
default void forEach(Consumer<? super T> action);
}
ConcurrentModificationException
¶List<String> cars = new LinkedList<>(Arrays.asList("jeden", "dwa", "trzy"));
Iterator<String> iterator = cars.iterator();
iterator.next();
cars.remove("jeden");
iterator.next();
iterator.next();
iterator.remove();
Set
¶equals
hashCode
, implementacji interfejsu Comparable
lub akceptują "zewnętrzną" definicję komparatorax.equals(y) -> x.hashCode() == y.hashCode()
equals
i hashCode
¶class Car {
private String vin;
public Car(String vin){
this.vin = vin;
}
public boolean equals(Object other){
//...
Car that = (Car) other;
return this.vin.equals(that.vin);
}
public int hashCode(){
return this.vin.hashCode();
}
}
Car car1 = new Car("ABC");
Car car2 = new Car("ABC");
Set<Car> cars = new HashSet<>();
cars.add(car1);
cars.add(car2);
cars.size();
1
SortedSet
¶SortedSet
przechowuje elementy w sposób uporządkowanyComparable
lub aby przekazano do niego obiekt implementujący
interfejs Comparator
headSet
tailSet
subSet
first
last
import static java.lang.System.out;
SortedSet<String> numbers = new TreeSet<>(Arrays.asList("dwa", "jeden", "trzy"));
out.println(numbers.headSet("jeden"));
out.println(numbers.tailSet("jeden"));
out.println(numbers.tailSet("jeden\0"));
out.println(numbers.subSet("dwa\0","trzy"));
[dwa] [jeden, trzy] [trzy] [jeden]
Set
¶Klasa | Reprezentacja | Uporządkowanie | Ograniczenia | Wydajność dostępu | Wydajność iteracji | Uwagi |
---|---|---|---|---|---|---|
HashSet | tablica haszująca | brak | brak | O(1) | O(pojemność) | implementacja ogólnego przeznaczenia |
LinkedHashSet | powiązana tablica haszująca | kolejność wstawiania | brak | O(1) | O(n) | zachowuje kolejność |
EnumSet | pole bitowe | deklaracja | wartości enum | O(1) | O(n) | tylko wartości enum |
TreeSet | drzewo czerwono-czarne | sortowanie rosnące | porównywalność | O(log(n)) | O(n) | Comparable lub Comparator |
CopyOnWriteArraySet | tablica | kolejność wstawiania | brak | O(n) | O(n) | bezpieczna zw. na wątki |
Map
¶Map
¶put
get
remove
containsKey
containsValue
keySet
values
entrySet
put
, get
, remove
¶Map<String,Integer> numbers = new HashMap<>();
numbers.put("jeden", 1);
numbers.put("dwa", 2);
numbers.put("trzy", 3);
out.println(numbers.get("dwa"));
out.println(numbers.remove("dwa"));
out.println(numbers.get("dwa"))
2 2 null
containsKey
, containsValue
¶Map<String,Integer> numbers = new HashMap<>();
numbers.put("jeden", 1);
numbers.put("dwa", 2);
numbers.put("trzy", 3);
out.println(numbers.containsKey("jeden"));
out.println(numbers.containsKey("cztery"));
out.println(numbers.containsValue(1));
out.println(numbers.containsValue(4));
true false true false
keySet
, values
, entrySet
¶Map<String,Integer> numbers = new HashMap<>();
numbers.put("jeden", 1);
numbers.put("dwa", 2);
numbers.put("trzy", 3);
out.println(numbers.keySet());
out.println(numbers.values());
[jeden, trzy, dwa] [1, 3, 2]
for(Map.Entry<String,Integer> entry : numbers.entrySet()){
out.println("" + entry.getKey() + " : " + entry.getValue());
}
jeden : 1 trzy : 3 dwa : 2
numbers.remove("dwa");
numbers
{jeden=1, trzy=3}
numbers.keySet().remove("jeden");
numbers
{trzy=3}
SortedMap
¶Map
Comparable
lub przekazania obiektu Comparator
firstKey
lastKey
headMap
tailMap
subMap
firstKey
, lastKey
¶SortedMap<String,Integer> numbers = new TreeMap<>();
numbers.put("jeden", 1);
numbers.put("dwa", 2);
numbers.put("trzy", 3);
numbers.put("łał", 4);
out.println(numbers.firstKey());
out.println(numbers.lastKey());
dwa łał
Map
¶Klasa | Reprezentacja | klucze null | wartości null | uwagi |
---|---|---|---|---|
HashMap | tablica haszująca | tak | tak | implementacja ogólnego przeznaczenia |
ConcurrentHashMap | tablica haszująca | nie | nie | implementacja bezpieczna zw. na wątki |
ConcurrentSkipListMap | tablica haszująca | nie | nie | jw., interfejs ConcurrentNavigableMap |
EnumMap | tablica | nie | nie | klucze to wartości enum |
LinkedHashMap | tablica haszująca | tak | tak | zachowuje kolejność wstawiania |
TreeMap | drzewo czerwono-czarne | nie | tak | posortowana wg wartości kluczy |
IdentityHashMap | tablica haszująca | tak | tak | do porównywania używa == |
WeakHashMap | tablica haszująca | tak | tak | korzysta ze słabych referencji dla kluczy |
Hashtable | tablica haszująca | nie | nie | przestarzała, synchronizowane metody |
Properties | tablica haszująca | nie | nie | rozszerza Hashtable o metody klasy String |
Collections
¶binarySearch
- wyszukiwanie połówkowecheckedCollection
- operacje modyfikacji są weryfikowane w czasie wykonania, a nie kompilacjidisjoint
- sprawdza rozłączność dwóch kolekcjiemptyList
- zwraca pustą listęfill
- wypełnia listę dostarczonymi wartościamimax
- zwraca element największyrotate
- przenosi elementy w kierunku końcasynchronizedList
- metody są synchronizowane, iterowanie wymaga synchronizacji na widokuunmodifiableList
- zwraca niemodyfikowalny widok danej listy