Başlık Durumuna Dize dönüşümü için bir yöntem var mı?

99

Bir dizeyi Title Case biçimine dönüştürmek için herhangi bir yerleşik yöntem var mı?

java  string  title-case 
— TylerH
kaynak
3
Bu soruyu okuyan herkes: Burada en çok oylanan cevapların çoğunun tüm diller için DOĞRU ÇALIŞMADIĞINA dikkat edin. ICU4J gibi doğru başlık ayırma için i18n farkında bir kitaplığa ihtiyacınız var (Daniel F'nin cevabına bakın).
— sffc

Yanıtlar:

106

Apache Commons StringUtils.capitalize () veya Commons Text WordUtils.capitalize ()

örneğin: WordUtils.capitalize("i am FINE") = "I Am FINE"den WordUtils doc

— anormal80
kaynak
14
WordUtils.capitalizeFully () verdiği gibi benim için daha iyiydi: WordUtils.capitalizeFully ("İyiyim") = "İyiyim"
— theINtoy
2
Sadece küçük bir güncelleme, WordUtils Commons Text'e gitti ve Commons Lang içinde kullanımdan kaldırıldı
— msrd0
Baharda ayrıcaStringUtils.capitalise()
— OrangeDog
@OrangeDog demek istiyorsun capitalize()?
— TylerH
61

Java'nın String sınıfında Capitalize () veya titleCase () yöntemleri yoktur. İki seçeneğiniz var:

 StringUtils.capitalize(null)  = null
 StringUtils.capitalize("")    = ""
 StringUtils.capitalize("cat") = "Cat"
 StringUtils.capitalize("cAt") = "CAt"
 StringUtils.capitalize("'cat'") = "'cat'"
  • toTitleCase () için (yine başka bir) statik yardımcı yöntem yazın

Örnek uygulama

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();
}

Test durumu

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

çıktılar:

Dize
Başka bir dize
HENÜZ BAŞKA BİR DİZE
— dfa
kaynak
1
Bu güzel ve küçük bir rutindir, ancak Dizelerin isimleri temsil edebileceği daha genel durumda başarısız olur. Bu durumda, büyük harf kullanımının kesme işaretlerinden ve kısa çizgilerden sonra da gelmesi gerekir. Örneğin. O'Connor ve J. Wilkes-Booth. Elbette, diğer dillerde ek başlık durum kuralları olabilir.
— scottb
... Eğer bunu içerecek olsaydı, sadece mevcut kelimenin bir isim olup olmadığını anlamak için tam bir sözlük aramasına ihtiyaç duymaz mıydı? Bu, herhangi bir yöntem için biraz fazla görünüyor.
— MMJZ
Bu kod neredeyse iyidir çünkü Maria del Carmen, Maria da Silva, Maria della Salute, vb. Gibi
— Junior Mayhé
Bu kesme işaretiyle bozulmaz mı? Örneğin O'Brian ne olacak?
— sproketboy
1
Not: dahili olarak kullanılan yeniden boyutlandırma önlemek için char[]de StringBuilderkullanıyorum önermeknew StringBuilder(input.length())
— Lino
38

Çözüme ilişkin görüşümü sunabilirsem ...

Aşağıdaki yöntem, dfa'nın gönderdiği yöntemi temel alır. Aşağıdaki büyük değişikliği yapar (o sırada ihtiyacım olan çözüme uygundur): giriş dizesindeki tüm karakterleri, hemen önünde bir "uygulanabilir sınırlayıcı" bulunmadıkça küçük harfe zorlar; bu durumda karakter, büyük harf.

Rutinimin önemli bir sınırlaması, "başlık büyüklüğünün" tüm yerel ayarlar için tek tip olarak tanımlandığı ve benim kullandığım aynı durum kurallarıyla temsil edildiği ve dolayısıyla bu açıdan dfa'nın kodundan daha az yararlı olduğu varsayımını yapmasıdır.

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();
}

TEST DEĞERLERİ

dizi

maRTin o'maLLEY

john wilkes-stand

HENÜZ BAŞKA BİR DİZE

ÇIKTILAR

Dizi

Martin O'Malley

John Wilkes-Booth

Yine başka bir dize

— Scottb
kaynak
lj gibi büyük harf LJ, ancak başlık tabanı Lj olan bitişik harflerle çalışmaz. Character.toTitleCaseBunun yerine kullanın .
— mihi
@mihi: ayrıca diğer özel kurallarla çalışmaz, örn. McNamara veya MacDonald gibi soyadları.
— scottb
ancak bu durumlar doğası gereği düzeltilemez. (İlk harfler büyük bir kelime yararlanmak için kullanılacak gerekiyordu değil, büyük harf, Unicode kurallarına göre) doğru harf dönüştürme işlevini kullanarak yapabilirsiniz yapılabilir (ve bu kolay).
— mihi
Bu aynı zamanda "onun" nın "Onun" olmasına da neden olmaz mı?
— allicarn
Bu doğru. Bu, isim alanlarında işe yarar ama sizin de belirttiğiniz gibi, genel düzyazıda değil. Her isimde, özellikle de Vulkanlarda (T'pau yerine T'Pau) pek işe yaramaz.
— scottb
21

Apache Commons'tan WordUtils.capitalizeFully () kullanın .

WordUtils.capitalizeFully(null)        = null
WordUtils.capitalizeFully("")          = ""
WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
— Jiehanzheng
kaynak
1
Güzel çözüm! Teşekkürler! Ancak, bu, aynı zamanda bu başlıktaki "a" harfini de büyük harfle yazdığı için% 100 çalışmaz: "Bu bir Başlık". Bakınız english.stackexchange.com/questions/14/… . Bununla ilgilenen herhangi bir kütüphane biliyor musunuz?
— Eirik W
3

İşte @ dfa ve @ scottb'un harf / rakam olmayan karakterleri ele alan yanıtlarına dayanan başka bir örnek:

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();
    }

}

Verilen girdi:

MARY ÄNN O'CONNEŽ-ŠUSLIK

çıktı

Mary Änn O'Connež-Šuslik

— mrts
kaynak
2

Bu, snake_case'i lowerCamelCase'e dönüştürmek için yazdığım bir şey, ancak gereksinimlere göre kolayca ayarlanabilir

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());
}
— user1743960
kaynak
Cevabınız bir cazibe gibi çalışıyor, ancak çözüm tek bir kelime dizisini ele almıyor gibi görünüyor, belki bir if koşulu yeterli olmalı.
— yashgarg1232
1

Bunun daha eski olduğunu biliyorum, ancak basit cevabı taşımıyor, kodlamam için bu yönteme ihtiyacım vardı, bu yüzden buraya ekledim, kullanımı basit. 

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);
}
— Manish Bansal
kaynak
1

Bu problemi yaşadım ve aradım, sonra bazı java anahtar kelimeleri kullanarak kendi yöntemimi yaptım, sadece String değişkenini parametre olarak geçirmem ve uygun başlıklı String olarak çıktı almam gerekiyor.

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 ();
    }
}
— Parveen Sishodiya
kaynak
Burada hiçbir yerde trim yöntemini kullanmadım çünkü benim durumumda uygun şekilde kesilmiş ip alıyordum.
— Parveen Sishodiya
0

çok iyi kullanabilirsin

org.apache.commons.lang.WordUtils

veya

CaseFormat

Google'ın API'sinden.

— gkarthiks
kaynak
1
Yöntemi ve bir örneği eklemek faydalı olacaktır.
— jechaviz
CaseFormat yalnızca tipik olarak program tanımlayıcılarında kullanılan formatlara sahiptir (Üst Cam, alt hipen, UPPER_UNDERSCORE, vb.) Ve yalnızca ASCII metnini destekler. Title Case'e dönüştürmek için pek işe yaramaz.
— M. Justin
0

Son zamanlarda ben de bu problemle karşılaştım ve ne yazık ki Mc ve Mac ile başlayan birçok isim vakası oldu, bu önekleri işlemek için değiştirdiğim scottb kodunun bir versiyonunu kullandım, bu yüzden kimse kullanmak isterse burada.

Hala bunun gözden kaçırdığı uç durumlar var, ancak olabilecek en kötü şey, büyük harfle yazılması gerektiğinde bir harfin küçük harf olacağıdır.

/**
 * 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;    
}
— Eski Nick
kaynak
0

Uygun Başlık Durumuna Dönüştürme:

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);

Sonuç: "Bu Bir Metin"

— VAIBHAV SHEERSH
kaynak
0

Baharın Kullanımı StringUtils:

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

Zaten Spring kullanıyorsanız, bu başka bir çerçeve getirmekten kaçınır.

— David Lavanta
kaynak
0

Bir dizeyi ilk harf büyüklüğüne dönüştürmek için bu yöntemi kullanın:

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("");
}
— Abdulhamid Yusuf
kaynak
0

Bu dönüştürücü, deve kılıfı, beyaz boşluklar, rakamlar ve diğer karakterleri içeren herhangi bir dizeyi sterilize edilmiş başlık durumuna dönüştürür.

/**
 * 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();
    }
}

İşte bazı girişler:

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

Ve çıktılarım:

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
— Dipu
kaynak
0

Görünüşe göre cevapların hiçbiri gerçek başlık örneğinde formatlanmış gibi görünüyor: "Hayalinizdeki İşi Nasıl Bulursunuz", "Alaycı Kuşu Öldürmek", vb. Bu yüzden kendi yöntemimi yaptım. En iyi İngilizce metinler için işe yarar.

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"));
  }
— Mladen Adamovic
kaynak
0

Bu en basit çözüm

    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);
— Reppin Frost
kaynak
-1

Bu çalışmalı:

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);
— Neha
kaynak
1
OP yerleşik işlevi istediğinden bu geçerli bir yanıt değil . Bunun arkasındaki gizli karmaşıklığı ele alan yoruma da bakınız, yani i18n.
— Marcus
-2

Herhangi bir dizeyi başlık durumuna dönüştürmenin en basit yolu, googles paketini kullanmaktır org.apache.commons.lang.WordUtils

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

Bunun sonucu olacak

Bu Benim Örneğim Olacak

Neden "CapitalizeFully" olarak adlandırıldığından emin değilim, burada aslında işlev tam bir sermaye sonucu vermiyor, ama her neyse, ihtiyacımız olan araç bu.

— JoeG
kaynak
1
capitalizeFullyBir başlıkta küçük harf olması gerekenler dahil her kelimeyi büyük harfle yazdığı için adlandırılmıştır . grammar.about.com/od/tz/g/Title-Case.htm
— aij
2
Apache Commons, Google'a ait değildir. Apache Software Foundation tarafından yönetilmektedir. commons.apache.org
— ATutorMe
-3

Üzgünüm acemiyim, bu yüzden kodlama alışkanlığım berbat!

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!"));
    }
}
— Vishwanath Dasa
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.