Camel casing in java

Универсальная функция toCamelCase() для Java

Сегодня мне понадобилось перевести строку произвольного содержания в camelCase.
В интернете в основном встретились узкоспециализированные методы, которые либо переводят только имена констант (по соглашениям Java, SOME_JAVA_NAMING_CONVENTION_CONST), либо только фразы, разделенные пробелами.
Мне этого категорически не хватало, нужна была бОльшая универсальность.

Как и подобает любому уважающему себя велосипедисту, я начал писать свой алгоритм, и немного увлёкся. Очнувшись от кода, я обнаружил, что функция переводит любые мною скормленные строки в нормальный camelCase или CamelCase.
Единственное, что она не делает — не запрещает цифры в начале получившейся строки (для соглашений JNC), но мне это и не нужно было (при необходимости дописывается одной строкой кода — пополнением ко второму, вложенному, условию).

Что получилось можете увидеть под катом.

Функция принимает два аргумента — собственно строку, и флаг, указывающий писать результат с большой буквы (недо-camelCase).
Делает она всё это за один проход. Код присыпан комментариями для новичков (кому и пишется эта шпаргалка).
При жалении второй аргумент можно безболезненно откусить.
Так же практически без изменений алгоритм портируется на javascript и C#.

 /** * Возвращает отформатированную в виде camelCase (или CamelCase) строку. * * @param string Исходная строка * @param firstWordToLowerCase Начинать ли искомую строку с маленького символа (lowercase). */ public static String toCamelCase(String string, boolean firstWordToLowerCase) < char currentChar, previousChar = '\u0000'; // Текущий и предыдущий символ прохода StringBuilder result = new StringBuilder(); // Результат функции в виде строкового билдера boolean firstLetterArrived = !firstWordToLowerCase; // Флаг, отвечающий за написание первого символа результата в lowercase boolean nextLetterInUpperCase = true; // Флаг, приказывающий следующий добавляемый символ писать в UPPERCASE // Проходимся по всем символам полученной строки for (int i = 0; i < string.length(); i++) < currentChar = string.charAt(i); /* Если текущий символ не цифробуква - приказываем следующий символ писать Большим (начать новое слово) и идем на следующую итерацию. Если предыдущий символ это маленькая буква или цифра, а текущий это большая буква - приказываем текущий символ писать Большим (начать новое слово). */ if (!Character.isLetterOrDigit(currentChar) || ( ((Character.isLetter(previousChar) && Character.isLowerCase(previousChar)) || Character.isDigit(previousChar)) && Character.isLetter(currentChar) && Character.isUpperCase(currentChar)) ) < nextLetterInUpperCase = true; if (!Character.isLetterOrDigit(currentChar)) < previousChar = currentChar; continue; >> // Если приказано писать Большую букву, и первая буква уже написана. if (nextLetterInUpperCase && firstLetterArrived) < result.append(Character.toUpperCase(currentChar)); >else < result.append(Character.toLowerCase(currentChar)); >// Устанавливаем флаги. firstLetterArrived = true; nextLetterInUpperCase = false; previousChar = currentChar; > // Возвращаем полученный результат. return result.toString(); > 

Source string: ‘normalCamelCaseName’
Result string: ‘normalCamelCaseName’
Result string: ‘NormalCamelCaseName’ (firstWordToLowerCase = false)
===========================
Source string: ‘NotCamelCaseName’
Result string: ‘notCamelCaseName’
Result string: ‘NotCamelCaseName’ (firstWordToLowerCase = false)
===========================
Source string: ‘CONSTANT_TO_CAMEL_CASE’
Result string: ‘constantToCamelCase’
Result string: ‘ConstantToCamelCase’ (firstWordToLowerCase = false)
===========================
Source string: ‘Text To Camel Case’
Result string: ‘textToCamelCase’
Result string: ‘TextToCamelCase’ (firstWordToLowerCase = false)
===========================
Source string: ‘Text to camel case’
Result string: ‘textToCamelCase’
Result string: ‘TextToCamelCase’ (firstWordToLowerCase = false)
===========================
Source string: ‘ОтЖиМаЕмСя На ШиФфТе, ДрУзЯфФкИ!:)’
Result string: ‘отЖиМаЕмСяНаШиФфТеДрУзЯфФкИ’
Result string: ‘ОтЖиМаЕмСяНаШиФфТеДрУзЯфФкИ’ (firstWordToLowerCase = false)
===========================
Source string: ‘-(*&*&%&%$^&^*()Знаков*&^%*(&$препинания… и.нечитаемых————знаков^ (Может*90Быть&(*?*?: СКОЛЬКО*?%?:%угодно!’
Result string: ‘знаковПрепинанияИНечитаемыхЗнаковМожет90БытьСколькоУгодно’
Result string: ‘ЗнаковПрепинанияИНечитаемыхЗнаковМожет90БытьСколькоУгодно’ (firstWordToLowerCase = false)
===========================
Source string: ‘И, напоследок, русская строка со знаками препинания (локализация!).’
Result string: ‘иНапоследокРусскаяСтрокаСоЗнакамиПрепинанияЛокализация’
Result string: ‘ИНапоследокРусскаяСтрокаСоЗнакамиПрепинанияЛокализация’ (firstWordToLowerCase = false)

Источник

CamelCase in Java naming conventions

Given a query string query, you use a regular expression to create a regular expression: For example the query will become the regex: You then use this regex for your matching using the method to get something like this: This will return the first match to your camel case query in the string str. EDIT: I have added a line to handle wildcards since in my tired stupor I didn’t appreciate the need for them Solution 2: As danbruc said, you have to generate a new regex for each new query. Consider the following example − Taxation Department Class — TaxationDepartment Object — taxationDepartment Method — getTaxationDepartmentDetails Variable — taxationDepartment Question: Is there a construct in Apache Camel (in Java DSL) similar to Java switch-case?

CamelCase in Java naming conventions

Java follows camel casing for objects, class, variables etc. If a name is having multiple words, the first letter is small then consecutive words are joint with the first letter as a capital case. Consider the following example −

CamelCase in Java naming conventions, Java follows camel casing for objects, class, variables etc. If a name is having multiple words, the first letter is small then consecutive words are joint with the first letter as a capital case. Consider the following example − Taxation Department Class — TaxationDepartment Object — taxationDepartment Method — …

Switch case in Apache Camel

Is there a construct in Apache Camel (in Java DSL) similar to Java switch-case?

 from( incomingRoute ) .choice() .when( simple( "$ == '" + TYPE.A.name() + "'" ) ) .to( A_Endpoint ) .when( simple( "$ == '" + TYPE.B.name() + "'" ) ) .to( B_Endpoint ) .when( simple( "$ == '" + TYPE.C.name() + "'" ) ) .to( C_Endpoint ) .otherwise() .to( errorEndpoint ); 

Can be translated into something else more similar to switch? I mean that I do not want to use simple predicates, only value of type of body element. Or is my approach completely wrong? (That could reasonably be)

I generally prefer using Java 8 lambdas in that particular scenario:

public void configure() throws Exception < from( incomingRoute ) .choice() .when( bodyTypeIs( TYPE.A ) ) .to( A_Endpoint ) .when( bodyTypeIs( TYPE.B ) ) .to( B_Endpoint ) .when( bodyTypeIs( TYPE.C ) ) .to( C_Endpoint ) .otherwise() .to( errorEndpoint ); >private Predicate bodyTypeIs(TYPE type) < return e ->e.getIn().getBody(BodyType.class).getType() == type; > 

Also, using Camel’s Predicate s with Java 8 allows for some awesome fluent API building, like adding your own type of functional Predicate :

@FunctionalInterface public interface ComposablePredicate extends Predicate, java.util.function.Predicate  < @Override default boolean matches(Exchange exchange) < return test(exchange); >@Override default ComposablePredicate and(java.util.function.Predicate other) < Objects.requireNonNull(other); return (t) ->test(t) && other.test(t); > @Override default ComposablePredicate negate() < return (t) ->!test(t); > @Override default ComposablePredicate or(java.util.function.Predicate other) < Objects.requireNonNull(other); return (t) ->test(t) || other.test(t); > > 

Which allows you to write stuff like:

public void configure() throws Exception < from( incomingRoute ) .choice() .when( bodyTypeIs( TYPE.A ) .or ( bodyTypeIs( TYPE.A1 ) ) ) .to( A_Endpoint ) .when( bodyTypeIs( TYPE.B ).negate() ) .to( NOT_B_Endpoint ) .when( bodyTypeIs( TYPE.C ) .and ( bodyNameIs( "name" ) ) ) .to( C_Endpoint ) .otherwise() .to( errorEndpoint ); >private ComposablePredicate bodyTypeIs(TYPE type) < return e ->bodyFrom(e).getType() == type; > private BodyType bodyFrom(Exchange e) < return e.getIn().getBody(BodyType.class); >private ComposablePredicate bodyNameIs(String name) < return e ->bodyFrom(e).getName().equals(name); > 

How to convert string to camel case in JavaScript, Approach: Use reduce () method to iterate over the character of string and convert it into camel case. The toUpperCase () and toLowerCase () methods are used to convert the string character into upper case and lower case respectively. Example 1: This example uses reduce , toLowerCase () and …

Regex to match from partial or camel case string?

I would like a regular expression to match given a partial or camel cased string. For example, if the search set contains the string «MyPossibleResultString» I want to be able to match it with the likes of the following:

I’d also like to include wildcard matching, e.g.:

If it’s not clear what I mean, the only example I can think of is Eclipse’s «Open Type» dialog which is pretty much the exact behaviour I’m looking for. I’m not too up on the use of regexes, so I’m not sure if it matters if I’m looking for a solution in Java.

Ok so I can’t really see why you would need the wildcard feature if you can already support the matching described in the first example. This is what I put together. Given a query string query, you use a regular expression to create a regular expression:

String re = "\\b(" + query.replaceAll("([A-Z][^A-Z]*)", "$1[^A-Z]*") + ".*?)\\b"; 

For example the query MyPosResStr will become the regex:

You then use this regex for your matching using the Matcher.find method to get something like this:

public static String matchCamelCase(String query, String str) < query = query.replaceAll("\\*", ".*?"); String re = "\\b(" + query.replaceAll("([A-Z][^A-Z]*)", "$1[^A-Z]*") + ".*?)\\b"; System.out.println(re); Pattern regex = Pattern.compile(re); Matcher m = regex.matcher(str); if (m.find()) < return m.group(); >else return null; > 

This will return the first match to your camel case query in the string str.

EDIT: I have added a line to handle wildcards since in my tired stupor I didn’t appreciate the need for them

As danbruc said, you have to generate a new regex for each new query. This code should do what you want.

public Pattern queryToPattern(String query) < StringBuilder sb = new StringBuilder(); char[] chars = query.toCharArray(); boolean incamel = false; for (int i=0; i < chars.length; i++) < if (chars[i] == '*') < if (!incamel) sb.append(".*"); >else if (Character.isUpperCase(chars[i])) < if (incamel) < sb.append(".*"); >sb.append(chars[i]); incamel = true; > else < sb.append(chars[i]); >> sb.append(".*"); return Pattern.compile(sb.toString()); > 

Creates a pattern of: My.* P.* R.* String.*

It is not possible to do this with a single regular expression. You will have to build a regular expression based on the input and use this to search. It is easy to see that you cannot use a single regex — the user can search for any (cammel cased) string and so your regex needs to match any (cammel cased) string but than it is not a search anymore.

You could try something like:

class RegexTransformer < public String fromQuery(String query) < StringBuilder sb = new StringBuilder(); sb.append("^"); sb.append(query.replaceAll("(\\p(?!\\p))", "$1\\\\p*?")); sb.append("$"); return sb.toString(); > > 

See Pattern API for description of negative lookahead assertions (?!pat) , POSIX character classes \p , and reluctant quantifiers *? .

import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.junit.Test; public class RegexTransformerTest < private RegexTransformer rt = new RegexTransformer(); @Test public void testQueries() < String in = "MyPossibleResultString"; String q1 = "MyPossibleResultString"; String q2 = "MPRS"; String q3 = "MPRString"; String q4 = "MyPosResStr"; // this wont work String q5 = "M"; test(in, q1, "^MyPossibleResultString$"); test(in, q2, "^M\\p*?P\\p*?R\\p*?S\\p*?$"); test(in, q3, "^M\\p*?P\\p*?R\\p*?String$"); test(in, q5, "^M\\p*?$"); > private void test(String in, String query, String expected) < assertEquals("transform", expected, rt.fromQuery(query)); assertTrue("match", in.matches(rt.fromQuery(query))); >> 

Java — Switch case in Apache Camel, I completely agree with Darius, Camel Predicates are generally the way to go in my opinion, your code is much more readable that way. – Miloš Milivojević Aug 26, 2016 at 8:52

To camelCase or not to camel_case

What is the standard when coding in Java, when do you use camel case when do you use underscores etc.

What exactly the standard is doesn’t matter — what matters is that everyone follows it, and you should too.

instanceVariable / localVariable

CONSTANT_NAME

G (Generic Type Parameter)

Use Java and RegEx to convert casing in a string, Java9+ From Java 9+ you can use Matcher::replaceAll where you can use a Function for example we use the example of polygenelubricants:. String text = «this is just a test which upper all short words»; String regex = «\\b\\w\\b»; Pattern pattern = Pattern.compile(regex); Matcher …

Источник

Что такое CamelCase или CamelStyle?

В Java очень важно правильно оформлять код . Да-да, не только писать работающие программы, но и еще правильно оформленные.

Существует целый свод правил, который называется Code Conventions в Java. Так что можете смело заходить и изучать.

А сейчас в этой статье мы рассмотрим только часть Code Conventions, а именно правила написания названий классов, переменных и методов. Итак, запоминаем.

Правило №1: Названия должны быть «говорящими»

То есть везде, где возможно, желательно давать названия классам, переменным, методам такие, чтобы уже из названия было понятно за что отвечает класс, переменная или метод.

Например, что понятнее?

Конечно же, int size, потому что из названия понятно, переменная отвечает за размер чего-то.

Правило №2: Применяется всегда CamelStyle

CamelStyle (от английского camel — «верблюд») — это стиль написания названий, состоящих из нескольких слов. Еще этот способ написания слов иногда называют CamelCase. Что же это такое — разберем на примерах.

Допустим, мы хотим дать название переменной, которая отвечает, скажем, за размер коробки. Тогда назовем переменную так:

Как Вы видите, название переменной состоит из 2 слов — Box и Size — которые написаны слитно, причем 2-е слово с большой буквы.

Допустим переменная отвечает за мои товары, которые я продаю в Германии:

И еще одна переменная, которая отвечает за мои товары, которые я продаю в Польше:

В приведенных примерах, если слово состоит из 2 и более слов, слова пишутся слитно и при этом каждое слово с большой буквы. Таким образом, образуются как бы «горбики», как у верблюда. Отсюда и называние CamelStyle.

Правило №3: С большой или с маленькой буквы

Источник

Convert String to Camel Case using Java

Complete the method/function so that it converts dash/underscore delimited words into camel casing. The first word within the output should be capitalized only if the original word was capitalized (known as Upper Camel Case, also often referred to as Pascal case).

Examples#

toCamelCase("the-stealth-warrior"); // returns "theStealthWarrior" toCamelCase("The_Stealth_Warrior"); // returns "TheStealthWarrior" 

Test cases#

import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4; public class SolutionTest < @Test public void testSomeUnderscoreLowerStart() < String input = "the_Stealth_Warrior"; System.out.println("input: "+input); assertEquals("theStealthWarrior", Solution.toCamelCase(input)); >@Test public void testSomeDashLowerStart() < String input = "the-Stealth-Warrior"; System.out.println("input: "+input); assertEquals("theStealthWarrior", Solution.toCamelCase(input)); >> 

The solution in Java#

import java.lang.StringBuilder; class Solution < // Our method static String toCamelCase(String s)< // create a StringBuilder to create our output string StringBuilder sb = new StringBuilder(); // determine when the next capital letter will be Boolean nextCapital = false; // loop through the string for (int i=0; ielse < // otherwise the next letter should be a capital nextCapital = true; >> // return our output string return sb.toString(); > > 

Top Related Articles

1. Sort a Java Integer in Descending Order
2. Get the Sum of Digits / Digital Root using Java
3. Check if Valid Sudoku Blocks in Java
4. FizzBuzz in Java
5. Python Splices reimplemented in Java
6. Is a Valid Palindrome with Java
7. Is a Valid Anagram with Java
8. How to ReImplement strStr() in Java
9. Third Maximum Number with Java
10. First Unique Character in a String using Java

Источник