जावा में स्ट्रिंग के पहले अक्षर को कैसे कैपिटल करें?

Question

मैं Stringउपयोगकर्ता से इनपुट प्राप्त करने के लिए जावा का उपयोग कर रहा हूं । मैं इस इनपुट के पहले अक्षर को कैपिटल बनाने की कोशिश कर रहा हूं।

मैंने यह कोशिश की:

String name;

BufferedReader br = new InputStreamReader(System.in);

String s1 = name.charAt(0).toUppercase());

System.out.println(s1 + name.substring(1));

जिसके कारण ये संकलक त्रुटियां हुईं:

• मिसमैच टाइप करें: InputStreamReader से BufferedReader में परिवर्तित नहीं हो सकता

• आदिम प्रकार के चर पर toUppercase () को लागू नहीं कर सकता

Comments

@ पोन्टस - मैं असहमत हूं। इनपुट "abcd" के लिए, OP आउटपुट "Abcd" चाहता है। यह बहुत स्पष्ट लगता है, हालांकि सवाल बेहतर हो सकता था।

— कोबी

stackoverflow.com/questions/1892765/…

— जिगर जोशी

चरित्र जावा में एक आदिम डेटा प्रकार है। आप डॉट (।) ऑपरेटर के साथ एक आदिम डेटा प्रकार को नियंत्रित नहीं कर सकते। आपको name.substring (0,1) द्वारा पहले वर्ण को प्रतिस्थापित करना होगा;

— दिवाकर राजेश

Answer 1

String str = "java";
String cap = str.substring(0, 1).toUpperCase() + str.substring(1);
// cap = "Java"

अपने उदाहरण के साथ:

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // Actually use the Reader
    String name = br.readLine();
    // Don't mistake String object with a Character object
    String s1 = name.substring(0, 1).toUpperCase();
    String nameCapitalized = s1 + name.substring(1);
    System.out.println(nameCapitalized);
}

Comments

मुझे लगता है कि आपको str.length () के बाद -1 की आवश्यकता है, अन्यथा आप सीमा से बाहर चले जाएंगे।

— दत्त

@ दत्त: नहीं वास्तव में, यह भी पूरी तरह से ठीक था। लेकिन रेकिन के संशोधन ने इसे सही बनाया। ;)

— अडेल अंसारी

कॉमन्स लैंग हमेशा दुर्लभ मामलों में जहां आप बेहतर जानते हैं, को छोड़कर अपने स्वयं के फ़ंक्शन को लिखने से बेहतर है। यदि आप पूंजीकरण समारोह पर कॉमन्स लैंग जावा डाओक को नहीं पढ़ते हैं, तो आपको अपना स्वयं का लेखन नहीं करना चाहिए।

— द लाफिंग.मन

Answer 2

StringUtils.capitalize(..) से कॉमन्स-लैंग

Comments

मैं WordUtils का उपयोग कर रहा था, इसमें एक ही फ़ंक्शन भी है लेकिन यह एक वाक्य में सभी शब्दों के पहले अक्षरों को कैपिटल करता है।

— सुरभि राव

StringUtils.capitalize( "fred from jupiter" );पैदा करता है "Fred from jupiter"। आसान ...: D

— udoline

WordUtils.capitalizeFully () मेरे लिए आकर्षण की तरह काम करता है जैसा कि यह देता है: WordUtils.capitalizeFully ("I am FINE") = "I Am Fine"

— अतुल शर्मा

Answer 3

स्ट्रिंग के पहले अक्षर को कैपिटल करने के लिए छोटा / तेज संस्करण कोड है:

String name  = "stackoverflow"; 
name = name.substring(0,1).toUpperCase() + name.substring(1).toLowerCase();

का मूल्य nameहै"Stackoverflow"

Comments

मुझे यह समाधान पसंद है क्योंकि यह सुनिश्चित करता है कि बाकी स्ट्रिंग लोअर-केस है। ALL_CAPS enum नामों से परिवर्तित करते समय मुझे यही आवश्यक है।

— एलेन स्पार्टस

Answer 4

अपाचे की सामान्य लाइब्रेरी का उपयोग करें। अपने दिमाग को इन सामानों से मुक्त करें और नल सूचक और सूचकांक से बाहर अपवाद से बचें

चरण 1:

build.gradleनिर्भरता में इसे डालकर अपाचे के सामान्य लैंग लाइब्रेरी को आयात करें

compile 'org.apache.commons:commons-lang3:3.6'

चरण 2:

यदि आप सुनिश्चित हैं कि आपका स्ट्रिंग सभी निचले मामले में है, या आप सभी की जरूरत है पहला पत्र शुरू करने के लिए, सीधे कॉल करें

StringUtils.capitalize(yourString);

यदि आप यह सुनिश्चित करना चाहते हैं कि केवल पहला अक्षर ही कैपिटल में आता है, जैसे कि ऐसा करने के लिए enum, toLowerCase()पहले कॉल करें और ध्यान रखें कि यह NullPointerExceptionइनपुट स्ट्रिंग के शून्य होने पर फेंक देगा ।

StringUtils.capitalize(YourEnum.STUFF.name().toLowerCase());
StringUtils.capitalize(yourString.toLowerCase());

यहां अपाचे द्वारा प्रदान किए गए अधिक नमूने हैं। यह अपवाद मुक्त है

StringUtils.capitalize(null)  = null
StringUtils.capitalize("")    = ""
StringUtils.capitalize("cat") = "Cat"
StringUtils.capitalize("cAt") = "CAt"
StringUtils.capitalize("'cat'") = "'cat'"

ध्यान दें:

WordUtilsइस लाइब्रेरी में भी शामिल है, लेकिन यह पदावनत है। कृपया इसका उपयोग न करें।

Comments

धन्यवाद। मैं विश्वास नहीं कर सकता कि लोग इस तरह के कार्य के लिए लूप का उपयोग करने के बारे में भी सोचते हैं

— अल्वारो

@ अलवारो, दिन के अंत में - लोग इस कार्य के लिए लूप का उपयोग करते हैं, अपाचे स्रोत कोड की जांच करते हैं। इसका मतलब यह नहीं है कि लोगों को अच्छी तरह से परीक्षण किए गए समाधान का उपयोग नहीं करना चाहिए।

— यूरी Chernyshov

@YuriyChernyshov यकीन है, मेरा मतलब है कि वे सबसे अधिक भाग के लिए उत्पादन कोड के लिए पहिया को सुदृढ़ नहीं करना चाहिए

— अल्वारो

WordUtils.capitalizeFully () मेरे लिए आकर्षण की तरह काम करता है जैसा कि यह देता है: WordUtils.capitalizeFully ("I am FINE") = "I Am Fine"

— अतुल शर्मा

मैं बाहरी पुस्तकालयों के लिए कभी नहीं जाऊंगा, जैसे छोटे उद्देश्य के लिए How to capitalize the first letter of a String in Java?।

— स्टैक ओवरफ्लो

Answer 5

जावा:

हर स्ट्रिंग को बड़ा करने के लिए बस एक सहायक विधि।

public static String capitalize(String str)
{
    if(str == null) return str;
    return str.substring(0, 1).toUpperCase() + str.substring(1);
}

इसके बाद बस कॉल करें str = capitalize(str)

---

Kotlin:

str.capitalize()

Comments

यह एक अपवाद है अगर strशून्य है। स्ट्रिंग की जाँच करें अशक्त नहीं है और इसका उपयोग करने से पहले कम से कम एक चरित्र है।

— attacomsian

@attacomsian आप सही मैं अद्यतन जावा कोड हैं, और Kotlin के लिए आप str .capitalize () का उपयोग कर सकते हैं?

— आमिर हुसैन घसेमी

Answer 6

आप जो करना चाहते हैं, वह यह है:

s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

(पहले चार्ट को अपरकेस में कनवर्ट करता है और मूल स्ट्रिंग के शेष को जोड़ता है)

इसके अलावा, आप एक इनपुट स्ट्रीम रीडर बनाते हैं, लेकिन कभी भी कोई लाइन नहीं पढ़ते हैं। इस प्रकार nameहमेशा रहेगा null।

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

BufferedReader br = new InputstreamReader(System.in);
String name = br.readLine();
String s1 = name.substring(0, 1).toUpperCase() + name.substring(1);

Answer 7

WordUtils.capitalize(java.lang.String)से अपाचे कॉमन्स ।

Comments

नमस्ते! क्या आप कृपया बता सकते हैं कि इसे मेरी परियोजना में कैसे लागू किया जाए? मैं आपके URL में कोई भी फ़ाइल डाउनलोड लिंक देख सकता हूं। धन्यवाद

— GrayFox

यह विधि पदावनत है। कृपया कॉमन्स-लैंग से

— स्ट्रिन्गटिल्स का

Answer 8

नीचे समाधान काम करेगा।

String A = "stackOverflow";
String ACaps = A.toUpperCase().charAt(0)+A.substring(1,A.length());
//Will print StackOverflow

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

Comments

प्रश्न में toUpperCase प्रतिबंधित है।

— हरप्रीत संधू - TheRootCoder

सवाल में, वह आदिम पर टॉपर कैस की कोशिश कर रहा था जो काम नहीं करेगा।

— जिजिल कक्कड़थु

ओह। मुझे वह बात याद आ गई। (y)

— हरप्रीत संधू - TheRootCoder

महान उत्तर प्रिय

— दुलज कुलथुंगा

Answer 9

का उपयोग करें WordUtils.capitalize(str)।

Comments

यह भी उल्लेख करना चाहिए कि यह कौन सा पुस्तकालय है।

— फ्रीलांसर

Answer 10

सबसे छोटा भी:

String message = "my message";    
message = Character.toUpperCase(message.charAt(0)) + message.substring(1);
System.out.println(message)    // Will output: My message

मेरे लिए काम किया।

Answer 11

स्ट्रिंग को लोअर केस में सेट करें, फिर पहले लेटर को इस तरह ऊपरी पर सेट करें:

    userName = userName.toLowerCase();

फिर पहले अक्षर को कैपिटल करने के लिए:

    userName = userName.substring(0, 1).toUpperCase() + userName.substring(1).toLowerCase();

प्रतिस्थापन केवल एक बड़ी स्ट्रिंग का एक टुकड़ा हो रहा है, तो हम उन्हें वापस एक साथ जोड़ रहे हैं।

Comments

मैं इसे कैसे प्राप्त करूं, कोड की पहली पंक्ति बेकार है, क्योंकि शेष स्ट्रिंग या तो निचले मामले में सेट है।

— Håvard Nygård

Answer 12

WordUtils.capitalizeFully () के बारे में क्या ?

import org.apache.commons.lang3.text.WordUtils;

public class Main {

    public static void main(String[] args) {

        final String str1 = "HELLO WORLD";
        System.out.println(capitalizeFirstLetter(str1)); // output: Hello World

        final String str2 = "Hello WORLD";
        System.out.println(capitalizeFirstLetter(str2)); // output: Hello World

        final String str3 = "hello world";
        System.out.println(capitalizeFirstLetter(str3)); // output: Hello World

        final String str4 = "heLLo wORld";
        System.out.println(capitalizeFirstLetter(str4)); // output: Hello World
    }

    private static String capitalizeFirstLetter(String str) {
        return WordUtils.capitalizeFully(str);
    }
}

Answer 13

राजधानी में सभी पहले पत्र प्राप्त करने के लिए इस उपयोगिता विधि का उपयोग करें।

String captializeAllFirstLetter(String name) 
{
    char[] array = name.toCharArray();
    array[0] = Character.toUpperCase(array[0]);

    for (int i = 1; i < array.length; i++) {
        if (Character.isWhitespace(array[i - 1])) {
            array[i] = Character.toUpperCase(array[i]);
        }
    }

    return new String(array);
}

Answer 14

String str1 = "hello";
str1.substring(0, 1).toUpperCase()+str1.substring(1);

Answer 15

आप यह भी आज़मा सकते हैं:

 String s1 = br.readLine();
 char[] chars = s1.toCharArray();
 chars[0] = Character.toUpperCase(chars[0]);
 s1= new String(chars);
 System.out.println(s1);

यह सबस्ट्रिंग का उपयोग करने की तुलना में बेहतर (अनुकूलित) है। (लेकिन छोटे स्ट्रिंग पर चिंता करने की नहीं)

Answer 16

आप ऐसा करने के substring()लिए उपयोग कर सकते हैं ।

लेकिन दो अलग-अलग मामले हैं:

मामला एक

यदि Stringआप पूंजीकरण को मानव-पठनीय मानते हैं, तो आपको डिफ़ॉल्ट लोकेल को भी निर्दिष्ट करना चाहिए:

String firstLetterCapitalized = 
    myString.substring(0, 1).toUpperCase(Locale.getDefault()) + myString.substring(1);

केस 2

यदि Stringआप कैपिटलाइज़ कर रहे हैं तो मशीन-पठनीय होने का मतलब है, उपयोग करने से बचें Locale.getDefault()क्योंकि जो स्ट्रिंग लौटा है वह विभिन्न क्षेत्रों में असंगत होगा, और इस मामले में हमेशा एक ही स्थान निर्दिष्ट करें (उदाहरण के लिए, toUpperCase(Locale.ENGLISH))। यह सुनिश्चित करेगा कि आंतरिक प्रसंस्करण के लिए आपके द्वारा उपयोग किए जा रहे तार संगत हैं, जो आपको मुश्किल से ढूंढने वाले कीड़ों से बचने में मदद करेंगे।

नोट: आप निर्दिष्ट करने के लिए की जरूरत नहीं है Locale.getDefault()के लिए toLowerCase()के रूप में इस स्वचालित रूप से किया जाता है।

Answer 17

Android स्टूडियो में

इस निर्भरता को अपने में जोड़ें build.gradle (Module: app)

dependencies {
    ...
    compile 'org.apache.commons:commons-lang3:3.1'
    ...
}

अब आप उपयोग कर सकते हैं

String string = "STRING WITH ALL CAPPS AND SPACES";

string = string.toLowerCase(); // Make all lowercase if you have caps

someTextView.setText(WordUtils.capitalize(string));

Answer 18

यदि आप SPRING का उपयोग करते हैं :

import static org.springframework.util.StringUtils.capitalize;
...


    return capitalize(name);

नोट: यदि आपके पास पहले से ही Apache Common Lang निर्भरता है, तो उनके StringUtils.capitalize का उपयोग करने पर विचार करें क्योंकि अन्य उत्तर सुझाते हैं।

प्रभाव: https://github.com/spring-projects/spring-framework/blob/64440a5f04a17b3728234afaa89f57766768decb-spring-core/sain/java/org/springframework/util/util/util

REF: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/util/StringUtils.html#capitalise-java.lang.String-

Answer 19

यह 101% काम करेगा

public class UpperCase {

    public static void main(String [] args) {

        String name;

        System.out.print("INPUT: ");
        Scanner scan = new Scanner(System.in);
        name  = scan.next();

        String upperCase = name.substring(0, 1).toUpperCase() + name.substring(1);
        System.out.println("OUTPUT: " + upperCase); 

    }

}

Answer 20

यह सिर्फ आपको दिखाने के लिए है, कि आप गलत नहीं थे।

BufferedReader br = new InputstreamReader(System.in);
// Assuming name is not blank
String name = br.readLine(); 

//No more error telling that you cant convert char to string
String s1 = (""+name.charAt(0)).toUppercase());
// Or, as Carlos prefers. See the comments to this post.
String s1 = Character.toString(name.charAt(0)).toUppercase());

System.out.println(s1+name.substring(1));

नोट: यह ऐसा करने के लिए सबसे अच्छा तरीका नहीं है। यह सिर्फ ओपी को दिखाने के लिए है कि इसे भी इस्तेमाल किया जा सकता है charAt()। ;)

Comments

+1 "गलत नहीं है" के लिए। मैं होगा पसंद करते हैं Character.toString(name.charAt(0)) के बजाय ""+name.charAt(0)क्या मैं वास्तव में क्या करना चाहते हैं दिखाने के लिए।

— user85421

कोई अशक्त लंबाई जाँच .. लंबाई शून्य हो सकती है।

— क्रिसपिक्स

Answer 21

यह काम करेगा

char[] array = value.toCharArray();

array[0] = Character.toUpperCase(array[0]);

String result = new String(array);

Answer 22

आप निम्नलिखित कोड का उपयोग कर सकते हैं:

public static void main(String[] args) {

    capitalizeFirstLetter("java");
    capitalizeFirstLetter("java developer");
}

public static void capitalizeFirstLetter(String text) {

    StringBuilder str = new StringBuilder();

    String[] tokens = text.split("\\s");// Can be space,comma or hyphen

    for (String token : tokens) {
        str.append(Character.toUpperCase(token.charAt(0))).append(token.substring(1)).append(" ");
    }
    str.toString().trim(); // Trim trailing space

    System.out.println(str);

}

Answer 23

इसको आजमाओ

यह विधि क्या करती है, "हैलो दुनिया" शब्द पर विचार करें यह विधि इसे "हैलो वर्ल्ड" में बदल देती है, प्रत्येक शब्द की शुरुआत को कैपिटलाइज़ करें।

 private String capitalizer(String word){

        String[] words = word.split(" ");
        StringBuilder sb = new StringBuilder();
        if (words[0].length() > 0) {
            sb.append(Character.toUpperCase(words[0].charAt(0)) + words[0].subSequence(1, words[0].length()).toString().toLowerCase());
            for (int i = 1; i < words.length; i++) {
                sb.append(" ");
                sb.append(Character.toUpperCase(words[i].charAt(0)) + words[i].subSequence(1, words[i].length()).toString().toLowerCase());
            }
        }
        return  sb.toString();

    }

Comments

लेकिन यह कोड बहुत अधिक समझ में आता है, सभी तरीकों को उनके नाम से भी समझना आसान है। लेकिन आपकी टिप्पणी के लिए धन्यवाद, अगली बार से और अधिक परिपूर्ण बनाने की कोशिश करेंगे, मैं कुछ समय बहुत आलसी हो जाता हूं :-)।

— आमीन माहेन

एक जादू की तरह काम करता है!

— विंसबल

Answer 24

दिए गए उत्तर केवल एक शब्द के पहले अक्षर को कैपिटलाइज़ करने के लिए है। एक पूरी स्ट्रिंग को कैपिटल करने के लिए निम्नलिखित कोड का उपयोग करें।

public static void main(String[] args) {
    String str = "this is a random string";
    StringBuilder capitalizedString = new StringBuilder();
    String[] splited = str.trim().split("\\s+");

    for (String string : splited) {         
        String s1 = string.substring(0, 1).toUpperCase();
        String nameCapitalized = s1 + string.substring(1);

        capitalizedString.append(nameCapitalized);
        capitalizedString.append(" ");
    }
    System.out.println(capitalizedString.toString().trim());
}

आउटपुट: This Is A Random String

Answer 25

यदि इनपुट अपरकेस है, तो निम्न का उपयोग करें:

str.substring (0, 1) .toUpperCase () + str.substring (1) .toLowerCase ();

यदि इनपुट लोअरकेस है, तो निम्न का उपयोग करें:

str.substring (0, 1) .toUpperCase () + str.substring (1);

Answer 26

ACL WordUtils पर एक नजर।

WordUtils.capitalize ("अपनी स्ट्रिंग") == "आपका स्ट्रिंग"

एक स्ट्रिंग में शब्द के हर पहले अक्षर को ऊपरी मामले में कैसे करें?

Answer 27

public static String capitalizer(final String texto) {

    // split words
    String[] palavras = texto.split(" ");
    StringBuilder sb = new StringBuilder();

    // list of word exceptions
    List<String> excessoes = new ArrayList<String>(Arrays.asList("de", "da", "das", "do", "dos", "na", "nas", "no", "nos", "a", "e", "o", "em", "com"));

    for (String palavra : palavras) {

        if (excessoes.contains(palavra.toLowerCase()))
            sb.append(palavra.toLowerCase()).append(" ");
        else
            sb.append(Character.toUpperCase(palavra.charAt(0))).append(palavra.substring(1).toLowerCase()).append(" ");
    }
    return sb.toString().trim();
}

Answer 28

आप निम्नलिखित कोड का उपयोग कर सकते हैं:

public static String capitalizeString(String string) {

    if (string == null || string.trim().isEmpty()) {
        return string;
    }
    char c[] = string.trim().toLowerCase().toCharArray();
    c[0] = Character.toUpperCase(c[0]);

    return new String(c);

}

उदाहरण के साथ परीक्षा JUnit:

@Test
public void capitalizeStringUpperCaseTest() {

    String string = "HELLO WORLD  ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

@Test
public void capitalizeStringLowerCaseTest() {

    String string = "hello world  ";

    string = capitalizeString(string);

    assertThat(string, is("Hello world"));
}

Answer 29

commons.lang.StringUtilsसबसे अच्छे उत्तर का उपयोग करना है:

public static String capitalize(String str) {  
    int strLen;  
    return str != null && (strLen = str.length()) != 0 ? (new StringBuffer(strLen)).append(Character.toTitleCase(str.charAt(0))).append(str.substring(1)).toString() : str;  
}

मुझे यह शानदार लगता है क्योंकि यह स्ट्रिंग को स्ट्रिंगरबफ़र के साथ लपेटता है। आप StringBuffer को अपनी इच्छानुसार और यद्यपि उसी उदाहरण का उपयोग करके हेरफेर कर सकते हैं।

Answer 30

फिर भी एक और उदाहरण, आप उपयोगकर्ता इनपुट के पहले अक्षर को कैसे बड़ा कर सकते हैं:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String string = br.readLine();
// handle supplementary characters
IntStream.concat(
        IntStream.of(string.codePointAt(0))
                .map(Character::toUpperCase), string.codePoints().skip(1)
)
.forEach(cp -> System.out.print(Character.toChars(cp)));