List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
// list.add(1); // Ошибка компиляции, так как list предназначен для хранения только строк.
Преимущества использования коллекций

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(1, 15);
        numbers.set(2, 25);
        numbers.remove(3);
        
        System.out.println(numbers);
    }
}

List<String> arrayList = new ArrayList<>();

arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");

String fruit = arrayList.get(0); // "Apple"

arrayList.set(1, "Grapes"); // Изменяет "Banana" на "Grapes"

arrayList.remove(0); // Удаляет "Apple"

int size = arrayList.size(); // 2

for (String fruit : arrayList) {
    System.out.println(fruit);
}

List<String> linkedList = new LinkedList<>();

linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Orange");

String fruit = linkedList.get(0); // "Apple"

linkedList.set(1, "Grapes"); // Изменяет "Banana" на "Grapes"

linkedList.remove(0); // Удаляет "Apple"

int size = linkedList.size(); // 2

for (String fruit : linkedList) {
    System.out.println(fruit);
}

Set<String> hashSet = new HashSet<>();

hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");

hashSet.remove("Banana");

boolean containsApple = hashSet.contains("Apple"); // true

int size = hashSet.size(); // 2

for (String fruit : hashSet) {
    System.out.println(fruit);
}

Set<String> treeSet = new TreeSet<>();

treeSet.add("Apple");
treeSet.add("Banana");
treeSet.add("Orange");

treeSet.remove("Banana");

boolean containsApple = treeSet.contains("Apple"); // true

int size = treeSet.size(); // 2

for (String fruit : treeSet) {
    System.out.println(fruit);
}

String first = treeSet.first(); // "Apple"
String last = treeSet.last(); // "Orange"

SortedSet<String> subSet = treeSet.subSet("Apple", "Orange");

public class ComparisonOperatorsExample {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        int z = 15;
        
        boolean result1 = (x < y) && (y < z);
        boolean result2 = (x > y) || (y < z);
        boolean result3 = !(z <= x);
        boolean result4 = (x + y) == z;
        boolean result5 = (z - x) != y;
        
        System.out.println(result1 + " " + result2 + " " + result3 + " " + result4 + " " + result5);
    }
}

Map<String, Integer> hashMap = new HashMap<>();

hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
hashMap.put("Orange", 3);

 
int value = hashMap.get("Apple"); // 1

hashMap.remove("Banana");

boolean containsKey = hashMap.containsKey("Apple"); // true

int size = hashMap.size(); // 2

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

Map<String, Integer> treeMap = new TreeMap<>();

treeMap.put("Apple", 1);
treeMap.put("Banana", 2);
treeMap.put("Orange", 3);

int value = treeMap.get("Apple"); // 1

treeMap.remove("Banana");

boolean containsKey = treeMap.containsKey("Apple"); // true

int size = treeMap.size(); // 2

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

String firstKey = treeMap.firstKey(); // "Apple"
String lastKey = treeMap.lastKey(); // "Orange"

SortedMap<String, Integer> subMap = treeMap.subMap("Apple", "Orange");

// Чтение из файла
try (FileInputStream fis = new FileInputStream("input.txt")) {
    int data;
    while ((data = fis.read()) != -1) {
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// Запись в файл
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
    String text = "Hello, World!";
    fos.write(text.getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

// Чтение из файла
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// Запись в файл
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    String text = "Hello, World!";
    bw.write(text);
} catch (IOException e) {
    e.printStackTrace();
}

import java.util.*;

public class ListExample {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));
        items.add("E");
        items.add(2, "F");
        items.remove(1);
        items.set(3, "G");
        Collections.sort(items, Collections.reverseOrder());
        
        System.out.println(items);
    }
}

File file = new File("example.txt");

boolean exists = file.exists();

boolean created = file.createNewFile();

boolean deleted = file.delete();

String name = file.getName();

String path = file.getPath();

String absolutePath = file.getAbsolutePath();

boolean isDirectory = file.isDirectory();

File[] files = file.listFiles();
for (File f : files) {
    System.out.println(f.getName());
}

File file = new File("example.txt");

// Проверка существования файла
if (!file.exists()) {
    // Создание нового файла
    try {
        boolean created = file.createNewFile();
        if (created) {
            System.out.println("File created successfully.");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// Получение информации о файле
System.out.println("File name: " + file.getName());
System.out.println("File path: " + file.getPath());
System.out.println("Absolute path: " + file.getAbsolutePath());
System.out.println("Is directory: " + file.isDirectory());

// Удаление файла
boolean deleted = file.delete();
if (deleted) {
    System.out.println("File deleted successfully.");
}

Path path = Paths.get("example.txt");

Path fileName = path.getFileName();

Path parent = path.getParent();

Path root = path.getRoot();

boolean exists = Files.exists(path);

Files.createFile(path);

Files.delete(path);

BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);

Path path = Paths.get("example.txt");

// Проверка существования файла
if (!Files.exists(path)) {
    // Создание нового файла
    try {
        Path createdFilePath = Files.createFile(path);
        System.out.println("File created at path: " + createdFilePath);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// Получение информации о файле
System.out.println("File name: " + path.getFileName());
System.out.println("Parent path: " + path.getParent());
System.out.println("Root path: " + path.getRoot());

// Удаление файла
try {
    Files.delete(path);
    System.out.println("File deleted successfully.");
} catch (IOException e) {
    e.printStackTrace();
}