शीर्षक मामले में स्ट्रिंग रूपांतरण के लिए एक विधि है?


99

क्या किसी मामले को शीर्षक केस प्रारूप में बदलने के लिए उपलब्ध तरीके हैं?


3
हर कोई इस सवाल को पढ़ रहा है: सावधान रहें कि यहाँ शीर्ष मतदान के कई उत्तर सभी भाषाओं के लिए काम नहीं करते हैं। ICU4J (जैसे डैनियल एफ का जवाब देखें) जैसे सही शीर्षक के लिए आपको एक i18n-जागरूक पुस्तकालय की आवश्यकता है।
sffc

जवाबों:


106

अपाचे कॉमन्स StringUtils.capitalize () या कॉमन्स पाठ WordUtils.capitalize ()

उदाहरण के लिए: WordUtils.capitalize("i am FINE") = "I Am FINE"से WordUtils डॉक


14
WordUtils.capitalizeFully () मेरे लिए बेहतर था क्योंकि यह देता है: WordUtils.capitalizeFully ("I am FINE") = "I Am Fine"
theINtoy

2
बस एक छोटा सा अपडेट, WordUtils कॉमन्स टेक्स्ट में चला गया है और कॉमन्स लैंग के अंदर पदावनत हो गया है
msrd0

वसंत भी हैStringUtils.capitalise()
ऑरेंजडॉग

@OrangeDog क्या आपका मतलब है capitalize()?
टायलरएच

@ टायलरएच हाँ, स्वतः पूर्ण हो गया
ऑरेंजडॉग

60

Java के String class में कोई capitalize () या titleCase () विधियाँ नहीं हैं। आपके पास दो विकल्प हैं:

 StringUtils.capitalize(null)  = null
 StringUtils.capitalize("")    = ""
 StringUtils.capitalize("cat") = "Cat"
 StringUtils.capitalize("cAt") = "CAt"
 StringUtils.capitalize("'cat'") = "'cat'"
  • लिखना (अभी तक) स्थिर सहायक विधि toTitleCase ()

नमूना कार्यान्वयन

public static String toTitleCase(String input) {
    StringBuilder titleCase = new StringBuilder(input.length());
    boolean nextTitleCase = true;

    for (char c : input.toCharArray()) {
        if (Character.isSpaceChar(c)) {
            nextTitleCase = true;
        } else if (nextTitleCase) {
            c = Character.toTitleCase(c);
            nextTitleCase = false;
        }

        titleCase.append(c);
    }

    return titleCase.toString();
}

परीक्षण का मामला

    System.out.println(toTitleCase("string"));
    System.out.println(toTitleCase("another string"));
    System.out.println(toTitleCase("YET ANOTHER STRING"));

आउटपुट:

तार
एक और स्ट्रिंग
YET ANOTHER STRING

1
यह एक छोटी सी दिनचर्या है, लेकिन यह अधिक सामान्य मामले के लिए विफल रहता है जिसमें स्ट्रिंग्स नामों का प्रतिनिधित्व कर सकते हैं। इस मामले में, पूंजीकरण को एपोस्ट्रोफ और हाइफ़न के बाद भी होने की आवश्यकता होगी। उदाहरण के लिए। ओ'कॉनर और जे। विल्केस-बूथ। बेशक, अन्य भाषाओं में अतिरिक्त शीर्षक केस नियम हो सकते हैं।
स्कॉटलैंड

... अगर यह शामिल करने जा रहे थे, तो क्या इसे पूरा शब्दकोश देखने की जरूरत है अगर वर्तमान शब्द एक नाम है? यह किसी भी एक विधि के लिए थोड़ा सा लगता है।
MMJZ

यह कोड लगभग ठीक है क्योंकि कुछ नामों में prepositons हो सकते हैं जैसे कि de, del, della, dei, da जैसे Maria del Carmen, Maria da Silva, Maria della Salute, आदि coderanch.com/t/35096-Programming/…
जूनियर मेहे

क्या यह एपोस्ट्रोफ से नहीं टूटता है? उदाहरण के लिए ओ'ब्रायन के बारे में क्या।
sproketboy

1
नोट: आंतरिक रूप से उपयोग किए जाने से बचने के लिए मैं सुझाव char[]देता StringBuilderहूंnew StringBuilder(input.length())
लिनो - वोट मत कहो

38

अगर मैं समाधान पर अपना ले जाऊं ...

निम्न विधि उस पोस्ट पर आधारित है जिसे dfa ने पोस्ट किया है। यह निम्नलिखित प्रमुख परिवर्तन करता है (जो उस समय मेरे लिए आवश्यक समाधान के अनुकूल है): यह इनपुट स्ट्रिंग में सभी वर्णों को निचले मामले में मजबूर करता है जब तक कि यह तुरंत "कार्रवाई योग्य सीमांकक" से पहले नहीं होता है, जिस स्थिति में चरित्र में सामंजस्य होता है अपरकेस।

मेरी दिनचर्या की एक प्रमुख सीमा यह है कि यह धारणा बनाता है कि "शीर्षक मामला" सभी स्थानों के लिए समान रूप से परिभाषित किया गया है और उसी मामले सम्मेलनों का प्रतिनिधित्व करता है जिसका मैंने उपयोग किया है और इसलिए यह उस संबंध में dfa के कोड से कम उपयोगी नहीं है।

public static String toDisplayCase(String s) {

    final String ACTIONABLE_DELIMITERS = " '-/"; // these cause the character following
                                                 // to be capitalized
    
    StringBuilder sb = new StringBuilder();
    boolean capNext = true;

    for (char c : s.toCharArray()) {
        c = (capNext)
                ? Character.toUpperCase(c)
                : Character.toLowerCase(c);
        sb.append(c);
        capNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0); // explicit cast not needed
    }
    return sb.toString();
}

टेस्ट वैल्यूज

एक स्ट्रिंग

मैरिन ओ'एलएलएलवाई

जॉन विल्स-बूथ

YET ANOTHER STRING

OUTPUTS

एक स्ट्रिंग

मार्टिन ओ'माल्ली

जॉन विल्क्स-बूथ

फिर भी एक और स्ट्रिंग


like की तरह ligatures के साथ काम नहीं करेगा, जिसका अपरकेस title है, लेकिन शीर्षक ig है। Character.toTitleCaseइसके बजाय उपयोग करें ।
मिही

@ मिमि: अन्य विशेष नियमों के साथ काम नहीं करेगा, जैसे। मैकनेमारा या मैकडोनाल्ड जैसे उपनाम।
दोपहर

लेकिन इन मामलों को स्वाभाविक रूप से तय नहीं किया जा सकता है। सही केस रूपांतरण फ़ंक्शन का उपयोग करना (शीर्षक को एक शब्द को कैपिटलाइज़ करने के लिए उपयोग किया जाना चाहिए, और अपरकेस नियमों के अनुसार अपरकेस) नहीं किया जा सकता है (और यह आसान है)।
मिही

नहीं होगा (यह नहीं होगा) भी "उसके" "HerS" बनने का कारण होगा?
एलिकार्नर

यह सच है। यह नाम फ़ील्ड पर अच्छा काम करता है, लेकिन जैसा कि आप बताते हैं, सामान्य गद्य पर नहीं। यह सभी नामों पर भी अच्छी तरह से काम नहीं करेगा, विशेष रूप से Vulcans (T'pau के बजाय T'Pau)।
scottb

21

अपाचे कॉमन्स से WordUtils.capitalizeFully () का उपयोग करें ।

WordUtils.capitalizeFully(null)        = null
WordUtils.capitalizeFully("")          = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"

1
अच्छा समाधान! धन्यवाद! लेकिन यह 100% समय के लिए काम नहीं करता है, क्योंकि यह भी इस शीर्षक में जैसे "" a "को कैपिटल करता है:" यह एक शीर्षक है "। English.stackexchange.com/questions/14/… देखें । क्या आप किसी ऐसे पुस्तकालय के बारे में जानते हैं जो इससे संबंधित है?
इरिक डब्ल्यू

10

आप इस तरह अपाचे कॉमन्स लैंग्स का उपयोग कर सकते हैं:

WordUtils.capitalizeFully("this is a text to be capitalize")

आप यहाँ जावा डॉक पा सकते हैं: WordUtils.capitalizeFully जावा डॉक

और यदि आप उन दुनिया के बीच के रिक्त स्थान को हटाना चाहते हैं जिनका आप उपयोग कर सकते हैं:

StringUtils.remove(WordUtils.capitalizeFully("this is a text to be capitalize")," ")

आप स्ट्रिंग के लिए जावा दस्तावेज़ पा सकते हैं StringUtils.remove जावा दस्तावेज़

मुझे उम्मीद है कि इस मदद


5

यदि आप नवीनतम यूनिकोड मानक के अनुसार सही उत्तर चाहते हैं, तो आपको icu4j का उपयोग करना चाहिए।

UCharacter.toTitleCase(Locale.US, "hello world", null, 0);

ध्यान दें कि यह स्थानीय संवेदनशील है।

एपि डॉक्यूमेंटेशन

कार्यान्वयन


नए ICU4J API CaseMap को भी देखें: icu-project.org/apiref/icu4j/com/ibm/icu/text/…
sffc

Android API स्तर 24 में भी उपलब्ध है: developer.android.com/reference/android/icu/lang/…
sffc

3

यहाँ @ dfa's और @ scottb के उत्तरों पर आधारित एक अन्य जानकारी दी गई है जो किसी भी गैर-अक्षर / अंक वर्णों को संभालती है:

public final class TitleCase {

    public static String toTitleCase(String input) {

        StringBuilder titleCase = new StringBuilder(input.length());
        boolean nextTitleCase = true;

        for (char c : input.toLowerCase().toCharArray()) {
            if (!Character.isLetterOrDigit(c)) {
                nextTitleCase = true;
            } else if (nextTitleCase) {
                c = Character.toTitleCase(c);
                nextTitleCase = false;
            }
            titleCase.append(c);
        }

        return titleCase.toString();
    }

}

दिए गए इनपुट:

MARY ŠNN O'CONNEŽ-IKUSLIK

आउटपुट है

मेरी Änn O'Connež-Äuslik


2

यह कुछ ऐसा है जिसे मैंने snake_case को लोअरकेमसेलकैसे में बदलने के लिए लिखा था, लेकिन आवश्यकताओं के आधार पर इसे आसानी से समायोजित किया जा सकता है

private String convertToLowerCamel(String startingText)
{
    String[] parts = startingText.split("_");
    return parts[0].toLowerCase() + Arrays.stream(parts)
                    .skip(1)
                    .map(part -> part.substring(0, 1).toUpperCase() + part.substring(1).toLowerCase())
                    .collect(Collectors.joining());
}

आपका जवाब एक आकर्षण की तरह काम करता है, हालांकि, समाधान एकल शब्द अनुक्रम को संभालने के लिए प्रतीत नहीं होता है, शायद एक अगर स्थिति पर्याप्त होनी चाहिए।
यशगर्ग १२३२

1

मुझे पता है कि यह एक पुराना है, लेकिन सरल उत्तर नहीं देता है, मुझे अपने कोडिंग के लिए इस पद्धति की आवश्यकता थी इसलिए मैंने यहां जोड़ा, उपयोग करने के लिए सरल।

public static String toTitleCase(String input) {
    input = input.toLowerCase();
    char c =  input.charAt(0);
    String s = new String("" + c);
    String f = s.toUpperCase();
    return f + input.substring(1);
}

1

मुझे यह समस्या थी और मैंने इसके लिए खोज की तो मैंने कुछ जावा कीवर्ड का उपयोग करके अपना तरीका बनाया, बस स्ट्रिंग वेरिएबल को पैरामीटर के रूप में पास करने और आउटपुट को उचित शीर्षक स्ट्रिंग के रूप में प्राप्त करने की आवश्यकता है।

public class Main
{
  public static void main (String[]args)
  {
    String st = "pARVeEN sISHOsIYA";
    String mainn = getTitleCase (st);
      System.out.println (mainn);
  }


  public static String getTitleCase(String input)
  {
    StringBuilder titleCase = new StringBuilder (input.length());
    boolean hadSpace = false;
    for (char c:input.toCharArray ()){
        if(Character.isSpaceChar(c)){
            hadSpace = true;
            titleCase.append (c);
            continue;
        }
        if(hadSpace){
            hadSpace = false;
            c = Character.toUpperCase(c);
            titleCase.append (c);
        }else{
            c = Character.toLowerCase(c);
            titleCase.append (c);
        }
    }
    String temp=titleCase.toString ();
    StringBuilder titleCase1 = new StringBuilder (temp.length ());
    int num=1;
    for (char c:temp.toCharArray ())
        {   if(num==1)
            c = Character.toUpperCase(c);
            titleCase1.append (c);
            num=0;
        }
        return titleCase1.toString ();
    }
}

यहाँ मुझे ट्रिम विधि का उपयोग नहीं करना चाहिए कहीं भी मेरे मामले में मुझे उचित ट्रिम किया गया स्ट्रिंग मिल रहा था।
परवीन शिशोदिया

0

आप बहुत अच्छी तरह से उपयोग कर सकते हैं

org.apache.commons.lang.WordUtils

या

CaseFormat

Google के API से।


1
यह विधि और एक उदाहरण को जोड़ने के लिए उपयोगी होगा।
jechaviz

CaseFormat में केवल प्रोग्राम आइडेंटिफ़ायर (अपरकंपेल, लोअर-हाइपेन, UPPER_UNDERSCORE, आदि) में उपयोग किए जाने वाले प्रारूप हैं और केवल ASCII टेक्स्ट का समर्थन करता है। यह टाइटल केस में परिवर्तित करने के लिए अच्छी तरह से काम नहीं करेगा।
एम। जस्टिन

0

मैं हाल ही में इस समस्या में भी भाग गया और दुर्भाग्य से मैक और मैक के साथ शुरू होने वाले नामों की कई घटनाएं हुईं, मैंने स्कॉट कोड के एक संस्करण का उपयोग करके समाप्त किया, जिसे मैंने इन उपसर्गों को संभालने के लिए बदल दिया है, इसलिए यह यहां है यदि कोई भी इसका उपयोग करना चाहता है।

अभी भी किनारे मामले हैं जो यह याद करते हैं लेकिन सबसे बुरी बात यह हो सकती है कि एक पत्र कम मामला होगा जब इसे कैपिटल किया जाना चाहिए।

/**
 * Get a nicely formatted representation of the name. 
 * Don't send this the whole name at once, instead send it the components.<br>
 * For example: andrew macnamara would be returned as:<br>
 * Andrew Macnamara if processed as a single string<br>
 * Andrew MacNamara if processed as 2 strings.
 * @param name
 * @return correctly formatted name
 */
public static String getNameTitleCase (String name) {
    final String ACTIONABLE_DELIMITERS = " '-/";
    StringBuilder sb = new StringBuilder();
    if (name !=null && !name.isEmpty()){                
        boolean capitaliseNext = true;
        for (char c : name.toCharArray()) {
            c = (capitaliseNext)?Character.toUpperCase(c):Character.toLowerCase(c);
            sb.append(c);
            capitaliseNext = (ACTIONABLE_DELIMITERS.indexOf((int) c) >= 0);
        }                       
        name = sb.toString();    
        if (name.startsWith("Mc") && name.length() > 2 ) {
            char c = name.charAt(2);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,2));
                sb.append (name.substring(2,3).toUpperCase());
                sb.append (name.substring(3));
                name=sb.toString();
            }               
        } else if (name.startsWith("Mac") && name.length() > 3) {
            char c = name.charAt(3);
            if (ACTIONABLE_DELIMITERS.indexOf((int) c) < 0) {
                sb = new StringBuilder();
                sb.append (name.substring(0,3));
                sb.append (name.substring(3,4).toUpperCase());
                sb.append (name.substring(4));
                name=sb.toString();
            }
        }
    }
    return name;    
}

0

उचित शीर्षक मामले में रूपांतरण:

String s= "ThiS iS SomE Text";
String[] arr = s.split(" ");
s = "";
for (String s1 : arr) {
    s += WordUtils.capitalize(s1.toLowerCase()) + " ";
}
s = s.substring(0, s.length() - 1);

परिणाम: "यह कुछ पाठ है"


0

वसंत का उपयोग करना StringUtils:

org.springframework.util.StringUtils.capitalize(someText);

यदि आप पहले से ही स्प्रिंग का उपयोग कर रहे हैं, तो यह दूसरे ढांचे में लाने से बचता है।


0

केस को शीर्षक में बदलने के लिए इस विधि का उपयोग करें:

static String toTitleCase(String word) {
    return Stream.of(word.split(" "))
            .map(w -> w.toUpperCase().charAt(0)+ w.toLowerCase().substring(1))
            .reduce((s, s2) -> s + " " + s2).orElse("");
}

0

यह कन्वर्टर ऊँट केस, व्हाइट-स्पेस, डिजिट और अन्य कैरेक्टर वाले किसी भी स्ट्रिंग को सैनिटाइज़्ड टाइटल केस में बदल देता है।

/**
 * Convert a string to title case in java (with tests).
 *
 * @author Sudipto Chandra
 */
public abstract class TitleCase {

    /**
     * Returns the character type. <br>
     * <br>
     * Digit = 2 <br>
     * Lower case alphabet = 0 <br>
     * Uppercase case alphabet = 1 <br>
     * All else = -1.
     *
     * @param ch
     * @return
     */
    private static int getCharType(char ch) {
        if (Character.isLowerCase(ch)) {
            return 0;
        } else if (Character.isUpperCase(ch)) {
            return 1;
        } else if (Character.isDigit(ch)) {
            return 2;
        }
        return -1;
    }

    /**
     * Converts any given string in camel or snake case to title case.
     * <br>
     * It uses the method getCharType and ignore any character that falls in
     * negative character type category. It separates two alphabets of not-equal
     * cases with a space. It accepts numbers and append it to the currently
     * running group, and puts a space at the end.
     * <br>
     * If the result is empty after the operations, original string is returned.
     *
     * @param text the text to be converted.
     * @return a title cased string
     */
    public static String titleCase(String text) {
        if (text == null || text.length() == 0) {
            return text;
        }

        char[] str = text.toCharArray();
        StringBuilder sb = new StringBuilder();

        boolean capRepeated = false;
        for (int i = 0, prev = -1, next; i < str.length; ++i, prev = next) {
            next = getCharType(str[i]);
            // trace consecutive capital cases
            if (prev == 1 && next == 1) {
                capRepeated = true;
            } else if (next != 0) {
                capRepeated = false;
            }
            // next is ignorable
            if (next == -1) {
                // System.out.printf("case 0, %d %d %s\n", prev, next, sb.toString());
                continue; // does not append anything
            }
            // prev and next are of same type
            if (prev == next) {
                sb.append(str[i]);
                // System.out.printf("case 1, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is not an alphabet
            if (next == 2) {
                sb.append(str[i]);
                // System.out.printf("case 2, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is an alphabet, prev was not +
            // next is uppercase and prev was lowercase
            if (prev == -1 || prev == 2 || prev == 0) {
                if (sb.length() != 0) {
                    sb.append(' ');
                }
                sb.append(Character.toUpperCase(str[i]));
                // System.out.printf("case 3, %d %d %s\n", prev, next, sb.toString());
                continue;
            }
            // next is lowercase and prev was uppercase
            if (prev == 1) {
                if (capRepeated) {
                    sb.insert(sb.length() - 1, ' ');
                    capRepeated = false;
                }
                sb.append(str[i]);
                // System.out.printf("case 4, %d %d %s\n", prev, next, sb.toString());
            }
        }
        String output = sb.toString().trim();
        output = (output.length() == 0) ? text : output;
        //return output;

        // Capitalize all words (Optional)
        String[] result = output.split(" ");
        for (int i = 0; i < result.length; ++i) {
            result[i] = result[i].charAt(0) + result[i].substring(1).toLowerCase();
        }
        output = String.join(" ", result);
        return output;
    }

    /**
     * Test method for the titleCase() function.
     */
    public static void testTitleCase() {
        System.out.println("--------------- Title Case Tests --------------------");
        String[][] samples = {
            {null, null},
            {"", ""},
            {"a", "A"},
            {"aa", "Aa"},
            {"aaa", "Aaa"},
            {"aC", "A C"},
            {"AC", "Ac"},
            {"aCa", "A Ca"},
            {"ACa", "A Ca"},
            {"aCamel", "A Camel"},
            {"anCamel", "An Camel"},
            {"CamelCase", "Camel Case"},
            {"camelCase", "Camel Case"},
            {"snake_case", "Snake Case"},
            {"toCamelCaseString", "To Camel Case String"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"ABDTest", "Abd Test"},
            {"title123Case", "Title123 Case"},
            {"expect11", "Expect11"},
            {"all0verMe3", "All0 Ver Me3"},
            {"___", "___"},
            {"__a__", "A"},
            {"_A_b_c____aa", "A B C Aa"},
            {"_get$It132done", "Get It132 Done"},
            {"_122_", "122"},
            {"_no112", "No112"},
            {"Case-13title", "Case13 Title"},
            {"-no-allow-", "No Allow"},
            {"_paren-_-allow--not!", "Paren Allow Not"},
            {"Other.Allow.--False?", "Other Allow False"},
            {"$39$ldl%LK3$lk_389$klnsl-32489  3 42034 ", "39 Ldl Lk3 Lk389 Klnsl32489342034"},
            {"tHis will BE MY EXAMple", "T His Will Be My Exa Mple"},
            {"stripEvery.damn-paren- -_now", "Strip Every Damn Paren Now"},
            {"getMe", "Get Me"},
            {"whatSthePoint", "What Sthe Point"},
            {"n0pe_aLoud", "N0 Pe A Loud"},
            {"canHave SpacesThere", "Can Have Spaces There"},
            {"  why_underScore exists  ", "Why Under Score Exists"},
            {"small-to-be-seen", "Small To Be Seen"},
            {"toCAMELCase", "To Camel Case"},
            {"_under_the_scoreCamelWith_", "Under The Score Camel With"},
            {"last one onTheList", "Last One On The List"}
        };
        int pass = 0;
        for (String[] inp : samples) {
            String out = titleCase(inp[0]);
            //String out = WordUtils.capitalizeFully(inp[0]);
            System.out.printf("TEST '%s'\nWANTS '%s'\nFOUND '%s'\n", inp[0], inp[1], out);
            boolean passed = (out == null ? inp[1] == null : out.equals(inp[1]));
            pass += passed ? 1 : 0;
            System.out.println(passed ? "-- PASS --" : "!! FAIL !!");
            System.out.println();
        }
        System.out.printf("\n%d Passed, %d Failed.\n", pass, samples.length - pass);
    }

    public static void main(String[] args) {
        // run tests
        testTitleCase();
    }
}

यहां कुछ इनपुट दिए गए हैं:

aCamel
TitleCase
snake_case
fromCamelCASEString
ABCTest
expect11
_paren-_-allow--not!
  why_underScore   exists  
last one onTheList 

और मेरे आउटपुट:

A Camel
Title Case
Snake Case
From Camel Case String
Abc Test
Expect11
Paren Allow Not
Why Under Score Exists
Last One On The List

0

ऐसा लगता है कि कोई भी उत्तर वास्तविक शीर्षक मामले में प्रारूपित नहीं करता है: "हाउ टू लैंड योर ड्रीम जॉब", "टू किल अ मॉकिंगबर्ड", आदि इसलिए मैंने अपनी विधि बनाई है। अंग्रेजी भाषाओं के ग्रंथों के लिए सबसे अच्छा काम करता है।

private final static Set<Character> TITLE_CASE_DELIMITERS = new HashSet<>();

  static {
    TITLE_CASE_DELIMITERS.add(' ');
    TITLE_CASE_DELIMITERS.add('.');
    TITLE_CASE_DELIMITERS.add(',');
    TITLE_CASE_DELIMITERS.add(';');
    TITLE_CASE_DELIMITERS.add('/');
    TITLE_CASE_DELIMITERS.add('-');
    TITLE_CASE_DELIMITERS.add('(');
    TITLE_CASE_DELIMITERS.add(')');
  }

  private final static Set<String> TITLE_SMALLCASED_WORDS = new HashSet<>();

  static {
    TITLE_SMALLCASED_WORDS.add("a");
    TITLE_SMALLCASED_WORDS.add("an");
    TITLE_SMALLCASED_WORDS.add("the");
    TITLE_SMALLCASED_WORDS.add("for");
    TITLE_SMALLCASED_WORDS.add("in");
    TITLE_SMALLCASED_WORDS.add("on");
    TITLE_SMALLCASED_WORDS.add("of");
    TITLE_SMALLCASED_WORDS.add("and");
    TITLE_SMALLCASED_WORDS.add("but");
    TITLE_SMALLCASED_WORDS.add("or");
    TITLE_SMALLCASED_WORDS.add("nor");
    TITLE_SMALLCASED_WORDS.add("to");
  }

  public static String toCapitalizedWord(String oneWord) {
    if (oneWord.length() < 1) {
      return oneWord.toUpperCase();
    }
    return "" + Character.toTitleCase(oneWord.charAt(0)) + oneWord.substring(1).toLowerCase();
  }

  public static String toTitledWord(String oneWord) {
    if (TITLE_SMALLCASED_WORDS.contains(oneWord.toLowerCase())) {
      return oneWord.toLowerCase();
    }
    return toCapitalizedWord(oneWord);
  }

  public static String toTitleCase(String str) {
    StringBuilder result = new StringBuilder();
    StringBuilder oneWord = new StringBuilder();

    char previousDelimiter = 'x';
    /* on start, always move to upper case */
    for (char c : str.toCharArray()) {
      if (TITLE_CASE_DELIMITERS.contains(c)) {
        if (previousDelimiter == '-' || previousDelimiter == 'x') {
          result.append(toCapitalizedWord(oneWord.toString()));
        } else {
          result.append(toTitledWord(oneWord.toString()));
        }
        oneWord.setLength(0);
        result.append(c);
        previousDelimiter = c;
      } else {
        oneWord.append(c);
      }
    }
    if (previousDelimiter == '-' || previousDelimiter == 'x') {
      result.append(toCapitalizedWord(oneWord.toString()));
    } else {
      result.append(toTitledWord(oneWord.toString()));
    }
    return result.toString();
  }

  public static void main(String[] args) {
    System.out.println(toTitleCase("one year in paris"));
    System.out.println(toTitleCase("How to Land Your Dream Job"));
  }

0

यह सबसे सरल उपाय है

    static void title(String a,String b){
    String ra = Character.toString(Character.toUpperCase(a.charAt(0)));
    String rb = Character.toString(Character.toUpperCase(b.charAt(0)));
    for(int i=1;i<a.length();i++){
        ra+=a.charAt(i);
    }
    for(int i=1;i<b.length();i++){
        rb+=b.charAt(i);
    }
    System.out.println(ra+" "+rb);

-1

यह काम करना चाहिए:

String str="i like pancakes";
String arr[]=str.split(" ");
String strNew="";
for(String str1:arr)
{
    Character oldchar=str1.charAt(0);
    Character newchar=Character.toUpperCase(str1.charAt(0));
    strNew=strNew+str1.replace(oldchar,newchar)+" ";    
}
System.out.println(strNew);

1
यह एक वैध जवाब नहीं है क्योंकि ओपी ने बिल्डिन फ़ंक्शन के लिए कहा था । टिप्पणी भी देखें जो इसके पीछे छिपी जटिलता को संबोधित करता है, अर्थात i18n।
माक्र्स

-2

किसी भी स्ट्रिंग को शीर्षक मामले में परिवर्तित करने का सबसे सरल तरीका है, googles पैकेज का उपयोग करना। org.apache.commons.lang.WordUtils

System.out.println(WordUtils.capitalizeFully("tHis will BE MY EXAMple"));

इसका परिणाम होगा

यह मेरा उदाहरण होगा

मुझे यकीन नहीं है कि इसका नाम "CapitalizeFully" क्यों रखा गया है, जहां वास्तव में फ़ंक्शन एक पूर्ण पूंजी परिणाम नहीं कर रहा है, लेकिन वैसे भी, हमें चाहिए कि उपकरण।


1
इसे नाम दिया गया है capitalizeFullyक्योंकि यह हर शब्द को कैपिटल करता है, जिसमें एक शीर्षक में निचला मामला भी शामिल होना चाहिए। grammar.about.com/od/tz/g/Title-Case.htm
aij

2
Apache Commons Google के स्वामित्व में नहीं है। यह अपाचे सॉफ्टवेयर फाउंडेशन द्वारा बनाए रखा गया है। commons.apache.org
ATutorMe

-3

माफ करना, मैं एक शुरुआत कर रहा हूँ तो मेरी कोडिंग आदत बेकार है!

public class TitleCase {

    String title(String sent)
    {   
        sent =sent.trim();
        sent = sent.toLowerCase();
        String[] str1=new String[sent.length()];
        for(int k=0;k<=str1.length-1;k++){
            str1[k]=sent.charAt(k)+"";
    }

        for(int i=0;i<=sent.length()-1;i++){
            if(i==0){
                String s= sent.charAt(i)+"";
                str1[i]=s.toUpperCase();
                }
            if(str1[i].equals(" ")){
                String s= sent.charAt(i+1)+"";
                str1[i+1]=s.toUpperCase();
                }

            System.out.print(str1[i]);
            }

        return "";
        }

    public static void main(String[] args) {
        TitleCase a = new TitleCase();
        System.out.println(a.title("   enter your Statement!"));
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.