Перепиши код так чтобы если в изначальном файле пере буквами шли символы которые не шифруются то ключ не тратился на них
package VigenereCipher;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class VigenereCipher {
    public static String vigenereEncrypt(String text, String key, String alphabet) {
        StringBuilder encrypted = new StringBuilder();
        List<Integer> keyIndices = new ArrayList<>();
        int n = alphabet.length();

        for (char k : key.toCharArray()) {
            int index = alphabet.indexOf(Character.toLowerCase(k));
            if (index >= 0) {
                keyIndices.add(index);
            }
        }
        int keyLength = keyIndices.size();

        if (keyLength == 0) {
            System.out.println("Ключ не содержит символов из выбранного алфавита.");
            return null;
        }

        for (int i = 0; i < text.length(); i++) {
            char charAt = text.charAt(i);
            if (alphabet.indexOf(Character.toLowerCase(charAt)) >= 0) {
                boolean isUpper = Character.isUpperCase(charAt);
                int idx = alphabet.indexOf(Character.toLowerCase(charAt));
                int shift = keyIndices.get(i % keyLength);
                int encryptedIdx = (idx + shift) % n;
                char encryptedChar = alphabet.charAt(encryptedIdx);
                encrypted.append(isUpper ? Character.toUpperCase(encryptedChar) : encryptedChar);
            } else {
                encrypted.append(charAt);
            }
        }
        return encrypted.toString();
    }

    public static String vigenereDecrypt(String text, String key, String alphabet) {
        StringBuilder decrypted = new StringBuilder();
        List<Integer> keyIndices = new ArrayList<>();
        int n = alphabet.length();

        for (char k : key.toCharArray()) {
            int index = alphabet.indexOf(Character.toLowerCase(k));
            if (index >= 0) {
                keyIndices.add(index);
            }
        }
        int keyLength = keyIndices.size();

        if (keyLength == 0) {
            System.out.println("Ключ не содержит символов из выбранного алфавита.");
            return null;
        }

        for (int i = 0; i < text.length(); i++) {
            char charAt = text.charAt(i);
            if (alphabet.indexOf(Character.toLowerCase(charAt)) >= 0) {
                boolean isUpper = Character.isUpperCase(charAt);
                int idx = alphabet.indexOf(Character.toLowerCase(charAt));
                int shift = keyIndices.get(i % keyLength);
                int decryptedIdx = (idx - shift + n) % n; // Добавляем n для обработки отрицательных индексов
                char decryptedChar = alphabet.charAt(decryptedIdx);
                decrypted.append(isUpper ? Character.toUpperCase(decryptedChar) : decryptedChar);
            } else {
                decrypted.append(charAt);
            }
        }
        return decrypted.toString();
    }

    public static String combineKeys(String key1, String key2, String alphabet) {
        List<Integer> key1Indices = new ArrayList<>();
        List<Integer> key2Indices = new ArrayList<>();
        int n = alphabet.length();

        for (char k : key1.toCharArray()) {
            int index = alphabet.indexOf(Character.toLowerCase(k));
            if (index >= 0) {
                key1Indices.add(index);
            }
        }
        for (char k : key2.toCharArray()) {
            int index = alphabet.indexOf(Character.toLowerCase(k));
            if (index >= 0) {
                key2Indices.add(index);
            }
        }

        int key1Length = key1Indices.size();
        int key2Length = key2Indices.size();

        if (key1Length == 0 || key2Length == 0) {
            System.out.println("Один из ключей не содержит символов из выбранного алфавита.");
            return null;
        }

        int lcm = lcm(key1Length, key2Length);
        StringBuilder combinedKey = new StringBuilder();

        for (int i = 0; i < lcm; i++) {
            int shift1 = key1Indices.get(i % key1Length);
            int shift2 = key2Indices.get(i % key2Length);
            int combinedShift = (shift1 + shift2) % n;
            combinedKey.append(alphabet.charAt(combinedShift));
        }
        return combinedKey.toString();
    }

    private static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    private static int lcm(int a, int b) {
        return a * (b / gcd(a, b));
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String alphabet;

        System.out.println("Выберите алфавит:");
        System.out.println("1. Русский");
        System.out.println("2. Английский");
        System.out.print("Введите номер алфавита (1 или 2): ");
        String choice = scanner.nextLine();

        if (choice.equals("1")) {
            alphabet = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя";
        } else if (choice.equals("2")) {
            alphabet = "abcdefghijklmnopqrstuvwxyz";
        } else {
            System.out.println("Неверный выбор алфавита.");
            return;
        }

        System.out.print("Введите путь к файлу с исходным текстом (.txt): ");
        String filePath = scanner.nextLine();
        String originalText = readFile(filePath);

        System.out.print("Введите путь к файлу с первым ключом K1 (.txt): ");
        String key1Path = scanner.nextLine();
        String key1 = readFile(key1Path).trim();

        System.out.print("Введите путь к файлу со вторым ключом K2 (.txt): ");
        String key2Path = scanner.nextLine();
        String key2 = readFile(key2Path).trim();

        String ciphertext1 = vigenereEncrypt(originalText, key1, alphabet);
        if (ciphertext1 == null) return;

        String ciphertext2 = vigenereEncrypt(ciphertext1, key2, alphabet);
        if (ciphertext2 == null) return;

        String combinedKey = combineKeys(key1, key2, alphabet);
        if (combinedKey == null) return;

        String ciphertextCombined = vigenereEncrypt(originalText, combinedKey, alphabet);
        if (ciphertextCombined == null) return;

        String key1Filtered = filterKey(key1, alphabet);
        String key2Filtered = filterKey(key2, alphabet);

        System.out.println("Первый ключ:");
        System.out.println(key1Filtered);
        System.out.println("Шифротекст после первого шифрования:");
        System.out.println(ciphertext1);
        System.out.println("\nВторой ключ:");
        System.out.println(key2Filtered);
        System.out.println("Шифротекст после второго шифрования:");
        System.out.println(ciphertext2);
        System.out.println("\nКомбинированный ключ:");
        System.out.println(combinedKey);
        System.out.println("Шифротекст после шифрования с комбинированным ключом:");
        System.out.println(ciphertextCombined);

        writeFile("output.txt", ciphertextCombined);
        writeFile("key3.txt", combinedKey);

        System.out.println("\nШифротекст сохранён в файле 'output.txt'.");
        System.out.println("Комбинированный ключ сохранён в файле 'key3.txt'.");

        String decryptedText = vigenereDecrypt(ciphertextCombined, combinedKey, alphabet);
        if (decryptedText == null) return;

        System.out.println("\nДешифрованный текст:");
        System.out.println(decryptedText);

        if (ciphertext2.equals(ciphertextCombined)) {
            System.out.println("\nШифротексты совпадают. Комбинированный ключ работает корректно.");
        } else {
            System.out.println("\nШифротексты не совпадают. Проверьте реализацию.");
        }

        if (decryptedText.equals(originalText)) {
            System.out.println("Дешифрование успешно. Исходный текст восстановлен.");
        } else {
            System.out.println("Дешифрование некорректно. Проверьте реализацию.");
        }
    }

    private static String readFile(String path) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8))) {
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
            return content.toString().trim();
        } catch (IOException e) {
            System.out.printf("Файл '%s' не найден. Проверьте путь и повторите попытку.%n", path);
            System.exit(1);
            return null;
        }
    }

    private static void writeFile(String path, String content) {
        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path), StandardCharsets.UTF_8))) {
            writer.write(content);
        } catch (IOException e) {
            System.out.printf("Ошибка при записи в файл '%s'.%n", path);
            System.exit(1);
        }
    }

    private static String filterKey(String key, String alphabet) {
        StringBuilder filtered = new StringBuilder();
        for (char c : key.toCharArray()) {
            if (alphabet.indexOf(Character.toLowerCase(c)) >= 0) {
                filtered.append(c);
            }
        }
        return filtered.toString();
    }
}