import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;

public class SignatureExample {
    public static void main(String[] args) throws Exception {
        // Генерация пары ключей
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        keyPairGen.initialize(2048);
        KeyPair keyPair = keyPairGen.generateKeyPair();

        // Получение ключей
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();

        // Создание подписи
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);
        String data = "Hello, Java Crypto!";
        signature.update(data.getBytes());
        byte[] digitalSignature = signature.sign();
        System.out.println("Digital Signature (Base64): " + Base64.getEncoder().encodeToString(digitalSignature));

        // Проверка подписи
        signature.initVerify(publicKey);
        signature.update(data.getBytes());
        boolean isVerified = signature.verify(digitalSignature);
        System.out.println("Signature Verified: " + isVerified);
    }
}

import java.security.MessageDigest;
import java.util.Base64;

public class MessageDigestExample {
    public static void main(String[] args) throws Exception {
        // Создание MessageDigest для SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        // Хэширование данных
        String data = "Hello, Java Crypto!";
        byte[] hash = digest.digest(data.getBytes());

        // Вывод хэша в Base64
        System.out.println("Hash (Base64): " + Base64.getEncoder().encodeToString(hash));
    }
}

M = 77, a = 97, n = 110

M     a     n
01001101 01100001 01101110

010011 010110 000101 101110

010011 → T
010110 → W
000101 → F
101110 → u
Результат кодирования: "TWFu"

"Ma" (2 байта) → TWE=
"M" (1 байт) → TQ==

import java.util.Base64;

public class Base64Example {
    public static void main(String[] args) {
        String originalString = "Hello, Java Crypto API!";
        String encodedString = Base64.getEncoder().encodeToString(originalString.getBytes());
        System.out.println("Encoded: " + encodedString);
    }
}

Encoded: SGVsbG8sIEphdmEgQ3J5cHRvIEFQISTCoA==

import java.util.Base64;

public class Base64DecodeExample {
    public static void main(String[] args) {
        String encodedString = "SGVsbG8sIEphdmEgQ3J5cHRvIEFQISTCoA==";
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded: " + decodedString);
    }
}

Decoded: Hello, Java Crypto API!

Base64.Encoder encoder = Base64.getEncoder();
Base64.Decoder decoder = Base64.getDecoder();

String encoded = encoder.encodeToString("Test".getBytes());
String decoded = new String(decoder.decode(encoded));

System.out.println("Encoded: " + encoded);
System.out.println("Decoded: " + decoded);

Base64.Encoder urlEncoder = Base64.getUrlEncoder();
Base64.Decoder urlDecoder = Base64.getUrlDecoder();

String encoded = urlEncoder.encodeToString("https://example.com".getBytes());
String decoded = new String(urlDecoder.decode(encoded));

System.out.println("Encoded URL: " + encoded);
System.out.println("Decoded URL: " + decoded);

Base64.Encoder mimeEncoder = Base64.getMimeEncoder();
Base64.Decoder mimeDecoder = Base64.getMimeDecoder();

String encoded = mimeEncoder.encodeToString("Example MIME data".getBytes());
String decoded = new String(mimeDecoder.decode(encoded));

System.out.println("Encoded MIME: " + encoded);
System.out.println("Decoded MIME: " + decoded);

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..." />

byte[] encryptedData = encryptAES("Hello".getBytes(), secretKey);
String base64Encoded = Base64.getEncoder().encodeToString(encryptedData);

String auth = "user:password";
String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes());
String header = "Authorization: Basic " + encodedAuth;

public class Task260225 {
    public static void main(String[] args) {
        String value = "10";
        print(value);
        print((byte) value);
        print((Object) value);
    }

    public static void print(String x) {
        System.out.println("String");
    }

    public static void print(byte x) {
        System.out.println("byte");
    }

    public static void print(Object x) {
        System.out.println("Object");
    }
}

import javax.net.ssl.HttpsURLConnection;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;

public class HttpsClient {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://www.example.com");
        HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

        // Проверка сертификата
        conn.setSSLSocketFactory((SSLSocketFactory) SSLSocketFactory.getDefault());
        conn.setRequestMethod("GET");

        // Чтение ответа
        BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            System.out.println(inputLine);
        }
        in.close();
    }
}

import javax.net.ssl.*;
import java.io.FileInputStream;
import java.security.KeyStore;

public class CustomSSLContext {
    public static void main(String[] args) throws Exception {
        String keystorePath = "keystore.jks"; // Файл хранилища ключей
        String keystorePassword = "password";

        // Загрузка ключей
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(new FileInputStream(keystorePath), keystorePassword.toCharArray());

        // Инициализация KeyManagerFactory
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, keystorePassword.toCharArray());

        // Создание SSL-контекста
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), null, null);

        // Использование SSLContext
        SSLSocketFactory socketFactory = sslContext.getSocketFactory();
        HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);
    }
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class HmacExample {
    public static void main(String[] args) throws Exception {
        String message = "Hello, Java Crypto API!";
        String secretKey = "my_secret_key";

        // Создание HMAC SHA-256
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA256");
        mac.init(keySpec);

        // Вычисление HMAC
        byte[] hmacBytes = mac.doFinal(message.getBytes());
        String hmacBase64 = Base64.getEncoder().encodeToString(hmacBytes);

        System.out.println("HMAC (Base64): " + hmacBase64);
    }
}

HMAC (Base64): q8phcxg9DpPpMfKkczjRkkv6OiOBv2YoTbYJ46qZaYc=

public static boolean verifyHmac(String message, String receivedHmac, String secretKey) throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA256");
    mac.init(keySpec);
    
    // Вычисляем HMAC заново
    byte[] hmacBytes = mac.doFinal(message.getBytes());
    String computedHmac = Base64.getEncoder().encodeToString(hmacBytes);

    // Сравниваем с полученным HMAC
    return computedHmac.equals(receivedHmac);
}

Редактировать
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

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

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

User user = new User();
user.setUsername("john_doe");
user.setEmail("john@example.com");
userRepository.save(user);

INSERT INTO users (username, email) VALUES ('john_doe', 'john@example.com');

user.setEmail("new_email@example.com");
userRepository.save(user);

UPDATE users SET email = 'new_email@example.com' WHERE id = 1;
Разработчик не пишет SQL-код вручную — ORM делает это автоматически.

User user = new User(); // Transient
user.setUsername("Alice");

entityManager.persist(user); // Managed
entityManager.detach(user); // Detached
entityManager.remove(user); // Removed

User user1 = entityManager.find(User.class, 1); // SQL выполняется
User user2 = entityManager.find(User.class, 1); // Берётся из кеша
Первый запрос загрузит данные из БД, второй возьмёт их из памяти.

@Entity
public class User {
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders;
}

User user = userRepository.findById(1L).get();
List<Order> orders = user.getOrders(); // SQL-запрос будет только здесь, если Lazy

public class Task270225 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        
        (list).removeFirst();
        list.remove(1);

        System.out.println(list);
    }
}