Как сгенерировать случайный пароль на языке пользователя?

Question

Мое приложение должно быть совместимо с I18N.Одним из требований является то, что исходный пароль, который я генерирую, должен быть на выбранном пользователем языке.Какой API в Java можно использовать для достижения этой цели?У меня есть язык пользователя, и мне нужно будет получить несколько случайных символов из набора Unicode этого языка.

Редактировать: Спасибо за ответы до сих пор.Некоторые пояснения: это для веб-приложения.По соображениям безопасности мы не можем поддерживать запас символов / слов на разных языках.

Редактировать 2: В ответ на комментарии и некоторые ответы: Это приложение будет развернуто в разных регионах, и я не хочу ихчтобы настроить пароли на том языке, на котором они развернуты. Это и безопасность - вот причины, по которым я пока не принял самый популярный ответ.

Answer 1

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

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

Редактировать: если вы просто создаете случайные строки, это становится намного проще: вы просто сохраняете файл доступных символов для каждого языка.Откройте правильный, когда вы придете, чтобы генерировать, а затем выбрать случайные буквы.Биш баш чушьГотово.

Редактировать 2: Как правильно прокомментировал Марсело, вы можете столкнуться с проблемой генерации нецензурного пароля для пользователя.Возможно, стоит также сохранить локализованные строки в черном списке, чтобы проверить ваш пароль.Если какая-либо из строк появляется в пароле (только в нем, а не в целом), сгенерируйте другой пароль.Это означает, что вы никогда не сгенерируете достаточно невинный пароль, такой как scunthorpe, но это также означает, что вы не получите, например, assclown проскальзывания.

Как вы уже поняли, это начинаетпохоже на большую работу:

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

Вы можете обнаружить, что установка фразы pass- с использованием известных чистых слов из каждого языка (согласно моему первоначальному ответу) работает лучше.

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

---

Редактировать: В порядке ли цифры?Они много безопаснее, не нуждаются в расчесывании, являются международными и могут быть достаточно длинными, чтобы быть уникальными, они просто редко запоминаются.Если это одноразовые задания на копирование и вставку, с ними все будет в порядке.

Если вам нужно, чтобы они были короткими, но очень уникальными (и нуждались в большом количестве), возможно, смешивая числа с буквами в предсказуемых шаблонах, таких как(a = буква, n = число) annn-annn дает 676 000 000 комбинаций.Даже такие простые вещи, как annn дают достаточно, чтобы не угадать (26000 комбинаций), если они не должны быть уникальными ... Если эти являются паролями, нет ничего плохого в том, что два одинаковых.

Answer 2

JDK включает в себя названия стран отображения, язык отображения и текст отображения для каждой локали, сохраненные во всех доступных локалях. Вы можете использовать это для создания начального набора символов для каждой локали и использовать Character.toUpperCase Character.toLowerCase, чтобы также получить варианты регистра.

   String getCharsForLocale(Locale locale) {
      Locale[] allLocales = Locale.getAvailableLocales();
      StringBuilder buf = new StringBuilder();
      for (Locale l: allLocales) {
          buf.append(l.getDisplayName(locale).toLowerCase())
             .append(l.getDisplayName(locale).toUpperCase())
             .append(l.getDisplaycountry(locale).toLowerCase())
             .append(l.getDisplayCountry(locale).toUpperCase())
             .append(l.getDisplayLanguage(locale).toLowerCase())
             .append(l.getDisplayLanguage(locale).toUpperCase());
      }
      // add other chars, such as decimals
      DecimalFormatSymbols decimals = DecimalFormatSymbols.getInstance(locale);
      buf.append(decimals.getMinusSign())
         .append(decimals.getPercent())
         .append(decimals.getDecimalSeparator());
      // etc..

      // now remove dupicates
      char[] chars = new char[buf.length()];
      buf.getChars(0, chars.length, chars, 0);
      Arrays.sort(chars);
      buf = new StringBuilder();
      char last = '\0';
      for (char c: chars) {
          if (c!=last) buf.append(c);
          last = c;
      }
      return buf.toString();
   }

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

Answer 3

Может быть, это звучит немного сложно.Но вы можете хранить много слов в базе данных.И перевести их с помощью какого-либо инструмента перевода на язык пользователя.(Может быть Google , но я не знаю, разрешает ли это Google)
Немного похоже на reCHAPTA .У них много текстов (например, Lorem Ipsum ), где они выбирают два слова.

Вы можете объединить два или три слова (с максимальной длиной) с числом.Может быть, с символом их страны впереди.Таким образом, вы получаете такие вещи, как:

• BE_VogelHuis9751
• FR_ChienVoiture3104
• ES_GatoEdificio9554
• D_BrustTausend9672
• ...

Answer 4

Если вы хотите, чтобы содержательные слова были на каждом языке, вы можете использовать набор слов на английском языке (например, через переводчик Google).

Затем вы можете обернуть их цифрами и специальными символами для надежности пароля.

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

Answer 5

1. Используйте латинский словарь, выбирая случайные слова в CammelCase до тех пор, пока они не наберут желаемой длины.
2. Если вы настаиваете на том, чтобы придумывать Unicode, попробуйте UN UDHR .Просто очистите его с помощью простого регулярного выражения.Из-за меньшего размера словаря вам могут понадобиться более длинные пароли, но кого это волнует.

Answer 6

Взгляните на http://thedailywtf.com/Articles/The-Automated-Curse-Generator.aspx, где описано нечто подобное.ключевые слова для поиска кажутся "цепями Маркова".

Редактировать: только что заметил, что dan04 уже упомянул эту ссылку.

Answer 7

Это действительно интересный вопрос, который заставил меня задуматься, и я опустил руки в грязь. Вот мой мыслительный процесс

1. Получить языковой стандарт (обычно стандартный для обмена языками, необязательно, если у вас уже есть язык)
2. Получить язык из локали
3. Получить скрипт для языка
4. Получить символы (символы Юникода) для сценария
5. Генерация случайного пароля.
6. По выбору, время обернуть процесс

Вот суть

import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public class LocaleSpecificPasswordGenerator {

    public static void main(String[] args) {
        // 1. get locale : en_US/ es_US/ hi_IN / ud_PK
        // 2. get language from locale
        // 3. get script for language
        // 4. get charset
        // 5. get script characters from charset
        // 6. generate random password
        // 7. time wrap the password generation process
        Locale lo = Locale.ENGLISH;
        int passwordLength = 10;
        String password = timeWrappedPasswordGeneration(lo, passwordLength);
        System.out.println(password);
    }

    private static String timeWrappedPasswordGeneration(Locale lo,
            int passwordLength) {
        long curr = System.currentTimeMillis();
        String password = null;
        while (System.currentTimeMillis() - curr < 50) {
            password = generateRandomPassword(
                    getCharListForScript(getScriptFromLanguage(lo.getLanguage())),
                    passwordLength);
        }
        return password;
    }

    private static String getScriptFromLanguage(String languageCode) {
        String script = "";
        switch (languageCode) {
        case "ar":
            script = "Arabic";
            break;
        case "as":
            script = "Bengali and Assamese";
            break;
        case "be":
            script = "Cyrillic";
            break;
        case "bg":
            script = "Cyrillic";
            break;
        case "bn":
            script = "Bengali and Assamese";
            break;
        case "ca":
            script = "Latin";
            break;
        case "cs":
            script = "Latin";
            break;
        case "da":
            script = "Latin";
            break;
        case "de":
            script = "Latin";
            break;
        case "el":
            script = "Greek";
            break;
        case "en":
            script = "Latin";
            break;
        case "es":
            script = "Latin";
            break;
        case "et":
            script = "Latin";
            break;
        case "fi":
            script = "Latin";
            break;
        case "fr":
            script = "Latin";
            break;
        case "ga":
            script = "Latin";
            break;
        case "gu":
            script = "Gujarati";
            break;
        case "he":
            script = "Samaritan";
            break;
        case "hi":
            script = "Devanagari";
            break;
        case "hr":
            script = "Latin";
            break;
        case "hu":
            script = "Old Hungarian";
            break;
        case "hy":
            script = "Armenian";
            break;
        case "in":
            script = "Latin";
            break;
        case "is":
            script = "Latin";
            break;
        case "it":
            script = "Latin";
            break;
        case "iw":
            script = "Hebrew";
            break;
        case "ja":
            script = "Katakana";
            break;
        case "ka":
            script = "Georgian";
            break;
        case "kn":
            script = "Kannada";
            break;
        case "ko":
            script = "Hangul Jamo";
            break;
        case "lt":
            script = "Latin";
            break;
        case "lv":
            script = "Latin";
            break;
        case "mk":
            script = "Cyrillic";
            break;
        case "ml":
            script = "Malayalam";
            break;
        case "mn":
            script = "Mongolian";
            break;
        case "ms":
            script = "Latin";
            break;
        case "mt":
            script = "Latin";
            break;
        case "ne":
            script = "Limbu";
            break;
        case "nl":
            script = "Latin";
            break;
        case "no":
            script = "Latin";
            break;
        case "or":
            script = "Oriya";
            break;
        case "pa":
            script = "Gurmukhi";
            break;
        case "pa-IN":
            script = "Gurmukhi";
            break;
        case "pl":
            script = "Latin";
            break;
        case "pt":
            script = "Latin";
            break;
        case "ro":
            script = "Latin";
            break;
        case "ru":
            script = "Cyrillic";
            break;
        case "sk":
            script = "Latin";
            break;
        case "sl":
            script = "Latin";
            break;
        case "sq":
            script = "Caucasian Albanian";
            break;
        case "sr":
            script = "Cyrillic";
            break;
        case "sv":
            script = "Latin";
            break;
        case "ta":
            script = "Tamil";
            break;
        case "te":
            script = "Telugu";
            break;
        case "th":
            script = "Thai";
            break;
        case "tr":
            script = "Latin";
            break;
        case "uk":
            script = "Cyrillic";
            break;
        case "vi":
            script = "Latin";
            break;
        case "zh":
            script = "CJK Unified Ideographs (Han)";
            break;
        default:
            script = "Latin";
        }
        return script;
    }

    private static String generateRandomPassword(List<Character> charlist,
            int length) {
        StringBuilder sb = new StringBuilder();
        if (charlist.size() > 0) {
            while (sb.length() < length) {
                SecureRandom random = new SecureRandom();
                int charAt = random.nextInt(charlist.size());

                sb.append(charlist.get(charAt));
            }
        }
        return sb.toString();
    }

    private static List<Character> getCharListForScript(String script) {
        Map<String, Character> initialMap = new HashMap<String, Character>();
        Map<String, Character> finalMap = new HashMap<String, Character>();
        initialMap.put("Armenian", '\u0530');
        finalMap.put("Armenian", '\u058F');
        initialMap.put("Armenian Ligatures", '\uFB13');
        finalMap.put("Armenian Ligatures", '\uFB17');
        // initialMap.put("Caucasian Albanian",'\u10530');
        // finalMap.put("Caucasian Albanian",'\u1056F');
        // initialMap.put("Cypriot Syllabary",'\u10800');
        // finalMap.put("Cypriot Syllabary",'\u1083F');
        initialMap.put("Cyrillic", '\u0400');
        finalMap.put("Cyrillic", '\u04FF');
        initialMap.put("Cyrillic Supplement", '\u0500');
        finalMap.put("Cyrillic Supplement", '\u052F');
        initialMap.put("Cyrillic Extended-A", '\u2DE0');
        finalMap.put("Cyrillic Extended-A", '\u2DFF');
        initialMap.put("Cyrillic Extended-B", '\uA640');
        finalMap.put("Cyrillic Extended-B", '\uA69F');
        // initialMap.put("Elbasan",'\u10500');
        // finalMap.put("Elbasan",'\u1052F');
        initialMap.put("Georgian", '\u10A0');
        finalMap.put("Georgian", '\u10FF');
        initialMap.put("Georgian Supplement", '\u2D00');
        finalMap.put("Georgian Supplement", '\u2D2F');
        initialMap.put("Glagolitic", '\u2C00');
        finalMap.put("Glagolitic", '\u2C5F');
        // initialMap.put("Gothic",'\u10330');
        // finalMap.put("Gothic",'\u1034F');
        initialMap.put("Greek", '\u0370');
        finalMap.put("Greek", '\u03FF');
        initialMap.put("Greek Extended", '\u1F00');
        finalMap.put("Greek Extended", '\u1FFF');
        // initialMap.put("Ancient Greek Numbers",'\u10140');
        // finalMap.put("Ancient Greek Numbers",'\u1018F');
        initialMap.put("Latin", '\u0020');
        finalMap.put("Latin", '\u007E');
        initialMap.put("Basic Latin (ASCII)", '\u0000');
        finalMap.put("Basic Latin (ASCII)", '\u007F');
        initialMap.put("Latin-1 Supplement", '\u0080');
        finalMap.put("Latin-1 Supplement", '\u00FF');
        initialMap.put("Latin Extended-A", '\u0100');
        finalMap.put("Latin Extended-A", '\u017F');
        initialMap.put("Latin Extended-B", '\u0180');
        finalMap.put("Latin Extended-B", '\u024F');
        initialMap.put("Latin Extended-C", '\u2C60');
        finalMap.put("Latin Extended-C", '\u2C7F');
        initialMap.put("Latin Extended-D", '\uA720');
        finalMap.put("Latin Extended-D", '\uA7FF');
        initialMap.put("Latin Extended-E", '\uAB30');
        finalMap.put("Latin Extended-E", '\uAB6F');
        initialMap.put("Latin Extended Additional", '\u1E00');
        finalMap.put("Latin Extended Additional", '\u1EFF');
        initialMap.put("Latin Ligatures", '\uFB00');
        finalMap.put("Latin Ligatures", '\uFB06');
        initialMap.put("Fullwidth Latin Letters", '\uFF00');
        finalMap.put("Fullwidth Latin Letters", '\uFF5E');
        initialMap.put("IPA Extensions", '\u0250');
        finalMap.put("IPA Extensions", '\u02AF');
        initialMap.put("Phonetic Extensions", '\u1D00');
        finalMap.put("Phonetic Extensions", '\u1D7F');
        initialMap.put("Phonetic Extensions Supplement", '\u1D80');
        finalMap.put("Phonetic Extensions Supplement", '\u1DBF');
        // initialMap.put("Linear A",'\u10600');
        // finalMap.put("Linear A",'\u1077F');
        // initialMap.put("Linear B Syllabary",'\u10000');
        // finalMap.put("Linear B Syllabary",'\u1007F');
        // initialMap.put("Linear B Ideograms",'\u10080');
        // finalMap.put("Linear B Ideograms",'\u100FF');
        // initialMap.put("Aegean Numbers",'\u10100');
        // finalMap.put("Aegean Numbers",'\u1013F');
        initialMap.put("Ogham", '\u1680');
        finalMap.put("Ogham", '\u169F');
        // initialMap.put("Old Hungarian",'\u10C80');
        // finalMap.put("Old Hungarian",'\u10CFF');
        // initialMap.put("Old Italic",'\u10300');
        // finalMap.put("Old Italic",'\u1032F');
        // initialMap.put("Old Permic",'\u10350');
        // finalMap.put("Old Permic",'\u1037F');
        // initialMap.put("Phaistos Disc",'\u101D0');
        // finalMap.put("Phaistos Disc",'\u101FF');
        initialMap.put("Runic", '\u16A0');
        finalMap.put("Runic", '\u16FF');
        // initialMap.put("Shavian",'\u10450');
        // finalMap.put("Shavian",'\u1047F');
        initialMap.put("Modifier Tone Letters", '\uA700');
        finalMap.put("Modifier Tone Letters", '\uA71F');
        initialMap.put("Spacing Modifier Letters", '\u02B0');
        finalMap.put("Spacing Modifier Letters", '\u02FF');
        initialMap.put("Superscripts and Subscripts", '\u2070');
        finalMap.put("Superscripts and Subscripts", '\u209F');
        initialMap.put("Combining Diacritical Marks", '\u0300');
        finalMap.put("Combining Diacritical Marks", '\u036F');
        initialMap.put("Combining Diacritical Marks Extended", '\u1AB0');
        finalMap.put("Combining Diacritical Marks Extended", '\u1AFF');
        initialMap.put("Combining Diacritical Marks Supplement", '\u1DC0');
        finalMap.put("Combining Diacritical Marks Supplement", '\u1DFF');
        initialMap.put("Combining Diacritical Marks for Symbols", '\u20D0');
        finalMap.put("Combining Diacritical Marks for Symbols", '\u20FF');
        initialMap.put("Combining Half Marks", '\uFE20');
        finalMap.put("Combining Half Marks", '\uFE2F');
        initialMap.put("Bamum", '\uA6A0');
        finalMap.put("Bamum", '\uA6FF');
        // initialMap.put("Bamum Supplement",'\u16800');
        // finalMap.put("Bamum Supplement",'\u16A3F');
        // initialMap.put("Bassa Vah",'\u16AD0');
        // finalMap.put("Bassa Vah",'\u16AFF');
        initialMap.put("Coptic", '\u2C80');
        finalMap.put("Coptic", '\u2CFF');
        initialMap.put("Coptic in Greek block", '\u03E2');
        finalMap.put("Coptic in Greek block", '\u03EF');
        // initialMap.put("Coptic Epact Numbers",'\u102E0');
        // finalMap.put("Coptic Epact Numbers",'\u102FF');
        // initialMap.put("Egyptian Hieroglyphs",'\u13000');
        // finalMap.put("Egyptian Hieroglyphs",'\u1342F');
        initialMap.put("Ethiopic", '\u1200');
        finalMap.put("Ethiopic", '\u137F');
        initialMap.put("Ethiopic Supplement", '\u1380');
        finalMap.put("Ethiopic Supplement", '\u139F');
        initialMap.put("Ethiopic Extended", '\u2D80');
        finalMap.put("Ethiopic Extended", '\u2DDF');
        initialMap.put("Ethiopic Extended-A", '\uAB00');
        finalMap.put("Ethiopic Extended-A", '\uAB2F');
        // initialMap.put("Mende Kikakui",'\u1E800');
        // finalMap.put("Mende Kikakui",'\u1E8DF');
        // initialMap.put("Meroitic Cursive",'\u109A0');
        // finalMap.put("Meroitic Cursive",'\u109FF');
        // initialMap.put("Meroitic Hieroglyphs",'\u10980');
        // finalMap.put("Meroitic Hieroglyphs",'\u1099F');
        initialMap.put("N&#39;Ko", '\u07C0');
        finalMap.put("N&#39;Ko", '\u07FF');
        // initialMap.put("Osmanya",'\u10480');
        // finalMap.put("Osmanya",'\u104AF');
        initialMap.put("Tifinagh", '\u2D30');
        finalMap.put("Tifinagh", '\u2D7F');
        initialMap.put("Vai", '\uA500');
        finalMap.put("Vai", '\uA63F');
        // initialMap.put("Anatolian Hieroglyphs",'\u14400');
        // finalMap.put("Anatolian Hieroglyphs",'\u1467F');
        initialMap.put("Arabic", '\u0600');
        finalMap.put("Arabic", '\u06FF');
        initialMap.put("Arabic Supplement", '\u0750');
        finalMap.put("Arabic Supplement", '\u077F');
        initialMap.put("Arabic Extended-A", '\u08A0');
        finalMap.put("Arabic Extended-A", '\u08FF');
        initialMap.put("Arabic Presentation Forms-A", '\uFB50');
        finalMap.put("Arabic Presentation Forms-A", '\uFDFF');
        initialMap.put("Arabic Presentation Forms-B", '\uFE70');
        finalMap.put("Arabic Presentation Forms-B", '\uFEFF');
        // initialMap.put("Aramaic, Imperial",'\u10840');
        // finalMap.put("Aramaic, Imperial",'\u1085F');
        // initialMap.put("Avestan",'\u10B00');
        // finalMap.put("Avestan",'\u10B3F');
        // initialMap.put("Carian",'\u102A0');
        // finalMap.put("Carian",'\u102DF');
        // initialMap.put("Cuneiform",'\u12000');
        // finalMap.put("Cuneiform",'\u123FF');
        // initialMap.put("Cuneiform Numbers and Punctuation",'\u12400');
        // finalMap.put("Cuneiform Numbers and Punctuation",'\u1247F');
        // initialMap.put("Early Dynastic Cuneiform",'\u12480');
        // finalMap.put("Early Dynastic Cuneiform",'\u1254F');
        // initialMap.put("Old Persian",'\u103A0');
        // finalMap.put("Old Persian",'\u103DF');
        // initialMap.put("Ugaritic",'\u10380');
        // finalMap.put("Ugaritic",'\u1039F');
        // initialMap.put("Hatran",'\u108E0');
        // finalMap.put("Hatran",'\u108FF');
        initialMap.put("Hebrew", '\u0590');
        finalMap.put("Hebrew", '\u05FF');
        initialMap.put("Hebrew Presentation Forms", '\uFB1D');
        finalMap.put("Hebrew Presentation Forms", '\uFB4F');
        // initialMap.put("Lycian",'\u10280');
        // finalMap.put("Lycian",'\u1029F');
        // initialMap.put("Lydian",'\u10920');
        // finalMap.put("Lydian",'\u1093F');
        initialMap.put("Mandaic", '\u0840');
        finalMap.put("Mandaic", '\u085F');
        // initialMap.put("Nabataean",'\u10880');
        // finalMap.put("Nabataean",'\u108AF');
        // initialMap.put("Old North Arabian",'\u10A80');
        // finalMap.put("Old North Arabian",'\u10A9F');
        // initialMap.put("Old South Arabian",'\u10A60');
        // finalMap.put("Old South Arabian",'\u10A7F');
        // initialMap.put("Pahlavi, Inscriptional",'\u10B60');
        // finalMap.put("Pahlavi, Inscriptional",'\u10B7F');
        // initialMap.put("Pahlavi, Psalter",'\u10B80');
        // finalMap.put("Pahlavi, Psalter",'\u10BAF');
        // initialMap.put("Palmyrene",'\u10860');
        // finalMap.put("Palmyrene",'\u1087F');
        // initialMap.put("Parthian, Inscriptional",'\u10B40');
        // finalMap.put("Parthian, Inscriptional",'\u10B5F');
        // initialMap.put("Phoenician",'\u10900');
        // finalMap.put("Phoenician",'\u1091F');
        initialMap.put("Samaritan", '\u0800');
        finalMap.put("Samaritan", '\u083F');
        initialMap.put("Syriac", '\u0700');
        finalMap.put("Syriac", '\u074F');
        // initialMap.put("Manichaean",'\u10AC0');
        // finalMap.put("Manichaean",'\u10AFF');
        initialMap.put("Mongolian", '\u1800');
        finalMap.put("Mongolian", '\u18AF');
        // initialMap.put("Old Turkic",'\u10C00');
        // finalMap.put("Old Turkic",'\u10C4F');
        // initialMap.put("Phags-Pa",'\u10C00');
        // finalMap.put("Phags-Pa",'\u10C4F');
        initialMap.put("Tibetan", '\u0F00');
        finalMap.put("Tibetan", '\u0FFF');
        // initialMap.put("Ahom",'\u11700');
        // finalMap.put("Ahom",'\u1173F');
        initialMap.put("Bengali and Assamese", '\u0980');
        finalMap.put("Bengali and Assamese", '\u09FF');
        // initialMap.put("Brahmi",'\u11000');
        // finalMap.put("Brahmi",'\u1107F');
        // initialMap.put("Chakma",'\u11100');
        // finalMap.put("Chakma",'\u1114F');
        initialMap.put("Devanagari", '\u0900');
        finalMap.put("Devanagari", '\u097F');
        initialMap.put("Devanagari Extended", '\uA8E0');
        finalMap.put("Devanagari Extended", '\uA8FF');
        // initialMap.put("Grantha",'\u11300');
        // finalMap.put("Grantha",'\u1137F');
        initialMap.put("Gujarati", '\u0A80');
        finalMap.put("Gujarati", '\u0AFF');
        initialMap.put("Gurmukhi", '\u0A05');
        finalMap.put("Gurmukhi", '\u0A71');
        // initialMap.put("Kaithi",'\u11080');
        // finalMap.put("Kaithi",'\u110CF');
        initialMap.put("Kannada", '\u0C80');
        finalMap.put("Kannada", '\u0CFF');
        // initialMap.put("Kharoshthi",'\u10A00');
        // finalMap.put("Kharoshthi",'\u10A5F');
        // initialMap.put("Khojki",'\u11200');
        // finalMap.put("Khojki",'\u1124F');
        // initialMap.put("Khudawadi",'\u112B0');
        // finalMap.put("Khudawadi",'\u112FF');
        initialMap.put("Lepcha", '\u1C00');
        finalMap.put("Lepcha", '\u1C4F');
        initialMap.put("Limbu", '\u1900');
        finalMap.put("Limbu", '\u194F');
        // initialMap.put("Mahajani",'\u11150');
        // finalMap.put("Mahajani",'\u1117F');
        initialMap.put("Malayalam", '\u0D00');
        finalMap.put("Malayalam", '\u0D7F');
        initialMap.put("Meetei Mayek", '\uABC0');
        finalMap.put("Meetei Mayek", '\uABFF');
        initialMap.put("Meetei Mayek Extensions", '\uAAE0');
        finalMap.put("Meetei Mayek Extensions", '\uAAFF');
        // initialMap.put("Modi",'\u11600');
        // finalMap.put("Modi",'\u1165F');
        // initialMap.put("Mro",'\u16A40');
        // finalMap.put("Mro",'\u16A6F');
        // initialMap.put("Multani",'\u11280');
        // finalMap.put("Multani",'\u112AF');
        initialMap.put("Ol Chiki", '\u1C50');
        finalMap.put("Ol Chiki", '\u1C7F');
        initialMap.put("Oriya (Odia)", '\u0B00');
        finalMap.put("Oriya (Odia)", '\u0B7F');
        initialMap.put("Saurashtra", '\uA880');
        finalMap.put("Saurashtra", '\uA8DF');
        // initialMap.put("Sharada",'\u11180');
        // finalMap.put("Sharada",'\u111DF');
        // initialMap.put("Siddham",'\u11580');
        // finalMap.put("Siddham",'\u115FF');
        initialMap.put("Sinhala", '\u0D80');
        finalMap.put("Sinhala", '\u0DFF');
        // initialMap.put("Sinhala Archaic Numbers",'\u111E0');
        // finalMap.put("Sinhala Archaic Numbers",'\u111FF');
        // initialMap.put("Sora Sompeng",'\u110D0');
        // finalMap.put("Sora Sompeng",'\u110FF');
        initialMap.put("Syloti Nagri", '\uA800');
        finalMap.put("Syloti Nagri", '\uA82F');
        // initialMap.put("Takri",'\u11680');
        // finalMap.put("Takri",'\u116CF');
        initialMap.put("Tamil", '\u0B80');
        finalMap.put("Tamil", '\u0BFF');
        initialMap.put("Telugu", '\u0C00');
        finalMap.put("Telugu", '\u0C7F');
        initialMap.put("Thaana", '\u0780');
        finalMap.put("Thaana", '\u07BF');
        // initialMap.put("Tirhuta",'\u11480');
        // finalMap.put("Tirhuta",'\u114DF');
        initialMap.put("Vedic Extensions", '\u1CD0');
        finalMap.put("Vedic Extensions", '\u1CFF');
        // initialMap.put("Warang Citi",'\u118A0');
        // finalMap.put("Warang Citi",'\u118FF');
        initialMap.put("Cham", '\uAA00');
        finalMap.put("Cham", '\uAA5F');
        initialMap.put("Kayah Li", '\uA900');
        finalMap.put("Kayah Li", '\uA92F');
        initialMap.put("Khmer", '\u1780');
        finalMap.put("Khmer", '\u17FF');
        initialMap.put("Khmer Symbols", '\u19E0');
        finalMap.put("Khmer Symbols", '\u19FF');
        initialMap.put("Lao", '\u0E80');
        finalMap.put("Lao", '\u0EFF');
        initialMap.put("Myanmar", '\u1000');
        finalMap.put("Myanmar", '\u109F');
        initialMap.put("Myanmar Extended-A", '\uAA60');
        finalMap.put("Myanmar Extended-A", '\uAA7F');
        initialMap.put("Myanmar Extended-B", '\uA9E0');
        finalMap.put("Myanmar Extended-B", '\uA9FF');
        initialMap.put("New Tai Lue", '\u1980');
        finalMap.put("New Tai Lue", '\u19DF');
        // initialMap.put("Pahawh Hmong",'\u16B00');
        // finalMap.put("Pahawh Hmong",'\u16B8F');
        // initialMap.put("Pau Cin Hau",'\u11AC0');
        // finalMap.put("Pau Cin Hau",'\u11AFF');
        initialMap.put("Tai Le", '\u1950');
        finalMap.put("Tai Le", '\u197F');
        initialMap.put("Tai Tham", '\u1A20');
        finalMap.put("Tai Tham", '\u1AAF');
        initialMap.put("Tai Viet", '\uAA80');
        finalMap.put("Tai Viet", '\uAADF');
        initialMap.put("Thai", '\u0E00');
        finalMap.put("Thai", '\u0E7F');
        initialMap.put("Balinese", '\u1B00');
        finalMap.put("Balinese", '\u1B7F');
        initialMap.put("Batak", '\u1BC0');
        finalMap.put("Batak", '\u1BFF');
        initialMap.put("Buginese", '\u1A00');
        finalMap.put("Buginese", '\u1A1F');
        initialMap.put("Buhid", '\u1740');
        finalMap.put("Buhid", '\u175F');
        initialMap.put("Hanunoo", '\u1720');
        finalMap.put("Hanunoo", '\u173F');
        initialMap.put("Javanese", '\uA980');
        finalMap.put("Javanese", '\uA9DF');
        initialMap.put("Rejang", '\uA930');
        finalMap.put("Rejang", '\uA95F');
        initialMap.put("Sundanese", '\uA930');
        finalMap.put("Sundanese", '\uA95F');
        initialMap.put("Sundanese Supplement", '\u1CC0');
        finalMap.put("Sundanese Supplement", '\u1CCF');
        initialMap.put("Tagalog", '\u1700');
        finalMap.put("Tagalog", '\u171F');
        initialMap.put("Tagbanwa", '\u1760');
        finalMap.put("Tagbanwa", '\u177F');
        initialMap.put("Bopomofo", '\u3100');
        finalMap.put("Bopomofo", '\u312F');
        initialMap.put("Bopomofo Extended", '\u31A0');
        finalMap.put("Bopomofo Extended", '\u31BF');
        initialMap.put("CJK Unified Ideographs (Han)", '\u4E00');
        finalMap.put("CJK Unified Ideographs (Han)", '\u9FFF');
        initialMap.put("CJK  Extension-A", '\u3400');
        finalMap.put("CJK  Extension-A", '\u4DBF');
        // initialMap.put("CJK Extension B",'\u20000');
        // finalMap.put("CJK Extension B",'\u2A6DF');
        // initialMap.put("CJK Extension C",'\u2A700');
        // finalMap.put("CJK Extension C",'\u2B73F');
        // initialMap.put("CJK Extension D",'\u2B740');
        // finalMap.put("CJK Extension D",'\u2B81F');
        // initialMap.put("CJK Extension E",'\u2B820');
        // finalMap.put("CJK Extension E",'\u2CEAF');
        initialMap.put("CJK Compatibility Ideographs", '\uF900');
        finalMap.put("CJK Compatibility Ideographs", '\uFAFF');
        // initialMap.put("CJK Compatibility Ideographs Supplement",'\u2F800');
        // finalMap.put("CJK Compatibility Ideographs Supplement",'\u2FA1F');
        initialMap.put("CJK Radicals / KangXi Radicals", '\u2F00');
        finalMap.put("CJK Radicals / KangXi Radicals", '\u2FDF');
        initialMap.put("CJK Radicals Supplement", '\u2E80');
        finalMap.put("CJK Radicals Supplement", '\u2EFF');
        initialMap.put("CJK Strokes", '\u31C0');
        finalMap.put("CJK Strokes", '\u31EF');
        initialMap.put("Ideographic Description Characters", '\u2FF0');
        finalMap.put("Ideographic Description Characters", '\u2FFF');
        initialMap.put("Hangul Jamo", '\u1100');
        finalMap.put("Hangul Jamo", '\u11FF');
        initialMap.put("Hangul Jamo Extended-A", '\uA960');
        finalMap.put("Hangul Jamo Extended-A", '\uA97F');
        initialMap.put("Hangul Jamo Extended-B", '\uD7B0');
        finalMap.put("Hangul Jamo Extended-B", '\uD7FF');
        initialMap.put("Hangul Compatibility Jamo", '\u3130');
        finalMap.put("Hangul Compatibility Jamo", '\u318F');
        initialMap.put("Halfwidth Jamo", '\uFFA0');
        finalMap.put("Halfwidth Jamo", '\uFFDC');
        initialMap.put("Hangul Syllables", '\uAC00');
        finalMap.put("Hangul Syllables", '\uD7AF');
        initialMap.put("Hiragana", '\u3040');
        finalMap.put("Hiragana", '\u309F');
        initialMap.put("Katakana", '\u30A0');
        finalMap.put("Katakana", '\u30FF');
        initialMap.put("Katakana Phonetic Extensions", '\u31F0');
        finalMap.put("Katakana Phonetic Extensions", '\u31FF');
        // initialMap.put("Kana Supplement",'\u1B000');
        // finalMap.put("Kana Supplement",'\u1B0FF');
        initialMap.put("Halfwidth Katakana", '\uFF65');
        finalMap.put("Halfwidth Katakana", '\uFF9F');
        initialMap.put("Kanbun", '\u3190');
        finalMap.put("Kanbun", '\u319F');
        initialMap.put("Lisu", '\uA4D0');
        finalMap.put("Lisu", '\uA4FF');
        // initialMap.put("Miao",'\u16F00');
        // finalMap.put("Miao",'\u16F9F');
        initialMap.put("Yi Syllables", '\uA000');
        finalMap.put("Yi Syllables", '\uA48F');
        initialMap.put("Yi Radicals", '\uA490');
        finalMap.put("Yi Radicals", '\uA4CF');
        initialMap.put("Cherokee", '\u13A0');
        finalMap.put("Cherokee", '\u13FF');
        initialMap.put("Cherokee Supplement", '\uAB70');
        finalMap.put("Cherokee Supplement", '\uABBF');
        // initialMap.put("Deseret",'\u10400');
        // finalMap.put("Deseret",'\u1044F');
        initialMap.put("Unified Canadian Aboriginal Syllabics", '\u1400');
        finalMap.put("Unified Canadian Aboriginal Syllabics", '\u167F');
        initialMap.put("UCAS Extended", '\u18B0');
        finalMap.put("UCAS Extended", '\u18FF');
        initialMap.put("Alphabetic Presentation Forms", '\uFB00');
        finalMap.put("Alphabetic Presentation Forms", '\uFB4F');
        initialMap.put("ASCII Characters", '\u0000');
        finalMap.put("ASCII Characters", '\u007F');
        initialMap.put("Halfwidth and Fullwidth Forms", '\uFF00');
        finalMap.put("Halfwidth and Fullwidth Forms", '\uFFEF');

        Character ab = initialMap.get(script.trim());
        Character b = finalMap.get(script.trim());
        List<Character> reqCharList = new ArrayList<Character>();
        if (ab != null) {
            while (!ab.equals(b)) {
                reqCharList.add(ab);
                ab++;
            }
        }
        return reqCharList;
    }
}

Известные проблемы с кодом:

1. Он обрабатывает только простые юникоды (4 символа). При необходимости он может быть расширен и для обработки других символов Юникода
2. На данный момент это зависит от диапазона символов в скрипте. Если несколько символов добавляются позже или находятся за пределами диапазона, код не будет охватывать их. Если некоторые символы в определенном диапазоне принадлежат другим сценариям, они могут вводить в заблуждение. Эту проблему можно решить, улучшив символы, относящиеся к сценарию.

Answer 8

База данных символов Unicode и хранилище данных Unicode Common Locale содержат много информации о языках и сценариях. Вы можете получить доступ к информации, используя, например, IBM ICU (библиотека I18N / L10N более полная, чем языковые стандарты Java).

В частности, вы можете получить набор образцов символов, используя LocaleData.getExemplarSet . Тем не менее, обратите внимание, что CLDR далек от завершения, вам следует ожидать пропущенных данных.

Answer 9

может быть, вы можете создать английское слово и перевести его с помощью Google перевести его