# java.util

***

**1. Creating an ArrayList**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");
```

**2. Creating a HashSet**

```java
Set<String> set = new HashSet<>();
set.add("Hello");
set.add("World");
```

**3. Creating a HashMap**

```java
Map<String, String> map = new HashMap<>();
map.put("Hello", "World");
```

**4. Iterating over a List**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

for (String str : list) {
  System.out.println(str);
}
```

**5. Iterating over a Set**

```java
Set<String> set = new HashSet<>();
set.add("Hello");
set.add("World");

for (String str : set) {
  System.out.println(str);
}
```

**6. Iterating over a Map**

```java
Map<String, String> map = new HashMap<>();
map.put("Hello", "World");

for (Map.Entry<String, String> entry : map.entrySet()) {
  System.out.println(entry.getKey() + " = " + entry.getValue());
}
```

**7. Sorting a List**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

Collections.sort(list);
```

**8. Searching for an Element in a List**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

int index = list.indexOf("Hello");
```

**9. Removing an Element from a List**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

list.remove("Hello");
```

**10. Checking if a List Contains an Element**

```java
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

boolean contains = list.contains("Hello");
```

**11. Creating a Queue**

```java
Queue<String> queue = new LinkedList<>();
queue.offer("Hello");
queue.offer("World");
```

**12. Removing an Element from a Queue**

```java
Queue<String> queue = new LinkedList<>();
queue.offer("Hello");
queue.offer("World");

String removed = queue.poll();
```

**13. Creating a Stack**

```java
Stack<String> stack = new Stack<>();
stack.push("Hello");
stack.push("World");
```

**14. Removing an Element from a Stack**

```java
Stack<String> stack = new Stack<>();
stack.push("Hello");
stack.push("World");

String popped = stack.pop();
```

**15. Creating a TreeMap**

```java
Map<String, String> map = new TreeMap<>();
map.put("Hello", "World");
```

**16. Creating a LinkedHashMap**

```java
Map<String, String> map = new LinkedHashMap<>();
map.put("Hello", "World");
```

**17. Creating a WeakHashMap**

```java
Map<String, String> map = new WeakHashMap<>();
map.put("Hello", "World");
```

**18. Creating a ConcurrentHashMap**

```java
Map<String, String> map = new ConcurrentHashMap<>();
map.put("Hello", "World");
```

**19. Creating a CopyOnWriteArrayList**

```java
List<String> list = new CopyOnWriteArrayList<>();
list.add("Hello");
list.add("World");
```

**20. Creating a CopyOnWriteArraySet**

```java
Set<String> set = new CopyOnWriteArraySet<>();
set.add("Hello");
set.add("World");
```

**21. Creating a BlockingQueue**

```java
BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
queue.put("Hello");
queue.put("World");
```

**22. Creating a SynchronousQueue**

```java
BlockingQueue<String> queue = new SynchronousQueue<>();
queue.put("Hello");
```

**23. Creating a PriorityBlockingQueue**

```java
BlockingQueue<String> queue = new PriorityBlockingQueue<>();
queue.put("Hello");
queue.put("World");
```

**24. Creating a Deque**

```java
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("Hello");
deque.addLast("World");
```

**25. Creating a NavigableSet**

```java
NavigableSet<String> set = new TreeSet<>();
set.add("Hello");
set.add("World");
```

**26. Creating a SortedMap**

```java
SortedMap<String, String> map = new TreeMap<>();
map.put("Hello", "World");
```

**27. Creating a HashSet using a Builder**

```java
Set<String> set = Set.of("Hello", "World");
```

**28. Creating a HashMap using a Builder**

```java
Map<String, String> map = Map.of("Hello", "World");
```

**29. Creating a List using a Builder**

```java
List<String> list = List.of("Hello", "World");
```

**30. Creating a StringJoiner**

```java
StringJoiner joiner = new StringJoiner(", ");
joiner.add("Hello");
joiner.add("World");
```

**31. Creating a Base64 Encoder**

```java
Base64.Encoder encoder = Base64.getEncoder();
String encoded = encoder.encodeToString("Hello World".getBytes());
```

**32. Creating a Base64 Decoder**

```java
Base64.Decoder decoder = Base64.getDecoder();
String decoded = new String(decoder.decode(encoded));
```

**33. Creating a UUID**

```java
UUID uuid = UUID.randomUUID();
```

**34. Creating a Random Number Generator**

```java
Random random = new Random();
int randomNumber = random.nextInt();
```

**35. Creating a Date**

```java
Date date = new Date();
```

**36. Creating a Calendar**

```java
Calendar calendar = Calendar.getInstance();
```

**37. Creating a NumberFormat**

```java
NumberFormat numberFormat = NumberFormat.getInstance();
String formattedNumber = numberFormat.format(12345.67);
```

**38. Creating a DateFormat**

```java
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
String formattedDate = dateFormat.format(new Date());
```

**39. Creating a TimeZone**

```java
TimeZone timeZone = TimeZone.getTimeZone("America/New_York");
```

**40. Creating a Locale**

```java
Locale locale = new Locale("en", "US");
```

**41. Creating a ResourceBundle**

```java
ResourceBundle resourceBundle = ResourceBundle.getBundle("messages");
```

**42. Creating a Properties**

```java
Properties properties = new Properties();
properties.put("name", "John Doe");
```

**43. Creating a Preferences**

```java
Preferences preferences = Preferences.userRoot();
preferences.put("name", "John Doe");
```

**44. Creating a Logger**

```java
Logger logger = Logger.getLogger("MyLogger");
logger.info("Hello World");
```

**45. Creating a Formatter**

```java
Formatter formatter = new SimpleFormatter();
logger.setFormatter(formatter);
```

**46. Creating a Handler**

```java
Handler handler = new ConsoleHandler();
logger.addHandler(handler);
```

**47. Creating a Timer**

```java
Timer timer = new Timer();
timer.schedule(new MyTimerTask(), 1000, 1000);
```

**48. Creating a TimerTask**

```java
TimerTask timerTask = new MyTimerTask();
timer.schedule(timerTask, 1000, 1000);
```

**49. Creating a Thread**

```java
Thread thread = new Thread(new MyRunnable());
thread.start();
```

**50. Creating a Runnable**

```java
Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
```