<project>
    <groupId>com.example</groupId>
    <artifactId>aggregator</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    <modules>
        <module>module-api</module>
        <module>module-core</module>
        <module>module-web</module>
    </modules>
</project>

<project>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.3.20</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <modules>
        <module>module-api</module>
        <module>module-core</module>
    </modules>
</project>

<project>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent</artifactId>
        <version>1.0.0</version>
    </parent>
    <artifactId>module-api</artifactId>
</project>

<!-- parent POM -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- module POM -->
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
</dependencies>

project-root/
├── pom.xml (parent/aggregator)
├── module-api/
│   └── pom.xml
├── module-core/
│   └── pom.xml
├── module-impl/
│   └── pom.xml
├── module-web/
│   └── pom.xml

<!-- module-core POM -->
<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>module-api</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

<!-- module-web POM -->
<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>module-core</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

dependencyManagement: Централизуйте версии зависимостей в родительском POM:<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.20</version>
        </dependency>
    </dependencies>
</dependencyManagement>

pluginManagement: Аналогично управляйте версиями плагинов:<pluginManagement>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.10.1</version>
            <configuration>
                <source>${java.version}</source>
                <target>${java.version}</target>
            </configuration>
        </plugin>
    </plugins>
</pluginManagement>

Настройте <distributionManagement> в родительском POM:<distributionManagement>
    <repository>
        <id>nexus</id>
        <url>https://nexus.example.com/repository/maven-releases/</url>
    </repository>
</distributionManagement>

import java.util.function.Function;

public class Task090725 {
    public static void main(String[] args) {
        Function<Integer, Integer> f = x -> x * 2;
        Function<Integer, Integer> g = x -> x + 3;
        
        System.out.println(f.compose(g).apply(5));
        System.out.println(f.andThen(g).apply(5));
    }
}

операнд1 оператор операнд2

оператор операнд

int sum = 5 + 3; // Арифметический оператор +
boolean isEqual = (a == b); // Оператор сравнения ==

+: Сложение (или конкатенация строк).
-: Вычитание.
*: Умножение.
/: Деление (целочисленное для int, с плавающей точкой для double).
%: Остаток от деления.
++: Инкремент (увеличивает значение на 1).
--: Декремент (уменьшает значение на 1).

int a = 10, b = 3;
int sum = a + b; // 13
int difference = a - b; // 7
int product = a * b; // 30
int quotient = a / b; // 3 (целочисленное деление)
int remainder = a % b; // 1
a++; // a = 11
b--; // b = 2

&&: Логическое И (короткого замыкания, вычисляет второй операнд только если первый true).
||: Логическое ИЛИ (короткого замыкания, вычисляет второй операнд только если первый false).
!: Логическое НЕ (инвертирует значение).

boolean x = true, y = false;
boolean andResult = x && y; // false
boolean orResult = x || y; // true
boolean notResult = !x; // false

==: Равенство (для примитивов — сравнение значений, для объектов — сравнение ссылок).
!=: Неравенство.
>: Больше.
<: Меньше.
>=: Больше или равно.
<=: Меньше или равно.

int a = 5, b = 3;
boolean isEqual = (a == b); // false
boolean isGreater = (a > b); // true
boolean isNotEqual = (a != b); // true

условие ? выражение1 : выражение2

Возвращает выражение1, если условие true, или выражение2, если false.

int a = 10, b = 5;
int max = (a > b) ? a : b; // max = 10

&: Побитовое И.
|: Побитовое ИЛИ.
^: Побитовое исключающее ИЛИ (XOR).
~: Побитовое НЕ (инверсия).
<<: Сдвиг влево.
>>: Сдвиг вправо (с сохранением знака).
>>>: Сдвиг вправо с заполнением нулями.

int a = 5; // 0101 в двоичной системе
int b = 3; // 0011 в двоичной системе
int and = a & b; // 0001 (1)
int or = a | b; // 0111 (7)
int xor = a ^ b; // 0110 (6)
int not = ~a; // 1010 (инверсия, результат -6)
int leftShift = a << 1; // 1010 (10)
int rightShift = a >> 1; // 0010 (2)

=: Простое присваивание.
+=, -=, *=, /=, %=: Составное присваивание (выполняют операцию и присваивают результат).
&=, |=, ^=, <<=, >>=, >>>=: Битовые составные присваивания.

int a = 10;
a += 5; // a = 15
a *= 2; // a = 30
a &= 7; // a = 6 (битовое И)

instanceof: Проверяет, является ли объект экземпляром определенного класса или интерфейса.

String str = "Hello";
boolean isString = str instanceof String; // true

double result = (double) 5 / 2; // 2.5
int evenCheck = number % 2; // 0 для четных чисел

if (user != null && user.isActive()) {
    // Безопасный доступ благодаря короткому замыканию
}

String str1 = "Hello";
String str2 = "Hello";
boolean equal = str1.equals(str2); // true

String status = (age >= 18) ? "Взрослый" : "Ребенок";

int flags = 0b0001; // Флаг 1 включен
flags |= 0b0010; // Включить флаг 2

double x = 10.5;
x *= 2; // x = 21.0

if (obj instanceof List) {
    List<?> list = (List<?>) obj;
}

int a = 5 + 3;

iconst_5
iconst_3
iadd
istore a

String result = "Hello" + "World";

JVM создает объект StringBuilder, выполняет конкатенацию и вызывает toString, создавая новый объект String в куче.

String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // Неэффективно, создает много объектов
}

Лучший вариант:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

int result = (a * b + c) / d; // Лучше разбить на части
int temp = a * b;
int result = (temp + c) / d;

public class Task100725 {
    public static void main(String[] args) {
        int x = 1;
        int y = x++ + x++ + ++x;
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}