locale.java

java源代码 请看看啊 提点宝贵的意见

        return true; // we made it through the guantlet.
        // (1)  We don't check super.equals since it is Object.
        //      Since Locale is final, we don't have to check both directions.
    }

    // ================= privates =====================================

    // XXX instance and class variables. For now keep these separate, since it is
    // faster to match. Later, make into single string.

    /**
     * @serial
     * @see #getLanguage
     */
    private String language = "";

    /**
     * @serial
     * @see #getCountry
     */
    private String country = "";

    /**
     * @serial
     * @see #getVariant
     */
    private String variant = "";

    /**
     * Placeholder for the object's hash code.  Always -1.
     * @serial
     */
    private int hashcode = -1;        // lazy evaluated

    private static Locale defaultLocale = null;

    /**
     * Return an array of the display names of the variant.
     * @param bundle the ResourceBundle to use to get the display names
     * @return an array of display names, possible of zero length.
     */
    private String[] getDisplayVariantArray(ResourceBundle bundle) {
        // Split the variant name into tokens separated by '_'.
        StringTokenizer tokenizer = new StringTokenizer(variant, "_");
        String[] names = new String[tokenizer.countTokens()];

        // For each variant token, lookup the display name.  If
        // not found, use the variant name itself.
        for (int i=0; i<names.length; ++i) {
            String token = tokenizer.nextToken();
            try {
                names[i] = (String)bundle.getObject("%%" + token);
            }
            catch (MissingResourceException e) {
                names[i] = token;
            }
        }

        return names;
    }

    /**
     * Format a list with an array of patterns.
     * @param patterns an array of three patterns. The first pattern is not
     * used. The second pattern should create a MessageFormat taking 0-3 arguments
     * and formatting them into a list. The third pattern should take 2 arguments
     * and is used by composeList. If patterns is null, then a the list is
     * formatted by concatenation with the delimiter ','.
     * @param stringList the list of strings to be formatted.
     * @return a string representing the list.
     */
    private static String formatList(String[] patterns, String[] stringList) {
        // If we have no list patterns, compose the list in a simple,
        // non-localized way.
        if (patterns == null) {
            StringBuffer result = new StringBuffer();
            for (int i=0; i<stringList.length; ++i) {
                if (i>0) result.append(',');
                result.append(stringList[i]);
            }
            return result.toString();
        }

        // Compose the list down to three elements if necessary
        if (stringList.length > 3) {
            MessageFormat format = new MessageFormat(patterns[2]);
            stringList = composeList(format, stringList);
        }

        // Rebuild the argument list with the list length as the first element
        Object[] args = new Object[stringList.length + 1];
        System.arraycopy(stringList, 0, args, 1, stringList.length);
        args[0] = new Integer(stringList.length);

        // Format it using the pattern in the resource
        MessageFormat format = new MessageFormat(patterns[1]);
        return format.format(args);
    }

    /**
     * Given a list of strings, return a list shortened to three elements.
     * Shorten it by applying the given format to the first two elements
     * recursively.
     * @param format a format which takes two arguments
     * @param list a list of strings
     * @return if the list is three elements or shorter, the same list;
     * otherwise, a new list of three elements.
     */
    private static String[] composeList(MessageFormat format, String[] list) {
        if (list.length <= 3) return list;

        // Use the given format to compose the first two elements into one
        String[] listItems = { list[0], list[1] };
        String newItem = format.format(listItems);

        // Form a new list one element shorter
        String[] newList = new String[list.length-1];
        System.arraycopy(list, 2, newList, 1, newList.length-1);
        newList[0] = newItem;

        // Recurse
        return composeList(format, newList);
    }

    /**
     * @serialData The first three fields are three <code>String</code> objects:
     * the first is a 2-letter ISO 639 code representing the locale's language,
     * the second is a 2-letter ISO 3166 code representing the locale's region or
     * country, and the third is an optional chain of variant codes defined by this
     * library.  Any of the fields may be the empty string.  The fourth field is an
     * <code>int</code> whose value is always -1.  This is a sentinel value indicating
     * the <code>Locale</code>'s hash code must be recomputed.
     */
    private void writeObject(ObjectOutputStream out) throws IOException {
        // hashcode is semantically transient.  We couldn't define it as transient
        // because versions of this class that DIDN'T declare it as transient have
        // already shipped.  What we're doing here is making sure that the written-out
        // version of hashcode is always -1, regardless of what's really stored there
        // (we hold onto the original value just in case someone might want it again).
        // Writing -1 ensures that version 1.1 Locales will always recalculate their
        // hash codes after being streamed back in.  This is necessary because
        // String.hashCode() calculates its hash code differently in 1.2 than it did
        // in 1.1.
        int temp = hashcode;
        hashcode = -1;
        out.defaultWriteObject();
        hashcode = temp;
    }

    /**
     * @serialData The first three fields are three <code>String</code> objects:
     * the first is a 2-letter ISO 639 code representing the locale's language,
     * the second is a 2-letter ISO 3166 code representing the locale's region or
     * country, and the third is an optional chain of variant codes defined by this
     * library.  Any of the fields may be the empty string.  The fourth field is an
     * <code>int</code>representing the locale's hash code, but is ignored by
     * <code>readObject()</code>.  Whatever this field's value, the hash code is
     * initialized to -1, a sentinel value that indicates the hash code must be
     * recomputed.
     */
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // hashcode is semantically transient.  We couldn't define it as transient
        // because versions of this class that DIDN'T declare is as transient have
        // already shipped.  This code makes sure that whatever value for hashcode
        // was written on the stream, we ignore it and recalculate it on demand.  This
        // is necessary because String.hashCode() calculates is hash code differently
        // in version 1.2 than it did in 1.1.
        in.defaultReadObject();
        hashcode = -1;
        language = convertOldISOCodes(language);
        country = country.intern();
        variant = variant.intern();
    }

    /**
     * List of all 2-letter language codes currently defined in ISO 639.
     * (Because the Java VM specification turns an array constant into executable code
     * that generates the array element by element, we keep the array in compressed
     * form in a single string and build the array from it at run time when requested.)
     * [We're now also using this table to store a mapping from 2-letter ISO language codes
     * to 3-letter ISO language codes.  Each group of characters consists of a comma, a
     * 2-letter code, and a 3-letter code.  We look up a 3-letter code by searching for
     * a comma followed by a 2-letter code and then getting the three letters following
     * the 2-letter code.]
     */
    private static String[] isoLanguages = null;
    private static final String compressedIsoLanguages =
        ",aaaar,ababk,afafr,amamh,arara,asasm,ayaym,azaze,babak,bebel,bgbul,bhbih,bibis,bnben,"
        + "bobod,brbre,cacat,cocos,csces,cycym,dadan,dedeu,dzdzo,elell,eneng,eoepo,esspa,"
        + "etest,eueus,fafas,fifin,fjfij,fofao,frfra,fyfry,gagai,gdgdh,glglg,gngrn,guguj,"
        + "hahau,heheb,hihin,hrhrv,huhun,hyhye,iaina,idind,ieile,ikipk,inind,isisl,itita,"
        + "iuiku,iwheb,jajpn,jiyid,jwjaw,kakat,kkkaz,klkal,kmkhm,knkan,kokor,kskas,kukur,"
        + "kykir,lalat,lnlin,lolao,ltlit,lvlav,mgmlg,mimri,mkmkd,mlmal,mnmon,momol,mrmar,"
        + "msmsa,mtmlt,mymya,nanau,nenep,nlnld,nonor,ococi,omorm,orori,papan,plpol,pspus,"
        + "ptpor,quque,rmroh,rnrun,roron,rurus,rwkin,sasan,sdsnd,sgsag,shsrp,sisin,skslk,"
        + "slslv,smsmo,snsna,sosom,sqsqi,srsrp,ssssw,stsot,susun,svswe,swswa,tatam,tetel,"
        + "tgtgk,ththa,titir,tktuk,tltgl,tntsn,toton,trtur,tstso,tttat,twtwi,uguig,ukukr,"
        + "ururd,uzuzb,vivie,vovol,wowol,xhxho,yiyid,yoyor,zazha,zhzho,zuzul";

    /**
     * List of all 2-letter country codes currently defined in ISO 3166.
     * (Because the Java VM specification turns an array constant into executable code
     * that generates the array element by element, we keep the array in compressed
     * form in a single string and build the array from it at run time when requested.)
     * [We're now also using this table to store a mapping from 2-letter ISO country codes
     * to 3-letter ISO country codes.  Each group of characters consists of a comma, a
     * 2-letter code, and a 3-letter code.  We look up a 3-letter code by searching for
     * a comma followed by a 2-letter code and then getting the three letters following
     * the 2-letter code.]
     */
    private static String[] isoCountries = null;
    private static final String compressedIsoCountries =
        ",ADAND,AEARE,AFAFG,AGATG,AIAIA,ALALB,AMARM,ANANT,AOAGO,AQATA,ARARG,ASASM,ATAUT,"
        + "AUAUS,AWABW,AZAZE,BABIH,BBBRB,BDBGD,BEBEL,BFBFA,BGBGR,BHBHR,BIBDI,BJBEN,BMBMU,"
        + "BNBRN,BOBOL,BRBRA,BSBHS,BTBTN,BVBVT,BWBWA,BYBLR,BZBLZ,CACAN,CCCCK,CFCAF,CGCOG,"
        + "CHCHE,CICIV,CKCOK,CLCHL,CMCMR,CNCHN,COCOL,CRCRI,CUCUB,CVCPV,CXCXR,CYCYP,CZCZE,"
        + "DEDEU,DJDJI,DKDNK,DMDMA,DODOM,DZDZA,ECECU,EEEST,EGEGY,EHESH,ERERI,ESESP,ETETH,"
        + "FIFIN,FJFJI,FKFLK,FMFSM,FOFRO,FRFRA,FXFXX,GAGAB,GBGBR,GDGRD,GEGEO,GFGUF,GHGHA,"
        + "GIGIB,GLGRL,GMGMB,GNGIN,GPGLP,GQGNQ,GRGRC,GSSGS,GTGTM,GUGUM,GWGNB,GYGUY,HKHKG,"
        + "HMHMD,HNHND,HRHRV,HTHTI,HUHUN,IDIDN,IEIRL,ILISR,ININD,IOIOT,IQIRQ,IRIRN,ISISL,"
        + "ITITA,JMJAM,JOJOR,JPJPN,KEKEN,KGKGZ,KHKHM,KIKIR,KMCOM,KNKNA,KPPRK,KRKOR,KWKWT,"
        + "KYCYM,KZKAZ,LALAO,LBLBN,LCLCA,LILIE,LKLKA,LRLBR,LSLSO,LTLTU,LULUX,LVLVA,LYLBY,"
        + "MAMAR,MCMCO,MDMDA,MGMDG,MHMHL,MKMKD,MLMLI,MMMMR,MNMNG,MOMAC,MPMNP,MQMTQ,MRMRT,"
        + "MSMSR,MTMLT,MUMUS,MVMDV,MWMWI,MXMEX,MYMYS,MZMOZ,NANAM,NCNCL,NENER,NFNFK,NGNGA,"
        + "NINIC,NLNLD,NONOR,NPNPL,NRNRU,NUNIU,NZNZL,OMOMN,PAPAN,PEPER,PFPYF,PGPNG,PHPHL,"
        + "PKPAK,PLPOL,PMSPM,PNPCN,PRPRI,PTPRT,PWPLW,PYPRY,QAQAT,REREU,ROROM,RURUS,RWRWA,"
        + "SASAU,SBSLB,SCSYC,SDSDN,SESWE,SGSGP,SHSHN,SISVN,SJSJM,SKSVK,SLSLE,SMSMR,SNSEN,"
        + "SOSOM,SRSUR,STSTP,SVSLV,SYSYR,SZSWZ,TCTCA,TDTCD,TFATF,TGTGO,THTHA,TJTJK,TKTKL,"
        + "TMTKM,TNTUN,TOTON,TPTMP,TRTUR,TTTTO,TVTUV,TWTWN,TZTZA,UAUKR,UGUGA,UMUMI,USUSA,"
        + "UYURY,UZUZB,VAVAT,VCVCT,VEVEN,VGVGB,VIVIR,VNVNM,VUVUT,WFWLF,WSWSM,YEYEM,YTMYT,"
        + "YUYUG,ZAZAF,ZMZMB,ZRZAR,ZWZWE";

    /*
     * Locale needs its own, locale insenitive version of toLowerCase to
     * avoid circularity problems between Locale and String.
     * The most straightforward algorithm is used. Look at optimizations later.
     */
    private String toLowerCase(String str) {
        char[] buf = str.toCharArray();
        for (int i = 0; i < buf.length; i++) {
            buf[i] = Character.toLowerCase( buf[i] );
        }
        return new String( buf );
    }

    /*
     * Locale needs its own, locale insensitive version of toUpperCase to
     * avoid circularity problems between Locale and String.
     * The most straightforward algorithm is used. Look at optimizations later.
     */
    private String toUpperCase(String str) {
        char[] buf = str.toCharArray();
        for (int i = 0; i < buf.length; i++) {
            buf[i] = Character.toUpperCase( buf[i] );
        }
        return new String( buf );
    }

    private String findStringMatch(String[][] languages,
                                   String desiredLanguage, String fallbackLanguage)
    {
        for (int i = 0; i < languages.length; ++i)
            if (desiredLanguage.equals(languages[i][0]))
                return languages[i][1];
        if (!fallbackLanguage.equals(desiredLanguage))
            for (int i = 0; i < languages.length; ++i)
                if (fallbackLanguage.equals(languages[i][0]))
                    return languages[i][1];
        if (!"EN".equals(desiredLanguage) && "EN".equals(fallbackLanguage))
            for (int i = 0; i < languages.length; ++i)
                if ("EN".equals(languages[i][0]))
                    return languages[i][1];
        return "";
    }

    private String convertOldISOCodes(String language) {
        // we accept both the old and the new ISO codes for the languages whose ISO
        // codes have changed, but we always store the OLD code, for backward compatibility
        language = toLowerCase(language).intern();
        if (language == "he") {
            return "iw";
        } else if (language == "yi") {
            return "ji";
        } else if (language == "id") {
            return "in";
        } else {
            return language;
        }
    }
}