दिलचस्प पोस्ट
ओवरलोडिंग ऑपरेटर <<: 'std :: basic_ostream <llvalue को बाइंड नहीं कर सकता है &&' इकाई ऑब्जेक्ट को आईईएन्टीटी चेंज ट्रैकर के कई उदाहरणों से संदर्भित नहीं किया जा सकता। जबकि संस्थागत ढांचे 4.1 में इकाई को संबंधित वस्तुओं को जोड़ते समय आईओएस 8 के तहत स्थानीय फाइलों को लोड नहीं कर रहा है UIAlertController प्रस्तुत करने के लिए कैसे करें जब दृश्य नियंत्रक में नहीं? कैसे चुनें एक टैग का विकल्प तत्व शैली? रनटाइम पर एक क्लास को कैसे रीट्रान्स करना मोंगोज़: अद्वितीय होने के लिए फ़ील्ड के संयोजन को कैसे परिभाषित करना है? एक पृष्ठभूमि स्क्रिप्ट से सामग्री स्क्रिप्ट तक संदेश भेजना, फिर इंजेक्शन वाली स्क्रिप्ट के लिए जावा ईई 6 में जावा वेब अनुप्रयोग बनाने के लिए क्या सीखें? exe संकलक के लिए एक अच्छा अजगर? एसक्यूएल केस स्टेटमेंट सिंटैक्स? जावा से लेकर ओरेकल प्रक्रिया की सूची कैसे पास करें? PHP का उपयोग कर दूरस्थ MySQL सर्वर से कनेक्ट करना क्लिक किए जाने पर HTML पाठ इनपुट के सभी पाठ को चुनना रेजर व्यू इंजिन में एस्केप @ वर्ण

मैं जावा में मानव-पठनीय नामों में कैमल सीज़ को कैसे बदलूं?

मैं एक ऐसी विधि लिखना चाहूंगा जो कि मानव-पठनीय नाम में कैमलकस को परिवर्तित करती है।

यहां टेस्ट केस है:

public void testSplitCamelCase() { assertEquals("lowercase", splitCamelCase("lowercase")); assertEquals("Class", splitCamelCase("Class")); assertEquals("My Class", splitCamelCase("MyClass")); assertEquals("HTML", splitCamelCase("HTML")); assertEquals("PDF Loader", splitCamelCase("PDFLoader")); assertEquals("A String", splitCamelCase("AString")); assertEquals("Simple XML Parser", splitCamelCase("SimpleXMLParser")); assertEquals("GL 11 Version", splitCamelCase("GL11Version")); } 

वेब के समाधान से एकत्रित समाधान "मैं जावा में मानव-पठनीय नामों में कैमल सीज़ को कैसे बदलूं?"

यह आपके परीक्षण के साथ काम करता है:

 static String splitCamelCase(String s) { return s.replaceAll( String.format("%s|%s|%s", "(?<=[AZ])(?=[AZ][az])", "(?<=[^AZ])(?=[AZ])", "(?<=[A-Za-z])(?=[^A-Za-z])" ), " " ); } 

यहाँ एक परीक्षण दोहन है:

  String[] tests = { "lowercase", // [lowercase] "Class", // [Class] "MyClass", // [My Class] "HTML", // [HTML] "PDFLoader", // [PDF Loader] "AString", // [A String] "SimpleXMLParser", // [Simple XML Parser] "GL11Version", // [GL 11 Version] "99Bottles", // [99 Bottles] "May5", // [May 5] "BFG9000", // [BFG 9000] }; for (String test : tests) { System.out.println("[" + splitCamelCase(test) + "]"); } 

यह शोर-लम्बाई के मिलान वाले रेगेक्स का उपयोग छिपे हुए बक्से के साथ करता है और रिक्त स्थान को कहां लगाता है। मूल रूप से 3 पैटर्न हैं, और मैं इसे String.format का उपयोग करने के लिए इसे और अधिक पठनीय बनाने के लिए एक साथ रखता हूं।

तीन पैटर्न हैं:

मेरे पीछे यूसी, यूसी मेरे सामने एलसी द्वारा पीछा किया

  XMLParser AString PDFLoader /\ /\ /\ 

मेरे पीछे गैर यूसी, मेरे सामने यूसी

  MyClass 99Bottles /\ /\ 

मेरे पीछे पत्र, मेरे सामने गैर-पत्र

  GL11 May5 BFG9000 /\ /\ /\ 

संदर्भ

  • regular-expressions.info/Lookarounds

संबंधित सवाल

विभाजित करने के लिए शून्य-लंबाई मिलान वाले खोजों का उपयोग करना:

  • रेगेक्स स्प्लिट स्ट्रिंग लेकिन अलग-अलग रखिए
  • जावा विभाजन मेरे पात्रों को खा रहा है

आप इसे org.apache.commons.lang.StringUtils का उपयोग कर सकते हैं

 StringUtils.join( StringUtils.splitByCharacterTypeCamelCase("ExampleTest"), ' ' ); 

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

 String name = camelName.replaceAll("([AZ][az]+)", " $1") // Words beginning with UC .replaceAll("([AZ][AZ]+)", " $1") // "Words" of only UC .replaceAll("([^A-Za-z ]+)", " $1") // "Words" of non-letters .trim(); 

यह अंकों के साथ सहित उन सभी परीक्षण मामलों को ऊपर से गुजरता है।

जैसा कि मैं कहता हूं, यह कुछ अन्य उदाहरणों में एक नियमित अभिव्यक्ति का उपयोग करने के रूप में उतना अच्छा नहीं है – लेकिन किसी को यह उपयोगी भी मिल सकता है।

आप org.modeshape.common.text.Inflector का उपयोग कर सकते हैं।

विशेष रूप से:

 String humanize(String lowerCaseAndUnderscoredWords, String... removableTokens) 

पहले शब्द को बड़ा बनाता है और "_id" और किसी भी आपूर्ति योग्य हटाने योग्य टोकन के पीछे के स्थान और स्ट्रिप्स में अंडरस्कोर बदल जाता है।

मावेन आर्टिफैक्ट है: org.modeshape: modeshape-common: 2.3.0.फिनल

जेबोस रिपॉजिटरी पर: https://repository.jboss.org/nexus/content/repositories/releases

यहां JAR फ़ाइल है: https://repository.jboss.org/nexus/content/repositories/releases/org/modeshape/modeshape-common/2.3.0.final/modeshape-common-2.3.0.Final.jar

निम्न रेगीक्स शब्दों के अंदर राजधानियों को पहचानने के लिए इस्तेमाल किया जा सकता है:

 "((?<=[a-z0-9])[AZ]|(?<=[a-zA-Z])[0-9]]|(?<=[AZ])[AZ](?=[az]))" 

यह प्रत्येक पूंजी पत्र से मेल खाता है, जो एक गैर-पूंजी पत्र या अंक के बाद ईथर है या उसके बाद एक लोअर केस लेटर और एक अक्षर के बाद हर अंक।

उनके सामने एक जगह डालने के लिए कैसे मेरे जावा कौशल से परे है =)

अंकीय केस और पीडीएफ लोडर केस को शामिल करने के लिए संपादित।

मुझे लगता है कि आपको स्ट्रिंग पर पुनरावृत्त करना होगा और लोअरकेस से अपरकेस, अपरकेस को लोअरकेस, वर्णानुक्रमिक, संख्यात्मक, वर्णानुक्रमिक, वर्णानुक्रम में बदलना होगा। प्रत्येक परिवर्तन पर आप एक अपवाद के साथ एक जगह सम्मिलित करते हैं, हालांकि: ऊपरी-से लोअरकेस में परिवर्तन से पहले आप को एक अक्षर अंतरिक्ष में डालें।

यह काम करता है .नेट … अपनी पसंद के अनुकूलन मैंने टिप्पणियों को जोड़ा ताकि आप समझ सकें कि प्रत्येक टुकड़ा क्या कर रहा है। (रेगएक्स को समझना मुश्किल हो सकता है)

 public static string SplitCamelCase(string str) { str = Regex.Replace(str, @"([AZ])([AZ][az])", "$1 $2"); // Capital followed by capital AND a lowercase. str = Regex.Replace(str, @"([az])([AZ])", "$1 $2"); // Lowercase followed by a capital. str = Regex.Replace(str, @"(\D)(\d)", "$1 $2"); //Letter followed by a number. str = Regex.Replace(str, @"(\d)(\D)", "$1 $2"); // Number followed by letter. return str; } 

स्वच्छ और कम समाधान:

 StringUtils.capitalize(StringUtils.join(StringUtils.splitByCharacterTypeCamelCase("yourCamelCaseText"), StringUtils.SPACE)); // Your Camel Case Text 

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

रिकॉर्ड के लिए, यहां लगभग (*) संगत स्काला संस्करण है:

  object Str { def unapplySeq(s: String): Option[Seq[Char]] = Some(s) } def splitCamelCase(str: String) = String.valueOf( (str + "A" * 2) sliding (3) flatMap { case Str(a, b, c) => (a.isUpper, b.isUpper, c.isUpper) match { case (true, false, _) => " " + a case (false, true, true) => a + " " case _ => String.valueOf(a) } } toArray ).trim 

एक बार संकलित होने पर इसे सीधे जावा से इस्तेमाल किया जा सकता है, यदि संबंधित स्का-लाइब्रेरी.जर क्लासपाथ में है।

(*) इनपुट "GL11Version" लिए विफल रहता है जिसके लिए वह "G L11 Version" देता है

मैंने रीगेक्स को पॉलीगेंज़ेल्बिकैंट्स से लिया और वस्तुओं पर एक एक्सटेंशन विधि में इसे बदल दिया:

  /// <summary> /// Turns a given object into a sentence by: /// Converting the given object into a <see cref="string"/>. /// Adding spaces before each capital letter except for the first letter of the string representation of the given object. /// Makes the entire string lower case except for the first word and any acronyms. /// </summary> /// <param name="original">The object to turn into a proper sentence.</param> /// <returns>A string representation of the original object that reads like a real sentence.</returns> public static string ToProperSentence(this object original) { Regex addSpacesAtCapitalLettersRegEx = new Regex(@"(?<=[AZ])(?=[AZ][az]) | (?<=[^AZ])(?=[AZ]) | (?<=[A-Za-z])(?=[^A-Za-z])", RegexOptions.IgnorePatternWhitespace); string[] words = addSpacesAtCapitalLettersRegEx.Split(original.ToString()); if (words.Length > 1) { List<string> wordsList = new List<string> { words[0] }; wordsList.AddRange(words.Skip(1).Select(word => word.Equals(word.ToUpper()) ? word : word.ToLower())); words = wordsList.ToArray(); } return string.Join(" ", words); } 

यह सब कुछ एक पठनीय वाक्य में बदल जाता है। यह ऑब्जेक्ट पर एक टोस्ट्रिंग पास करता है फिर स्ट्रिंग को विभाजित करने के लिए पॉलीगेन्यूब्यूब्रिकेंट द्वारा दिए गए रेगेक्स का उपयोग करता है। फिर यह पहला शब्द और किसी भी संक्षेपण के लिए प्रत्येक शब्द को छोड़ देता है। सोचा कि यह किसी के लिए उपयोगी हो सकता है वहाँ बाहर।

RegEx को काम करना चाहिए, जैसे कुछ ([AZ]{1}) । यह सभी कैपिटल लेक्स पर कब्जा करेगा, इसके बाद आप उन्हें \1 साथ बदल सकते हैं या आप जावा में रेगएक्स समूह का उल्लेख कैसे कर सकते हैं

http://code.google.com/p/inflection-js/

आप String.underscore () को श्रृंखलाबद्ध कर सकते हैं । () एक कैमल सीज़ स्ट्रिंग लेने और मानव पठनीय स्ट्रिंग में कनवर्ट करने के तरीके