Java for Beginner

Выполнение задачи с таймаутом
Если задача выполняется слишком долго, можно установить таймаут, после которого будет возвращён результат по умолчанию или выброшено исключение.

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class TimeoutExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000); // Имитация длительной задачи
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task completed";
        });

        try {
            String result = future.get(1, TimeUnit.SECONDS); // Устанавливаем таймаут в 1 секунду
            System.out.println(result);
        } catch (TimeoutException e) {
            System.out.println("Timeout occurred");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
В этом примере задача длится 2 секунды, но установленный таймаут — 1 секунда. В результате будет выведено сообщение о таймауте.

Цепочка зависимых асинхронных операций
Часто требуется выполнить несколько асинхронных операций последовательно, передавая результат одной задачи в другую.

import java.util.concurrent.CompletableFuture;

public class ChainedAsyncExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> "Hello")
                         .thenApplyAsync(greeting -> greeting + ", World")
                         .thenApplyAsync(message -> message + "!")
                         .thenAcceptAsync(System.out::println);

        CompletableFuture<Void> allOf = CompletableFuture.allOf(); // Для ожидания завершения всех задач
        allOf.join(); // Ожидаем завершения
    }
}
В этом примере цепочка асинхронных операций последовательно преобразует строку, добавляя к ней различные части и выводя окончательный результат на консоль.

Асинхронная обработка коллекций данных
Представим, что у нас есть список элементов, и для каждого элемента нужно выполнить асинхронную операцию, например, запрос в базу данных или внешний API.

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class AsyncProcessingExample {
    public static void main(String[] args) {
        List<String> data = Arrays.asList("One", "Two", "Three");

        List<CompletableFuture<String>> futures = data.stream()
                .map(item -> CompletableFuture.supplyAsync(() -> processItem(item)))
                .collect(Collectors.toList());

        List<String> results = futures.stream()
                .map(CompletableFuture::join) // Ожидаем завершения всех задач
                .collect(Collectors.toList());

        results.forEach(System.out::println);
    }

    private static String processItem(String item) {
        try {
            Thread.sleep(1000); // Имитация асинхронной операции
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Processed: " + item;
    }
}
Этот пример демонстрирует асинхронную обработку списка элементов, где каждая операция выполняется параллельно, а результаты собираются и выводятся после завершения всех задач.

#Java #Training #Medium #CompletableFuture

100 views14:35

Java for Beginner

Optional, особенности и внутреннее устройство

Optional — это класс, введенный в Java 8, который представляет собой контейнер для значений, который может содержать значение или быть пустым. Основная цель Optional — избежать проблем с NullPointerException (NPE), которые возникают, когда программа пытается получить доступ к объекту через ссылку, содержащую null.

Optional — это обертка, которая может содержать либо одно значение, либо быть пустой. Таким образом, вместо того чтобы возвращать null, методы могут возвращать экземпляр Optional, сигнализируя о том, что результат может отсутствовать. Это позволяет явно обрабатывать отсутствие значения и избегать NPE.

Пример использования Optional:

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> possibleValue = Optional.of("Hello, World!");
        possibleValue.ifPresent(System.out::println); // Выведет "Hello, World!"
        
        Optional<String> emptyValue = Optional.empty();
        System.out.println(emptyValue.isPresent()); // Выведет "false"
    }
}
В этом примере possibleValue содержит строку, и при наличии значения оно выводится на консоль. emptyValue является пустым, и метод isPresent() возвращает false.

Внутреннее устройство Optional

Optional реализован как финальный класс с двумя основными полями:

Value — содержит значение, если оно присутствует.
Empty — статическое поле, представляющее пустой Optional, используется в качестве синглтона.

Конструктор Optional приватен, и создание объекта осуществляется через статические фабричные методы, такие как of(), ofNullable(), и empty().

Ключевые методы класса Optional:

of(T value): Создает Optional, содержащий переданное значение. Если значение null, то выбрасывается NullPointerException.
ofNullable(T value): Создает Optional, который может быть пустым, если переданное значение null.
empty(): Возвращает пустой Optional.

Пример внутренней структуры класса Optional:

public final class Optional<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    
    private final T value;
    
    private Optional() {
        this.value = null;
    }
    
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }
    
    public static <T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
    
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
    
    // Другие методы...
}
Этот код демонстрирует, как Optional хранит значение и как реализованы его статические фабричные методы.

#Java #Training #Medium #Optional

134 views05:21

Java for Beginner

Особенности и преимущества использования Optional

Безопасность от NPE: Основное преимущество использования Optional заключается в том, что он помогает предотвратить NullPointerException путем явного указания на возможность отсутствия значения.
Читабельность кода: Использование Optional позволяет сделать код более читаемым и понятным, так как разработчик сразу видит, что метод может вернуть значение или быть пустым, а также может использовать цепочку вызовов для обработки значения.
Избежание явного использования null: Optional позволяет разработчику избегать явного использования null, что упрощает обработку отсутствующих значений и делает код более выразительным.
Поддержка функционального стиля программирования: Optional тесно интегрирован с другими функциональными возможностями Java, такими как лямбда-выражения и Stream API. Это позволяет использовать Optional в контексте функционального программирования, делая код более компактным и эффективным.

Проблемы и ограничения использования Optional

Несмотря на свои преимущества, Optional имеет некоторые ограничения:

Не для полей класса: Optional не рекомендуется использовать в качестве типа полей класса. Это связано с тем, что Optional задумывался как вспомогательный тип для возврата значений из методов, а не для хранения состояний.
Накладные расходы: Optional является объектом, и его использование может создавать дополнительные накладные расходы в плане производительности и памяти, особенно в критически важных частях кода, таких как циклы.
Проблемы совместимости: Использование Optional в публичных API может вызвать проблемы с обратной совместимостью, если код будет использоваться с более старыми версиями Java, где Optional еще не был доступен.

#Java #Training #Medium #Optional

129 views05:21

Java for Beginner

Что выведет код?

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> optional = Optional.ofNullable(getValue());
        String result = optional.orElse("default")
                                .toUpperCase();
        System.out.println(result);
    }

    private static String getValue() {
        return null;
    }
}

#Tasks

146 views08:50

Java for Beginner

Варианты ответа:

Anonymous Quiz

NoSuchElementException

9 voters121 views08:50

Java for Beginner

А вы пользовались?🤪

https://t.me/Java_for_beginner_dev

#Mems

136 views10:25

Java for Beginner

Основные методы Optional и примеры использования

isPresent() и ifPresent()
Метод isPresent() возвращает true, если значение присутствует, и false, если оно отсутствует. Этот метод полезен для проверки наличия значения перед его использованием.
Метод ifPresent() принимает Consumer и выполняет его, если значение присутствует. Этот метод позволяет избежать явных проверок null.

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> possibleValue = Optional.of("Hello, World!");
        
        // Проверка наличия значения
        if (possibleValue.isPresent()) {
            System.out.println("Value is present: " + possibleValue.get());
        }

        // Альтернативный подход
        possibleValue.ifPresent(value -> System.out.println("Value is present: " + value));
    }
}
В этом примере isPresent() используется для проверки, присутствует ли значение, а ifPresent() позволяет выполнить действие, если значение не пустое.

orElse() и orElseGet()
Метод orElse(T other) возвращает значение, если оно присутствует, или переданное значение по умолчанию, если оно отсутствует.
Метод orElseGet(Supplier<? extends T> other) схож с orElse(), но принимает лямбда-выражение, которое будет выполнено только в случае, если значение отсутствует. Это может быть полезно, если вычисление значения по умолчанию требует затратных операций.

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> emptyValue = Optional.empty();

        String result = emptyValue.orElse("Default Value");
        System.out.println(result); // Выведет "Default Value"

        result = emptyValue.orElseGet(() -> "Generated Value");
        System.out.println(result); // Выведет "Generated Value"
    }
}
В этом примере, если значение отсутствует, используется значение по умолчанию или генерируется новое.

orElseThrow()
Метод orElseThrow() выбрасывает исключение, если значение отсутствует. Это удобно, когда отсутствие значения должно приводить к ошибке.

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> emptyValue = Optional.empty();

        try {
            String result = emptyValue.orElseThrow(() -> new IllegalArgumentException("Value is absent!"));
        } catch (Exception e) {
            System.out.println(e.getMessage()); // Выведет "Value is absent!"
        }
    }
}
Этот метод позволяет обработать отсутствие значения более явным образом, выбрасывая исключение.

map() и flatMap()
Метод map() используется для преобразования значения, если оно присутствует. Он принимает функцию, которая применяется к значению, и возвращает новый Optional с преобразованным значением.
Метод flatMap() похож на map(), но используется в случаях, когда функция возвращает другой Optional. Это помогает избежать вложенности Optional<Optional<T>>.

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> possibleValue = Optional.of("Hello");

        // Преобразуем значение, добавляя ", World!"
        Optional<String> transformedValue =```java
possibleValue.map(value -> value + ", World!");

        transformedValue.ifPresent(System.out::println); // Выведет "Hello, World!"

        // Пример с flatMap
        Optional<Optional<String>> nestedOptional = Optional.of(Optional.of("Nested value"));
        Optional<String> flatMappedValue = nestedOptional.flatMap(opt -> opt);
        
        flatMappedValue.ifPresent(System.out::println); // Выведет "Nested value"
    }
}
В этом примере метод map() используется для преобразования строки, а метод flatMap() — для разворачивания вложенного Optional.

#Java #Training #Medium #Optional

128 views14:24

Java for Beginner

Примеры использования Optional в реальных задачах

Обработка возможного отсутствия значений в конфигурациях
Предположим, у нас есть система, которая загружает конфигурацию из файла. Некоторые параметры могут отсутствовать, и в этом случае нужно использовать значения по умолчанию.

import java.util.Optional;
import java.util.Properties;

public class ConfigurationExample {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.setProperty("timeout", "5000");

        Optional<String> timeout = Optional.ofNullable(properties.getProperty("timeout"));
        Optional<String> maxConnections = Optional.ofNullable(properties.getProperty("maxConnections"));

        int timeoutValue = timeout.map(Integer::parseInt).orElse(1000);
        int maxConnectionsValue = maxConnections.map(Integer::parseInt).orElse(10);

        System.out.println("Timeout: " + timeoutValue);
        System.out.println("Max Connections: " + maxConnectionsValue);
    }
}
В этом примере, если параметр maxConnections отсутствует в конфигурации, используется значение по умолчанию 10.

Безопасная работа с потенциально отсутствующими данными в базе данных
При работе с базами данных часто возникает необходимость обрабатывать случаи, когда запись не найдена. Optional может помочь сделать эту обработку более безопасной и понятной.

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class DatabaseExample {
    private static final Map<Integer, String> database = new HashMap<>();

    static {
        database.put(1, "John Doe");
        database.put(2, "Jane Doe");
    }

    public static void main(String[] args) {
        Optional<String> user1 = findUserById(1);
        Optional<String> user2 = findUserById(3);

        user1.ifPresent(System.out::println); // Выведет "John Doe"
        user2.ifPresentOrElse(
                System.out::println,
                () -> System.out.println("User not found")
        );
    }

    public static Optional<String> findUserById(int id) {
        return Optional.ofNullable(database.get(id));
    }
}
Здесь метод findUserById возвращает Optional, и если пользователь с указанным id не найден, Optional будет пустым. Это позволяет избежать NPE и явно обрабатывать отсутствие записи.

Комбинирование значений нескольких источников
Иногда требуется объединить данные из нескольких источников, где каждый источник может вернуть значение или быть пустым. Optional позволяет сделать это удобно и безопасно.

import java.util.Optional;

public class CombiningExample {
    public static void main(String[] args) {
        Optional<String> firstSource = Optional.of("Value from first source");
        Optional<String> secondSource = Optional.empty();

        String result = firstSource
                .or(() -> secondSource)
                .orElse("Default value");

        System.out.println(result); // Выведет "Value from first source"
    }
}
В этом примере, если firstSource содержит значение, оно будет использовано. Если firstSource пуст, используется значение из secondSource. Если оба источника пусты, применяется значение по умолчанию.

Отложенное вычисление значений
Используя orElseGet(), можно выполнить отложенное вычисление значения, если оно действительно необходимо.

import java.util.Optional;

public class DelayedComputationExample {
    public static void main(String[] args) {
        Optional<String> optionalValue = Optional.empty();

        String result = optionalValue.orElseGet(() -> computeValue());

        System.out.println(result); // Выведет "Computed value"
    }

    public static String computeValue() {
        System.out.println("Computing value...");
        return "Computed value";
    }
}
В этом примере метод computeValue() будет вызван только если optionalValue пусто, что экономит ресурсы, если значение не требуется.

#Java #Training #Medium #Optional

148 views14:24

Java for Beginner

Всем доброго утра!

В связи с тем что я немного занят, к сожалению сегодня скорее всего встреча отменяется!

Но мы обязательно встретимся в следующее воскресенье!!!✋

145 views06:45

Java for Beginner

Алгоритмы

В мире программирования алгоритмы играют ключевую роль. Они представляют собой четкие инструкции для решения задач и выполнения операций. Понимание особенностей алгоритмов и их сложности выполнения помогает разработчикам создавать эффективные и оптимальные программы.

Особенности Алгоритмов

Четкость и Однозначность: Каждый шаг алгоритма должен быть ясно определен без двусмысленности.
Конечность: Алгоритм должен завершаться после конечного числа шагов.
Эффективность: Алгоритм должен использовать минимальные ресурсы — время и память.
Масштабируемость: Эффективность алгоритма должна сохраняться при увеличении объема входных данных.

Наиболее распространенный способ описания сложности алгоритма — это нотация "О" (Big-O). Она позволяет определить, как количество операций, необходимых для выполнения алгоритма, увеличивается с увеличением размера входных данных. Разберем наиболее важные типы сложности.

O(1) — Константная сложность

Алгоритмы с константной сложностью выполняются за фиксированное время, независимо от размера входных данных. Примером может служить доступ к элементу массива по индексу:

int[] array = {1, 2, 3, 4, 5};
int element = array[2]; // O(1)

Сложность: O(1). Лучший, средний и худший варианты совпадают и занимают одинаковое время, так как доступ к элементу по индексу происходит мгновенно.

O(n) — Линейная сложность

Алгоритмы с линейной сложностью увеличивают время выполнения пропорционально размеру входных данных. Примером является простая итерация по массиву:

int[] array = {1, 2, 3, 4, 5};
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

Сложность: O(n).
Лучший случай: массив пустой или содержит только один элемент — минимальное время выполнения.
Средний случай: итерация по массиву среднего размера, пропорционально половине элементов.
Худший случай: полный обход массива с n элементами, требующий n операций.

O(n²) — Квадратичная сложность

Алгоритмы с квадратичной сложностью увеличивают время выполнения пропорционально квадрату размера входных данных. Примером является сортировка пузырьком:

int[] array = {5, 1, 4, 2, 8};
for (int i = 0; i < array.length - 1; i++) {
    for (int j = 0; j < array.length - i - 1; j++) {
        if (array[j] > array[j + 1]) {
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
}

Сложность: O(n²).
Лучший случай: массив уже отсортирован, минимальное количество операций (O(n)).
Средний случай: частично отсортированный массив — требует больше операций, чем в лучшем случае, но меньше, чем в худшем (O(n²)).
Худший случай: элементы массива полностью упорядочены в обратном порядке, требующий максимального количества операций (O(n²)).

O(log n) — Логарифмическая сложность

Логарифмическая сложность возникает, когда алгоритм делит задачу на части и работает только с одной из них. Примером является бинарный поиск:

int binarySearch(int[] array, int x) {
    int left = 0, right = array.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (array[mid] == x)
            return mid;
        if (array[mid] < x)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

Сложность: O(log n).
Лучший случай: элемент найден в середине массива на первой итерации (O(1)).
Средний случай: несколько итераций, но элемент найден до достижения последнего деления (O(log n)).
Худший случай: элемент отсутствует или находится на одном из концов массива, требуя полного деления массива до его минимального размера (O(log n)).

Лучший, средний и худший варианты выполнения

Лучший случай — минимальное количество операций, необходимое для завершения алгоритма. Например, если массив уже отсортирован.
Средний случай — сценарий, когда алгоритм выполняется при среднем распределении входных данных. Например, частично отсортированный массив.
Худший случай — максимальное количество операций, которое может потребоваться. Например, при обратной сортировке массива.

#Java #Training #Medium #Algorithm

129 viewsedited 05:31

Java for Beginner

Что выведет код?

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        Arrays.sort(arr);
        int result = binarySearch(arr, 5);
        System.out.println(result);
    }

    private static int binarySearch(int[] arr, int key) {
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] == key) {
                return mid;
            }
            if (arr[mid] < key) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
}

#Tasks

132 views08:48

Java for Beginner

Варианты ответа:

Anonymous Quiz

10 voters133 views08:53

Java for Beginner

Святой JVM! Что за ересь?😂

https://t.me/Java_for_beginner_dev

#Mems

129 views10:25

Java for Beginner

Основные типы и виды алгоритмов

1. Поисковые алгоритмы
Поисковые алгоритмы предназначены для нахождения элемента в структуре данных.

Линейный поиск
Линейный поиск проверяет каждый элемент структуры данных последовательно, пока не найдет нужный элемент. Этот алгоритм имеет линейную сложность O(n), так как время выполнения прямо пропорционально размеру входных данных.

int linearSearch(int[] array, int x) {
    for (int i = 0; i < array.length; i++) {
        if (array[i] == x) {
            return i;
        }
    }
    return -1;
}
Сложность: O(n). Если массив содержит n элементов, в худшем случае потребуется n операций для поиска.

Бинарный поиск
Бинарный поиск используется для поиска в отсортированном массиве. Алгоритм делит массив пополам на каждой итерации, уменьшая область поиска. Этот алгоритм имеет логарифмическую сложность O(log n), так как количество операций растет логарифмически относительно размера входных данных.

int binarySearch(int[] array, int x) {
    int left = 0, right = array.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (array[mid] == x)
            return mid;
        if (array[mid] < x)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}
Сложность: O(log n). Например, для массива из 1000 элементов потребуется примерно 10 операций в худшем случае.

2. Сортировочные алгоритмы

Сортировка данных — одна из ключевых задач в программировании. Приведем примеры с разной сложностью.

Сортировка пузырьком
Этот метод сравнивает соседние элементы и меняет их местами, пока массив не будет отсортирован. Сложность алгоритма — квадратичная O(n²), что делает его неэффективным для больших массивов.

void bubbleSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}
Сложность: O(n²). Для массива из 100 элементов потребуется до 10,000 операций в худшем случае.

Быстрая сортировка (QuickSort)
Этот алгоритм использует стратегию «разделяй и властвуй». Он выбирает опорный элемент (pivot), сортирует элементы относительно него, затем рекурсивно повторяет процесс для подмассивов. Сложность в среднем — O(n log n), но в худшем случае (если опорный элемент всегда оказывается крайним) — O(n²).

int partition(int[] array, int low, int high) {
    int pivot = array[high];
    int i = (low - 1);
    for (int j = low; j < high; j++) {
        if (array[j] < pivot) {
            i++;
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    int temp = array[i + 1];
    array[i + 1] = array[high];
    array[high] = temp;
    return i + 1;
}

void quickSort(int[] array, int low, int high) {
    if (low < high) {
        int pi = partition(array, low, high);
        quickSort(array, low, pi - 1);
        quickSort(array, pi + 1, high);
    }
}
Сложность: В среднем O(n log n), в худшем случае O(n²). Например, для массива из 1000 элементов потребуется порядка 10,000 операций в среднем случае и до 1,000,000 операций в худшем.

3. Алгоритмы работы с графами

Графы представляют собой структуру данных, состоящую из узлов и соединяющих их ребер. Алгоритмы работы с графами часто используют обходы в ширину и в глубину.

Поиск в глубину (DFS)
DFS — это рекурсивный алгоритм, который исследует узлы до максимальной глубины перед возвратом и исследованием других путей. Сложность алгоритма составляет O(V + E), где V — количество узлов, а E — количество ребер.

void DFS(int v, boolean[] visited, List<List<Integer>> adj) {
    visited[v] = true;
    System.out.print(v + " ");
    for (int x : adj.get(v)) {
        if (!visited[x]) {
            DFS(x, visited, adj);
        }
    }
}
Сложность: O(V + E). В зависимости от плотности графа, сложность может быть линейной или близкой к квадратичной.

#Java #Training #Medium #Algorithm

119 views14:25

Java for Beginner

Поиск в ширину (BFS)
BFS использует очередь и исследует граф уровнями, начиная с начального узла. Как и DFS, сложность BFS — O(V + E).

void BFS(int v, boolean[] visited, List<List<Integer>> adj) {
    Queue<Integer> queue = new LinkedList<>();
    visited[v] = true;
    queue.add(v);
    while (!queue.isEmpty()) {
        v = queue.poll();
        System.out.print(v + " ");
        for (int x : adj.get(v)) {
            if (!visited[x]) {
                visited[x] = true;
                queue.add(x);
            }
        }
    }
}
Сложность: O(V + E). В лучшем случае сложность линейная, но в плотных графах сложность может приближаться к квадратичной.

4. Динамическое программирование

Этот тип алгоритмов оптимизирует решение задачи путем хранения результатов подзадач, чтобы избежать повторных вычислений.

Задача о рюкзаке
Динамическое программирование эффективно решает задачу о рюкзаке, используя таблицу для хранения промежуточных результатов. Сложность этого алгоритма — O(nW), где n — количество предметов, а W — вместимость рюкзака.

int knapSack(int W, int[] wt, int[] val, int n) {
    int[][] K = new int[n + 1][W + 1];
    for (int i = 0; i <= n; i++) {
        for (int w = 0; w <= W; w++) {
            if (i == 0 || w == 0)
                K[i][w] = 0;
            else if (wt[i - 1] <= w)
                K[i][w] = Math.max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]);
            else
                K[i][w] = K[i - 1][w];
        }
    }
    return K[n][W];
}
Сложность: O(nW). Например, если n = 10, W = 50, потребуется 500 операций для заполнения таблицы.

#Java #Training #Medium #Algorithm

117 views14:25

Java for Beginner

Работа с датами в Java.

Работа с датами и временем — одна из важнейших задач в программировании. В Java для этого изначально были предоставлены классы Date и Calendar, которые позволяли работать с датами и временем. Однако, с течением времени, их функциональность оказалась недостаточной, и они были заменены более современными решениями, такими как java.time (включая классы LocalDate, LocalTime, LocalDateTime и другие), появившимися в Java 8.

Класс Date

Класс Date был частью Java с самой первой версии JDK 1.0 и представлял собой конкретный момент времени, измеряемый в миллисекундах с 1 января 1970 года (эта дата называется "эпоха UNIX").

import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        Date date = new Date();  // текущая дата и время
        System.out.println("Current Date: " + date);
        
        // Создание даты на основе миллисекунд от начала эпохи UNIX
        Date specificDate = new Date(1633024800000L);  // 1 октября 2021 года
        System.out.println("Specific Date: " + specificDate);
    }
}
Этот пример демонстрирует, как можно создать объект Date с текущей датой и временем, а также с определенной датой.

Недостатки класса Date

Изменяемость: Класс Date изменяем, что делает его использование в многопоточных приложениях небезопасным.
Устаревшие методы: Большинство методов класса Date устарели и заменены новыми методами в других классах (например, Calendar).
Сложность манипуляций с датами: Для выполнения операций с датами, таких как добавление дней, месяцев или лет, требуется использование других классов, например, Calendar, так как у Date нет встроенных методов для подобных операций.

Класс Calendar

Для преодоления ограничений Date, в Java 1.1 был введен класс Calendar. Этот класс предоставляет более сложные и гибкие методы для работы с датами и временем.

import java.util.Calendar;

public class CalendarExample {
    public static void main(String[] args) {
        // Получение текущей даты и времени
        Calendar calendar = Calendar.getInstance();
        System.out.println("Current Date: " + calendar.getTime());
        
        // Установка конкретной даты
        calendar.set(2021, Calendar.OCTOBER, 1);
        System.out.println("Specific Date: " + calendar.getTime());
        
        // Добавление дней к дате
        calendar.add(Calendar.DAY_OF_MONTH, 5);
        System.out.println("Date after adding 5 days: " + calendar.getTime());
        
        // Получение отдельных частей даты
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;  // месяцы начинаются с 0
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("Year: " + year + ", Month: " + month + ", Day: " + day);
    }
}
Этот пример показывает, как можно использовать Calendar для работы с датами, такими как установка конкретной даты, добавление дней и получение отдельных частей даты (год, месяц, день).

Ограничения Calendar

Изменяемость: Класс Calendar, как и Date, изменяем, что создает те же проблемы с безопасностью в многопоточных приложениях.
Сложность API: Интерфейс Calendar слишком сложен, что делает его использование затруднительным для простых задач.
Неточности в работе с временными зонами: Работа с временными зонами через Calendar может быть запутанной и неточной.

#Java #Training #Medium #Date #Calendar #Time

124 views05:21

Java for Beginner

Современные решения: java.time API

В Java 8 был представлен новый API для работы с датами и временем — java.time, который призван заменить устаревшие классы Date и Calendar. Этот API базируется на новом подходе, обеспечивающем неизменяемость и четкую работу с датами, временем и временными зонами.

Основные классы java.time

LocalDate: Представляет собой дату без учета времени и часового пояса.
LocalTime: Представляет время без учета даты и часового пояса.
LocalDateTime: Комбинация даты и времени без учета часового пояса.
ZonedDateTime: Дата и время с учетом часового пояса.
Duration и Period: Представляют собой длительность и период времени соответственно.

import java.time.LocalDate;
import java.time.LocalDateTime;

public class NewDateTimeExample {
    public static void main(String[] args) {
        // Текущая дата
        LocalDate currentDate = LocalDate.now();
        System.out.println("Current Date: " + currentDate);
        
        // Текущая дата и время
        LocalDateTime currentDateTime = LocalDateTime.now();
        System.out.println("Current Date and Time: " + currentDateTime);
        
        // Установка конкретной даты
        LocalDate specificDate = LocalDate.of(2021, 10, 1);
        System.out.println("Specific Date: " + specificDate);
        
        // Добавление дней к дате
        LocalDate dateAfterAddingDays = currentDate.plusDays(5);
        System.out.println("Date after adding 5 days: " + dateAfterAddingDays);
    }
}
Этот пример показывает, как легко и интуитивно можно использовать новые классы для работы с датами и временем.

Преимущества java.time API

Неизменяемость: Все классы в java.time неизменяемы, что делает их потокобезопасными.
Четкая работа с часовыми поясами: Классы, такие как ZonedDateTime, предоставляют четкий и интуитивный интерфейс для работы с временными зонами.
Удобный API: Новый API проще и удобнее в использовании, особенно для выполнения повседневных задач с датами и временем.
Поддержка различных календарей: java.time поддерживает не только григорианский календарь, но и другие календари, такие как японский или тайский.

#Java #Training #Medium #Date #Calendar #Time

134 views05:21

Java for Beginner

Варианты ответа:

Anonymous Quiz

Invalid date exception

18%

29-02-2028

11 voters119 views08:49

Java for Beginner

Что выведет код?

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        LocalDate date = LocalDate.of(2024, 2, 29);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        String formattedDate = date.plusYears(4).format(formatter);
        System.out.println(formattedDate);
    }
}

#Tasks

133 views08:49

Java for Beginner

А потом ты еще и устроился😂😂😂

https://t.me/Java_for_beginner_dev

#Mems

133 views10:24

Java for Beginner

Основные методы классов Date, Calendar и java.time, примеры применения

Основные методы класса Date

getTime()
Метод getTime() возвращает количество миллисекунд, прошедших с 1 января 1970 года. Это значение полезно для хранения времени в числовом формате или для сравнения дат.

import java.util.Date;

public class DateMethodsExample {
    public static void main(String[] args) {
        Date date = new Date();
        long time = date.getTime();
        System.out.println("Milliseconds since January 1, 1970: " + time);
    }
}

after() и before()
Эти методы позволяют сравнивать две даты. Метод after() возвращает true, если текущая дата позже указанной, а before() — если раньше.

import java.util.Date;

public class DateComparisonExample {
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date(date1.getTime() + 10000); // 10 секунд позже

        System.out.println("Is date1 before date2? " + date1.before(date2)); // true
        System.out.println("Is date1 after date2? " + date1.after(date2)); // false
    }
}

toString()
Метод toString() возвращает строковое представление даты. Этот метод полезен для быстрой отладки или вывода даты в формате по умолчанию.

import java.util.Dateimport java.util.Date;

public class DateToStringExample {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println("Current Date: " + date.toString());
    }
}
Этот пример показывает, как можно вывести дату в виде строки.

Основные методы класса Calendar

getInstance()
Метод getInstance() создает и возвращает объект Calendar, настроенный на текущую дату и время по умолчанию. Этот метод используется для получения базового объекта Calendar, с которым можно работать.

import java.util.Calendar;

public class CalendarGetInstanceExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        System.out.println("Current Date and Time: " + calendar.getTime());
    }
}

set()
Метод set() позволяет устанавливать дату и время в объекте Calendar. Этот метод полезен, когда нужно работать с конкретной датой или временем.

import java.util.Calendar;

public class CalendarSetExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2021, Calendar.OCTOBER, 1);
        System.out.println("Specific Date: " + calendar.getTime());
    }
}

add()
Метод add() позволяет изменять дату и время путем добавления или вычитания определенного количества дней, месяцев или лет.

import java.util.Calendar;

public class CalendarAddExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, 5);
        System.out.println("Date after adding 5 days: " + calendar.getTime());
    }
}
Этот пример показывает, как добавить 5 дней к текущей дате.

get()
Метод get() позволяет получить значение конкретного поля даты, например, год, месяц, день или час.

import java.util.Calendar;

public class CalendarGetExample {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;  // месяцы начинаются с 0
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("Year: " + year + ", Month: " + month + ", Day: " + day);
    }
}

#Java #Training #Medium #Date #Calendar #Time

105 views14:27

About

Blog

Apps

Platform