जावा का उपयोग करते हुए एक स्ट्रिंग में शब्द के पहले अक्षर को कैसे कैपिटल करें?

Question

उदाहरण तार

one thousand only
two hundred
twenty
seven

मैं कैपिटल लेटर में स्ट्रिंग के पहले कैरेक्टर को कैसे बदलूं और किसी अन्य लेटर के केस को नहीं बदलूं?

परिवर्तन के बाद यह होना चाहिए:

One thousand only
Two hundred
Twenty
Seven

नोट: मैं ऐसा करने के लिए apache.commons.lang.WordUtils का उपयोग नहीं करना चाहता।

Comments

@eat_a_lemon: चरित्र से बेहतर उपयोग करना।

— साइमन निकर्सन

संबं

— धत लं क

Answer 1

यदि आप केवल नाम वाले स्ट्रिंग के पहले अक्षर को कैपिटलाइज़ करना चाहते हैं inputऔर बाकी को अकेले छोड़ दें:

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

अब outputवही होगा जो आप चाहते हैं। जांचें कि आपका inputउपयोग करने से पहले यह कम से कम एक वर्ण है, अन्यथा आपको एक अपवाद मिलेगा।

Comments

इसके अलावा, मैं पहले पूरे इनपुट को ले लूंगा और इसे निम्न-केस बना दूंगा या आपके उदाहरण को निम्नानुसार बना दूंगा: स्ट्रिंग आउटपुट = input.substring (0, 1) .toUpperCase () + input.substring (1) .toLowerCase ();

— डेविड ब्रोडार्ड

और आप स्ट्रिंग की लंबाई की जांच करना चाहते हैं, क्योंकि यह 1 अक्षर स्ट्रिंग हो सकता है, या यहां तक ​​कि 0.

— मारेक

मुझे यह गटर और सेटर नाम निर्माण के लिए मिला है, इसलिए बाकी स्ट्रिंग पर लोअरकेस को क्षेत्र के नामकरण को तोड़ देगा। दिया जवाब मेरे लिए एकदम सही है।

— केसर

Answer 2

public String capitalizeFirstLetter(String original) {
    if (original == null || original.length() == 0) {
        return original;
    }
    return original.substring(0, 1).toUpperCase() + original.substring(1);
}

बस ... एक पूर्ण समाधान, मैं इसे इस तरह देखता हूँ जैसे कि बाकी सभी ने पोस्टिंग समाप्त कर दी = पी।

Comments

अच्छा लगा। मैं इसे "वन-लाइनर्ड" करता return original.length() == 0 ? original : original.substring(0, 1).toUpperCase() + original.substring(1);

— हूं

@ शेमर: if length() == 0क्या हम सुरक्षित रूप से यह नहीं कह सकते कि यह है ""और इसके बजाय वापस लौटना है original? हमें एक लाइनर में कुछ अक्षर बचाता है। मैं पूछता हूं क्योंकि मुझे लगता है कि जावा एक ऐसी भाषा है जो गोटे से भरी हुई है, मुझे ईमानदारी से आश्चर्य नहीं होगा अगर लंबाई शून्य का एक स्ट्रिंग करने का कोई और तरीका था।

— ArtOfWarfare

तुम सब सच बोलते हो @ArtOfWarfare।

— मार्पर

नोट: आप गैर-अंग्रेजी अक्षरों के साथ भी यह काम करना चाहते हैं। उस स्थिति में आपको लोकल इनयूपरकैस () विधि को निर्दिष्ट करना चाहिए।

— मकाले

String.toUpperCase(Locale)एक मनमाना स्ट्रिंग के लिए उपयोग करना संभव नहीं है , क्योंकि लोकेल को पाठ से मेल खाना है। हां, इसका उपयोग किया जाना चाहिए, लेकिन यह हमेशा स्पष्ट नहीं होता है कि Locale

— क्रिस्टोफर शुल्त्ज़

Answer 3

सरलतम तरीका org.apache.commons.lang.StringUtilsवर्ग का उपयोग करना है

StringUtils.capitalize(Str);

Comments

थोड़ा साइड-नोट यहाँ। यह केवल उन स्ट्रिंग्स के लिए काम करता है जो पहले से कैपिटल नहीं हैं।

— जॉबबर्ट

@jobbert कृपया अपनी टिप्पणी स्पष्ट करें। यदि तार पहले से ही पूंजीकृत हैं, तो क्या यह एक विधि नाम होने के बावजूद उन लोगों को अप्रभावित करेगा capitalize?

— C --ur

Answer 4

इसके अलावा, वहाँ org.springframework.util.StringUtilsमें स्प्रिंग फ्रेमवर्क :

StringUtils.capitalize(str);

Answer 5

StringUtils.capitalize(str)

से Apache Commons-लैंग ।

Comments

हसीब के जवाब की नकल ।

— C --ur

Answer 6

String sentence = "ToDAY   WeAthEr   GREat";    
public static String upperCaseWords(String sentence) {
        String words[] = sentence.replaceAll("\\s+", " ").trim().split(" ");
        String newSentence = "";
        for (String word : words) {
            for (int i = 0; i < word.length(); i++)
                newSentence = newSentence + ((i == 0) ? word.substring(i, i + 1).toUpperCase(): 
                    (i != word.length() - 1) ? word.substring(i, i + 1).toLowerCase() : word.substring(i, i + 1).toLowerCase().toLowerCase() + " ");
        }

        return newSentence;
    }
//Today Weather Great

Comments

यह ओपी के सवाल का जवाब नहीं देता है। चूंकि यह अन्य अक्षरों का मामला बदलता है।

— लेउवे रूइजाक्कर्स

प्रश्न को देखो। शायद, आपको प्रश्न अच्छी तरह से नहीं मिला।

— समेट SamZTOPRAK

Answer 7

String s=t.getText().trim();
int l=s.length();
char c=Character.toUpperCase(s.charAt(0));
s=c+s.substring(1);
for(int i=1; i<l; i++)
    {
        if(s.charAt(i)==' ')
        {
            c=Character.toUpperCase(s.charAt(i+1));
            s=s.substring(0, i) + c + s.substring(i+2);
        }
    }
    t.setText(s);

Comments

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

— Tobias_k

Answer 8

यहाँ आप जाते हैं (आशा है कि यह आपको विचार देगा):

/*************************************************************************
 *  Compilation:  javac Capitalize.java
 *  Execution:    java Capitalize < input.txt
 * 
 *  Read in a sequence of words from standard input and capitalize each
 *  one (make first letter uppercase; make rest lowercase).
 *
 *  % java Capitalize
 *  now is the time for all good 
 *  Now Is The Time For All Good 
 *  to be or not to be that is the question
 *  To Be Or Not To Be That Is The Question 
 *
 *  Remark: replace sequence of whitespace with a single space.
 *
 *************************************************************************/

public class Capitalize {

    public static String capitalize(String s) {
        if (s.length() == 0) return s;
        return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
    }

    public static void main(String[] args) {
        while (!StdIn.isEmpty()) {
            String line = StdIn.readLine();
            String[] words = line.split("\\s");
            for (String s : words) {
                StdOut.print(capitalize(s) + " ");
            }
            StdOut.println();
        }
    }

}

Comments

और अन्य पत्रों का मामला नहीं बदला। इसके अलावा के आपके उपयोग StdInऔर StdOutबहुत जावा-y नहीं है। :-)

— साइमन निकर्सन

Answer 9

इसके लिए इसका सरल केवल एक लाइन कोड आवश्यक है। यदि String A = scanner.nextLine(); तब आपको इस पहले अक्षर को बड़े अक्षरों के साथ प्रदर्शित करने के लिए लिखना होगा।

System.out.println(A.substring(0, 1).toUpperCase() + A.substring(1));

और अब यह किया है।

Answer 10

StringTokenizer वर्ग का उपयोग करके उदाहरण:

String st = "  hello all students";
String st1;
char f;
String fs="";
StringTokenizer a= new StringTokenizer(st);
while(a.hasMoreTokens()){   
        st1=a.nextToken();
        f=Character.toUpperCase(st1.charAt(0));
        fs+=f+ st1.substring(1);
        System.out.println(fs);
} 

Answer 11

StringBuilder के साथ समाधान:

value = new StringBuilder()
                .append(value.substring(0, 1).toUpperCase())
                .append(value.substring(1))
                .toString();

.. पिछले उत्तरों पर आधारित

Answer 12

सब कुछ एक साथ जोड़ना, स्ट्रिंग की शुरुआत में अतिरिक्त सफेद स्थान के लिए ट्रिम करना एक अच्छा विचार है। अन्यथा, .substring (0,1) .toUpperCase एक सफेद स्थान को कैपिटल करने की कोशिश करेगा।

    public String capitalizeFirstLetter(String original) {
        if (original == null || original.length() == 0) {
            return original;
        }
        return original.trim().substring(0, 1).toUpperCase() + original.substring(1);
    }

Answer 13

मेरा क्रियात्मक दृष्टिकोण। पूरे पैराग्राफ में व्हाट्सएप के बाद वाक्य में इसका पहला अक्षर।

शब्द के केवल पहले वर्ण को कैपिटलाइज़ करने के लिए .split ("") हटा दें

           b.name.split(" ")
                 .filter { !it.isEmpty() }
                 .map { it.substring(0, 1).toUpperCase() 
                 +it.substring(1).toLowerCase() }
                  .joinToString(" ")

Answer 14

जुलाई 2019 को अपडेट करें

वर्तमान में, यह करने के लिए सबसे अद्यतित पुस्तकालय समारोह में निहित है org.apache.commons.lang3.StringUtils

import org.apache.commons.lang3.StringUtils;

StringUtils.capitalize(myString);

यदि आप मावेन का उपयोग कर रहे हैं, तो अपने pom.xml में निर्भरता आयात करें:

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.9</version>
</dependency>

Answer 15

यहां तक ​​कि "सरल" कोड के लिए, मैं पुस्तकालयों का उपयोग करूंगा। बात प्रति कोड नहीं है, लेकिन पहले से ही मौजूदा परीक्षण मामलों में असाधारण मामले शामिल हैं। यह nullअन्य भाषाओं में रिक्त तार, तार हो सकता है ।

शब्द हेरफेर भाग को ouf Apache Commons Lang से हटा दिया गया है। इसे अब Apache Commons Text में रखा गया है । इसे https://search.maven.org/artifact/org.apache.commons/commons-text के माध्यम से प्राप्त करें ।

आप Apache Commons Text से WordUtils.capitalize (String str) का उपयोग कर सकते हैं । यह आपके द्वारा मांगे जाने से अधिक शक्तिशाली है। यह फुलेल को भी कैपिटल कर सकता है (जैसे, फिक्सिंग "oNe tousand only")।

चूंकि यह पूर्ण पाठ पर काम करता है, इसलिए इसे केवल पहले शब्द को कैपिटलाइज़ करने के लिए बताना होगा।

WordUtils.capitalize("one thousand only", new char[0]);

कार्यक्षमता के साथ खेलने के लिए पूर्ण JUnit वर्ग:

package io.github.koppor;

import org.apache.commons.text.WordUtils;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class AppTest {

  @Test
  void test() {
    assertEquals("One thousand only", WordUtils.capitalize("one thousand only", new char[0]));
  }

}

Answer 16

यदि आप केवल पहले अक्षर को कैपिटलाइज़ करना चाहते हैं तो नीचे दिए गए कोड का उपयोग किया जा सकता है

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

Answer 17

वास्तव में, आपको सबसे अच्छा प्रदर्शन मिलेगा यदि आप +ऑपरेटर से बचते हैं और concat()इस मामले में उपयोग करते हैं । यह सिर्फ 2 स्ट्रिंग्स के विलय के लिए सबसे अच्छा विकल्प है (हालांकि कई स्ट्रिंग्स के लिए इतना अच्छा नहीं है)। उस स्थिति में कोड इस तरह दिखेगा:

String output = input.substring(0, 1).toUpperCase().concat(input.substring(1));

Answer 18

इसे इस्तेमाल करो:

char[] chars = {Character.toUpperCase(A.charAt(0)), 
Character.toUpperCase(B.charAt(0))};
String a1 = chars[0] + A.substring(1);
String b1 = chars[1] + B.substring(1);

Answer 19

inputस्ट्रिंग को देखते हुए :

Character.toUpperCase(input.charAt(0)) + input.substring(1).toLowerCase()

Answer 20

आप निम्न कोड आज़मा सकते हैं:

public string capitalize(str) {
    String[] array = str.split(" ");
    String newStr;
    for(int i = 0; i < array.length; i++) {
        newStr += array[i].substring(0,1).toUpperCase() + array[i].substring(1) + " ";
    }
    return newStr.trim();
}

Answer 21

public static String capitalize(String str){
        String[] inputWords = str.split(" ");
        String outputWords = "";
        for (String word : inputWords){
            if (!word.isEmpty()){
                outputWords = outputWords + " "+StringUtils.capitalize(word);
            }
        }
        return outputWords;
    }

Answer 22

मैं स्वीकृत उत्तर पर एक पूर्ण जाँच और IndexOutOfBoundsException जोड़ना चाहूंगा।

String output = input.substring(0, 1).toUpperCase() + input.substring(1);

जावा कोड:

  class Main {
      public static void main(String[] args) {
        System.out.println("Capitalize first letter ");
        System.out.println("Normal  check #1      : ["+ captializeFirstLetter("one thousand only")+"]");
        System.out.println("Normal  check #2      : ["+ captializeFirstLetter("two hundred")+"]");
        System.out.println("Normal  check #3      : ["+ captializeFirstLetter("twenty")+"]");
        System.out.println("Normal  check #4      : ["+ captializeFirstLetter("seven")+"]");

        System.out.println("Single letter check   : ["+captializeFirstLetter("a")+"]");
        System.out.println("IndexOutOfBound check : ["+ captializeFirstLetter("")+"]");
        System.out.println("Null Check            : ["+ captializeFirstLetter(null)+"]");
      }

      static String captializeFirstLetter(String input){
             if(input!=null && input.length() >0){
                input = input.substring(0, 1).toUpperCase() + input.substring(1);
            }
            return input;
        }
    }

आउटपुट:

Normal  check #1      : [One thousand only]
Normal  check #2      : [Two hundred]
Normal  check #3      : [Twenty]
Normal  check #4      : [Seven]
Single letter check   : [A]
IndexOutOfBound check : []
Null Check            : [null]

Answer 23

निम्नलिखित आपके इनपुटस्ट्रीमिंग के मूल्य की परवाह किए बिना आपको एक ही सुसंगत आउटपुट देगा:

if(StringUtils.isNotBlank(inputString)) {
    inputString = StringUtils.capitalize(inputString.toLowerCase());
}

Answer 24

1. स्ट्रिंग की substring()विधि का उपयोग करना

public static String capitalize(String str) {
    if(str== null || str.isEmpty()) {
        return str;
    }

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

अब capitalize()किसी स्ट्रिंग के पहले अक्षर को अपरकेस में बदलने के लिए विधि को कॉल करें :

System.out.println(capitalize("stackoverflow")); // Stackoverflow
System.out.println(capitalize("heLLo")); // HeLLo
System.out.println(capitalize(null)); // null

2. अपाचे कॉमन्स लैंग

StringUtilsकॉमन्स लैंग का वर्ग वह capitalize()विधि प्रदान करता है जिसका उपयोग इस उद्देश्य के लिए भी किया जा सकता है:

System.out.println(StringUtils.capitalize("apache commons")); // Apache commons
System.out.println(StringUtils.capitalize("heLLO")); // HeLLO
System.out.println(StringUtils.uncapitalize(null)); // null

अपनी pom.xmlफ़ाइल के लिए निम्न निर्भरता जोड़ें (केवल मावेन के लिए):

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

यहां एक लेख है जो इन दोनों दृष्टिकोणों के बारे में विस्तार से बताता है।

Answer 25

class Test {
     public static void main(String[] args) {
        String newString="";
        String test="Hii lets cheCk for BEING String";  
        String[] splitString = test.split(" ");
        for(int i=0; i<splitString.length; i++){
            newString= newString+ splitString[i].substring(0,1).toUpperCase() 
                    + splitString[i].substring(1,splitString[i].length()).toLowerCase()+" ";
        }
        System.out.println("the new String is "+newString);
    }
 }