import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@SpringBootApplication
public class Main151124_2 {
    public static void main(String[] args) {
        SpringApplication.run(Main151124_2.class, args);
    }

    @Bean
    public CommandLineRunner demo(JdbcTemplate jdbcTemplate) {
        return args -> {
            jdbcTemplate.execute("CREATE TABLE users (id INT AUTO_INCREMENT, name VARCHAR(255), age INT, PRIMARY KEY (id))");
            jdbcTemplate.update("INSERT INTO users (name, age) VALUES (?, ?)", "Alice", 30);
            jdbcTemplate.update("INSERT INTO users (name, age) VALUES (?, ?)", "Bob", 25);
            List<String> names = jdbcTemplate.query("SELECT name FROM users WHERE age > ?", new Object[]{20}, new NameRowMapper());
            names.forEach(System.out::println);
        };
    }

    static class NameRowMapper implements RowMapper<String> {
        @Override
        public String mapRow(ResultSet rs, int rowNum) throws SQLException {
            return rs.getString("name");
        }
    }
}

Alice
Bob

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    // Getters and Setters
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }
}

import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.saveUser(user);
    }
}

public class Task181124_1 {
    public static void main(String[] args) {
        int result = 0;
        for (int i = 0; i < 3; i++) {  // Внешний цикл
            for (int j = i; j < 3; j++) {  // Внутренний цикл
                result += i + j;
            }
        }
        System.out.println(result);
    }
}

import jakarta.persistence.Entity;

@Entity
public class Product {
    private Long id;
    private String name;
    private Double price;
}
Если класс помечен как @Entity, но таблица не указана явно, Spring автоматически использует название класса для создания таблицы в базе данных.

import jakarta.persistence.Entity;
import jakarta.persistence.Table;

@Entity
@Table(name = "products", schema = "shop")
public class Product {
    private Long id;
    private String name;
    private Double price;
}
Если имя таблицы не указано, то по умолчанию используется имя класса.

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    private Long id;

    private String name;
    private Double price;
}

import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

import jakarta.persistence.Column;

@Column(name = "product_name", nullable = false, unique = true)
private String name;

@Transient
private String tempData;

import jakarta.persistence.*;

@Entity
@Table(name = "products")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_name", nullable = false)
    private String name;

    private Double price;

    @Transient
    private String tempData;

    // Getters and Setters
}

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class User {

    @Id
    private Long id;

    @Column(name = "username", nullable = false, unique = true, length = 50)
    private String username;

    @Column(name = "email", nullable = false, unique = true)
    private String email;

    @Column(name = "age", columnDefinition = "INTEGER DEFAULT 18")
    private int age;

    // Геттеры и сеттеры
}

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private double price;

    // Геттеры и сеттеры
}
Здесь id будет автоматически генерироваться базой данных.

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;

@Entity
public class Order {

    @Id
    private Long id;

    private String description;

    @ManyToOne
    private Customer customer;

    // Геттеры и сеттеры
}
Эта аннотация указывает, что множество заказов (Order) могут быть связаны с одним клиентом (Customer).

public class Counter {
    private int count = 0;

    public void increment() {
        count++; // Неатомарная операция: чтение, увеличение, запись
    }

    public int getCount() {
        return count;
    }
}

public class RaceConditionExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Ожидаем 2000, но результат может быть меньше
    }
}

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock1...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock2) {
                System.out.println("Thread 1: Acquired lock2.");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock2...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock1) {
                System.out.println("Thread 2: Acquired lock1.");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample demo = new DeadlockExample();

        Thread t1 = new Thread(demo::method1);
        Thread t2 = new Thread(demo::method2);

        t1.start();
        t2.start();
    }
}

public class LivelockExample {

    static class Worker {
        private boolean active = true;

        public synchronized void work(Worker other) {
            while (active) {
                System.out.println(Thread.currentThread().getName() + " is working...");
                try { Thread.sleep(50); } catch (InterruptedException e) {}

                if (other.isActive()) {
                    System.out.println(Thread.currentThread().getName() + " is waiting...");
                    continue;
                }
                break;
            }
        }

        public synchronized void setActive(boolean active) {
            this.active = active;
        }

        public synchronized boolean isActive() {
            return active;
        }
    }

    public static void main(String[] args) {
        Worker w1 = new Worker();
        Worker w2 = new Worker();

        Thread t1 = new Thread(() -> w1.work(w2), "Worker 1");
        Thread t2 = new Thread(() -> w2.work(w1), "Worker 2");

        t1.start();
        t2.start();
    }
}

private static volatile boolean running = true;

public void run() {
    while (running) {
        // Выполняем задачу
    }
}

class Parent { }

class Child extends Parent { }

public class Task191124_1 {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = new Child();
        Child obj3 = new Child();

        System.out.println(obj1 instanceof Parent);
        System.out.println(obj2 instanceof Child);
        System.out.println(obj3 instanceof Parent);
        System.out.println(obj1 instanceof Child);
    }
}

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne
    @JoinColumn(name = "profile_id", referencedColumnName = "id")
    private Profile profile;
}

@Entity
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String bio;
}
Здесь связь между User и Profile устанавливается через внешний ключ profile_id.

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses;
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students;
}
Связь осуществляется через промежуточную таблицу student_course.

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne
    @JoinColumn(name = "customer_id", nullable = false)
    private Customer customer;
}
Здесь customer_id в таблице Order будет внешним ключом, ссылающимся на таблицу Customer.

@Entity
public class Document {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Lob
    private String content; // Для больших текстов

    @Lob
    private byte[] fileData; // Для бинарных данных
}

public interface UserRepository extends JpaRepository<User, Long> {

    @Query("SELECT u FROM User u WHERE u.email = :email")
    User findByEmail(@Param("email") String email);
}

public interface UserRepository extends JpaRepository<User, Long> {

    @Modifying
    @Query("UPDATE User u SET u.name = :name WHERE u.id = :id")
    void updateUserName(@Param("id") Long id, @Param("name") String name);
}

@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
public class AppConfig {
}

@Embeddable
public class Address {
    private String street;
    private String city;
}

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Embedded
    private Address address;
}

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ElementCollection
    private List<String> tags;
}

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Vehicle {
    @Id
    private Long id;
}

@Entity
public class Car extends Vehicle {
    private int seatingCapacity;
}

@Entity
@Cacheable
public class Product {
    @Id
    private Long id;
    private String name;
}

@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT u FROM User u WHERE u.id = :id")
User findForUpdate(@Param("id") Long id);

@Entity
@EntityListeners(AuditListener.class)
public class Order {
    @Id
    private Long id;
}

@SQLInsert(sql = "INSERT INTO user_audit (id, username) VALUES (?, ?)")
@SQLDelete(sql = "DELETE FROM user_audit WHERE id = ?")
@Entity
public class UserAudit {
    @Id
    private Long id;
}

import java.math.BigDecimal;

public class Task201124_1 {
    public static void main(String[] args) {
        BigDecimal num1 = new BigDecimal("3");
        BigDecimal num2 = new BigDecimal("2");
        
        BigDecimal sum = num1.add(num2);
        BigDecimal product = num1.multiply(num2);
        
        BigDecimal result = sum.subtract(product).divide(new BigDecimal("1.0"), 10, BigDecimal.ROUND_HALF_UP);
        
        System.out.println(result);
    }
}