Java | Фишки и трюки

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;

public class WalkFileTreeExample {
    public static void main(String[] args) throws IOException {
        Path startPath = Paths.get("example_directory");

        Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("Deleting file: " + file);
                Files.delete(file); // Удаляем файл
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("Deleting directory: " + dir);
                Files.delete(dir); // Удаляем директорию после удаления её содержимого
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            sleep(2000);
            return "Результат задачи 1";
        });

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            sleep(3000);
            return "Результат задачи 2";
        });

        CompletableFuture<String> combined = task1.thenCombine(task2, (result1, result2) -> result1 + " & " + result2);

        // Ожидаем завершения всех задач и получаем общий результат
        combined.thenAccept(result -> {
            long endTime = System.currentTimeMillis();
            System.out.println("Общий результат: " + result);
            System.out.println("Время выполнения: " + (endTime - startTime) + " мс");
        });

        combined.join(); // Дождёмся завершения наших задач
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}

import java.util.*;

public class Quest {
    private static Random rnd = new Random();
    public static void main(String[] args) {
        StringBuffer word = null;
        switch(rnd.nextInt(2)) {
            case 1: word = new StringBuffer('P');
            case 2: word = new StringBuffer('G');
            default: word = new StringBuffer('M');
        }
        word.append('a');
        word.append('i');
        word.append('n');
        System.out.println(word);
    }
}

 java
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<>();
        
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        
        System.out.println(map); // {1=One, 2=Two, 3=Three}
    }
}

 java
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUExample {
    public static void main(String[] args) {
        Map<Integer, String> map = new LinkedHashMap<>(16, 0.75f, true);

        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");

        map.get(2); // Используем ключ 2
        System.out.println(map); // {1=One, 3=Three, 2=Two}
    }
}

@Override
protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
    return size() > 3; // Удалять записи, если их больше 3
}

 java
import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        WeakHashMap<Object, String> map = new WeakHashMap<>();

        Object key = new Object();
        map.put(key, "Value");

        System.out.println("Before GC: " + map); // Ключ и значение есть

        key = null; // Убираем сильную ссылку на объект
        System.gc(); // Вызываем сборку мусора

        System.out.println("After GC: " + map); // Ключ и значение исчезли
    }
}

 java
import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityHashMapExample {
    public static void main(String[] args) {
        Map<String, String> map = new IdentityHashMap<>();

        String key1 = new String("key");
        String key2 = new String("key");

        map.put(key1, "Value 1");
        map.put(key2, "Value 2");

        System.out.println(map); // Выведет обе пары: {key=Value 1, key=Value 2}
    }
}

import java.util.EnumMap;

enum Action {
    START, STOP, PAUSE
}

public class EnumMapExample {
    public static void main(String[] args) {
        EnumMap<Action, Runnable> actionMap = new EnumMap<>(Action.class);

        // Определяем поведение для каждого значения Enum
        actionMap.put(Action.START, () -> System.out.println("Starting the process..."));
        actionMap.put(Action.STOP, () -> System.out.println("Stopping the process..."));
        actionMap.put(Action.PAUSE, () -> System.out.println("Pausing the process..."));

        // Пример вызова
        Action currentAction = Action.START;
        actionMap.get(currentAction).run();
    }
}

public class Quest {
    public static void greet() {
        System.out.println("Hello world!");
    }

    public static void main(String[] args) {
        Quest q = null;
        q.greet();
    }
}

public class Quest {
    public static void main(String[] args) {
        String s = null;
        System.out.println(s instanceof String);
    }
}

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class SpELExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        // Пример вычисления простого выражения
        String expression = "'Hello, Spring SpEL!'.toUpperCase()";
        String result = parser.parseExpression(expression).getValue(String.class);

        System.out.println(result); // Вывод: HELLO, SPRING SPEL!
    }
}

@Component
public class MyBean {
    @Value("#{T(java.lang.Math).random() * 100}")
    private double randomValue;

    @Value("#{systemProperties['user.name']}")
    private String userName;

    public void printValues() {
        System.out.println("Random Value: " + randomValue);
        System.out.println("User Name: " + userName);
    }
}

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.util.Arrays;
import java.util.List;

public class CollectionExample {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Фильтрация списка
        List<Integer> filteredNumbers = (List<Integer>) parser.parseExpression(
                "#numbers.?[#this > 2]").getValue(new StandardEvaluationContext(), numbers);

        System.out.println(filteredNumbers); // Вывод: [3, 4, 5]
    }
}