- [This tutorial][chars-tutorial] is useful.

- [Reference documentation][chars-docs] for `char`s is here.

- You can retrieve `char`s from a string using the [charAt][char-at] method.

- You should use a [`StringBuilder`][string-builder] to build the output string.

- See [this method][iswhitespace] for detecting spaces. Remember it is a static method.

- `char` literals are enclosed in single quotes.

- See [this method][iscontrol] to check if a character is a control character.

- See [this method][toupper] to convert a character to upper case.

- `char`s support the default equality and comparison operators.

[chars-docs]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html

[chars-tutorial]: https://docs.oracle.com/javase/tutorial/java/data/characters.html

[char-at]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/String.html#charAt(int)

[string-builder]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/StringBuilder.html

[iswhitespace]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isWhitespace(char)

[iscontrol]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#isISOControl(char)

[toupper]: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html#toUpperCase(char)

In this exercise you will implement a partial set of utility routines to help a developer

clean up identifier names.

In the 4 tasks you will gradually build up the routine `clean` A valid identifier comprises

zero or more letters and underscores.

In all cases the input string is guaranteed to be non-null. Note that the `clean` method should treat an empty string as valid.

Implement the (_static_) `Identifier.clean()` method to replace any spaces with underscores. This also applies to leading and trailing spaces.

Identifier.clean("my Id");

Modify the (_static_) `Identifier.clean()` method to replace control characters with the upper case string `"CTRL"`.

Identifier.clean("my\0Id");

Modify the (_static_) `Identifier.clean()` method to convert kebab-case to camelCase.

Identifier.Clean("à-ḃç");

Modify the (_static_) `Identifier.clean()` method to omit any Greek letters in the range 'α' to 'ω'.

Identifier.Clean("MyΟβιεγτFinder");

The Java `char` type represents the smallest addressable components of text.

Multiple `char`s can comprise a string such as `"word"` or `char`s can be

processed independently. Their literals have single quotes e.g. `'A'`.

Java `char`s support Unicode encoding so in addition to the latin character set

pretty much all the writing systems in use world can be represented,

e.g. ancient greek `'β'`.

There are many builtin library methods to inspect and manipulate `char`s. These

can be found as static methods of the `java.lang.Character` class.

`char`s are sometimes used in conjunction with a `StringBuilder` object.

This object has methods that allow a string to be constructed

character by character and manipulated. At the end of the process

`toString` can be called on it to output a complete string.

{

"authors": [

{

"github_username": "ystromm",

"exercism_username": "ystromm"

}

],

"forked_from": ["csharp/chars"]

}

- Know of the existence of the `char` type.

- Know what a char represents (a Unicode character).

- Know how to define a `char`.

- Know that a `char` is not the same as a single character string

- Know how to access a `char` in a string by index.

- Know of some basic `char` methods (like converting to uppercase).

- Know that `char`s are immutable.

- Know how to compare characters.

- Know how to use a `StringBuilder`.

- Converting an integer to a character and vice versa.

- Advanced unicode issues such as surrogates, text normalization, combining characters.

- Cultural considerations and invariants.

- `chars`: know of the existence of the `char` type; know that a `char` represents; know how to define a `char`; know how to access a `char` in a string by index; know of some basic `char` methods (like converting to uppercase).

- `StringBuilder`: know how to use this.

- `strings`: know of the `string` type that will be iterated over and accessed by index.

- `for-loop` for loops (rather than foreach) are the best means of highlighting the relationship between strings and `char`s

class Identifier {

static String clean(String identifier) {

final StringBuilder cleanIdentifier = new StringBuilder();

for (int i = 0; i < identifier.length(); i++) {

final char ch = identifier.charAt(i);

if (Character.isSpaceChar(ch)) {

cleanIdentifier.append("_");

} else if (Character.isISOControl(ch)) {

cleanIdentifier.append("CTRL");

} else if (ch == '-' && i < identifier.length() + 1) {

i++;

cleanIdentifier.append(Character.toUpperCase(identifier.charAt(i)));

} else if (ch >= 'α' && ch <= 'ω') {

} else if (Character.isAlphabetic(ch)) {

cleanIdentifier.append(ch);

}

}

return cleanIdentifier.toString();

}

}

apply plugin: "java"

apply plugin: "eclipse"

apply plugin: "idea"

repositories {

mavenCentral()

}

dependencies {

testCompile "junit:junit:4.13"

testImplementation "org.assertj:assertj-core:3.15.0"

}

test {

testLogging {

exceptionFormat = 'short'

showStandardStreams = true

events = ["passed", "failed", "skipped"]

}

}

class Identifier {

static String clean(String identifier) {

throw new UnsupportedOperationException("Please implement the (static) Chars.clean() method");

}

}

import org.junit.Test;

import org.junit.Ignore;

import static org.assertj.core.api.Assertions.assertThat;

public class IdentifierTest {

@Test

public void empty() {

assertThat(Identifier.clean("")).isEmpty();

}

@Ignore("Remove to run test")

@Test

public void single_letter() {

assertThat(Identifier.clean("A")).isEqualTo("A");

}

@Ignore("Remove to run test")

@Test

public void string() {

assertThat(Identifier.clean("àḃç")).isEqualTo("àḃç");

}

@Ignore("Remove to run test")

@Test

public void spaces() {

assertThat(Identifier.clean("my Id")).isEqualTo("my___Id");

}

@Ignore("Remove to run test")

@Test

public void leading_and_trailing_spaces() {

assertThat(Identifier.clean(" myId ")).isEqualTo("_myId_");

}

@Ignore("Remove to run test")

@Test

public void ctrl() {

assertThat(Identifier.clean("my\0Id")).isEqualTo("myCTRLId");

}

@Ignore("Remove to run test")

@Test

public void string_with_no_letters() {

assertThat(Identifier.clean("\uD83D\uDE00\uD83D\uDE00\uD83D\uDE00")).isEmpty();

}

@Ignore("Remove to run test")

@Test

public void kebab_to_camel_case() {

assertThat(Identifier.clean("à-ḃç")).isEqualTo("àḂç");

}

@Ignore("Remove to run test")

@Test

public void omit_lower_case_greek_letters() {

assertThat(Identifier.clean("MyΟβιεγτFinder")).isEqualTo("MyΟFinder");

}

@Ignore("Remove to run test")

@Test

public void combine_conversions() {

assertThat(Identifier.clean("9 -abcĐ\uD83D\uDE00ω\0")).isEqualTo("_AbcĐCTRL");

}

}