# Strings
## Character
A character represents a single symbol. A symbol can be any of the following:
* Uppercase Characters **[A - Z]**
* Lowercase Characters **[a - z]**
* Numeric Characters **[0 - 9]**
* Special Characters **[@ , $ , # , < , = , etc.]**
### Syntax
``` java
char name = 'single_character';
```
Code :
``` java
char ch = 'a';
```
### American Standard Code for Information Interchange
### Rules of Typecasting
1. **Char to int** is implicit typecasting, we get the ASCII value of the character
Code 1:
``` java
Line1: int x = 'a';
Line2: x = x+2;
Line3: System.out.println(x);
```
Output:
``` java
99
```
Explanation:
```
The ASCII value of 'a' is 97.
So, 97 is stored in variable x.
Line 2 increments the value of x by 2
Hence, Line 3 prints 99 in the output.
```
Code 2:
``` java
Line1: char ch = 'A';
Line2: int x = ch;
Line3: System.out.println(x);
```
Output:
``` java
65
```
Explanation:
```
The ASCII value of 'A' is 65.
So, when we try to store the value of ch into x, 65 is stored.
Hence, Line 3 prints 65 in the output.
```
2. **Char to int** gives error sometimes, so explicitly typecast
Code 1:
``` java
Line1: char ch = 'A' + 2;
Line2: System.out.println(ch);
```
Output:
```
C
```
Explanation:
```
When we perform operation between char and int we get int.
65 + 2 gives 67 which is the ASCII value of 'C'
Line 2 prints C in the output.
```
Code 2:
``` java
Line1: char ch5 = 'A';
Line2: ch5 = ch5 + 32;
Line3: System.out.println(ch5);
```
Output:
```
Error : possible lossy conversion from int to char
```
Explanation:
```
When we perform operation between char and int we get int.
We are trying to store int to char and it gives error.
```
Code 3:
``` java
Line1: char ch5 = 'A';
Line2: ch5 = (char)(ch5 + 32);
Line3: System.out.println(ch5);
```
Output:
```
a
```
Explanation:
```
When we perform operation between char and int we get int.
65 + 32 gives 97 which is the ASCII value of 'a'
Line 2 prints a in the output.
```
3. We can use operators with char
Code 1:
``` java
Line1: char ch7 = 'B';
Line2: if(ch7 >= 90){
Line3: System.out.println("YES");
Line4: }
Line5: else{
Line6: System.out.println("NO");
Line7: }
```
Output:
```
NO
```
Explanation:
```
The ASCII value of 'B' is 66.
Since 66 is not greater than or equals to 90, the condition is false.
So, else block is executed.
Line 6 prints NO in the output.
```
Code 2:
``` java
Line1: char ch1 = 'B';
Line2: char ch2 = 'a';
Line3: if(ch2 >= ch1){
Line4: System.out.println("YES");
Line5: }
Line6: else{
Line7: System.out.println("NO");
Line8: }
```
Output:
```
YES
```
Explanation:
```
The ASCII value of 'B' is 66 and 'a' is 97.
Since 97 is greater than or equals to 66, the condition is true.
So, if block is executed.
Line 4 prints YES in the output.
```
## Character Array
### Syntax
```
char name[] = new char[size];
```
Code:
``` java
static void printChar(char data[]){
int N = data.length; // Index : 0 to N-1
for(int i=0;i<N;i++){
System.out.print(data[i] + " ");
}
System.out.println();
}
public static void main(String args[]) {
char ch[] = new char[5];
ch[0] = 'A';
ch[1] = 'B';
ch[2] = 67;
ch[3] = 'D';
ch[4] = 'E';
printChar(ch);
}
```
Output:
``` java
A
B
C
D
E
```
Explanation:
```
An array of character is created of size 5.
ch : [ 'A' | 'B' | 'C' | 'D' | 'E' ]
0 1 2 3 4
We print all the elments of the array using the function printChar()
```
## String
### Syntax
```
String name = "value";
```
Code:
``` java
String str = "MonaLisa";
```
Each of the characters have indexes starting from 0.
```
"MonaLisa"
index: 01234567
```
### Properties
1. To get total number of characters present in string: **name.length()**
Code:
``` java
String str = "MonaLisa";
System.out.println(str.length());
```
Output:
```java
8
```
Explanation:
```
The given string has 8 characters.
```
2. To access a character at any particular index: **name.charAt(index)**
Code:
``` java
String str = "MonaLisa";
System.out.println(str.charAt(4));
```
Output:
```java
L
```
Explanation:
```
The given string has 'L' at 4th index.
```
3. We **cannot** update characters at particular indices.
4. We can append a character or String at the start or end of a String
Code 1:
``` java
String str = "Hell";
str = str + 'o';
System.out.println(str);
```
Output:
``` java
Hello
```
Explanation:
```
Here, we are appending a character at the end.
```
Code 2:
``` java
String str = "Hello";
str = "Guys " + str;
System.out.println(str);
```
Output:
``` java
Guys Hello
```
Explanation:
```
Here, we are appending a string at the start.
```
## StringBuilder
In order to update character at particular indices we use StringBuilder.
### Syntax
```
StringBuilder name = new StringBuilder(String_name);
```
Code:
``` java
String str = "Hello";
StringBuilder sb = new StringBuilder(str);
System.out.println(sb);
```
Output:
``` java
Hello
```
Explanation:
```
StringBuilder sb is created having value "Hello" in it.
```
### Functions
Code:
``` java
Line1: String str = "Hello";
Line2: StringBuilder sb = new StringBuilder(str);
Line3: System.out.println(sb.length());
Line4: System.out.println(sb.charAt(1));
Line5: sb.setCharAt(1, 'x');
Line6: System.out.println(sb);
Line7: System.out.println(sb.append("abc"));
Line8: System.out.println(sb.append('w'));
```
Output:
``` java
5
e
Hxllo
Hxlloabc
Hxlloabcw
```
Explanation:
```
name.length() -> gives total number of characters
name.charAt(index) -> gives character present at that index
name.setCharAt(index, character) -> helps us to update the character at particular index
name.append(String) -> helps us add the string at the end of the stringBuilder
name.append(character) -> helps us add a character at the end of stringBuilder
```
***NOTE:*** Whenever you want to make changes in your String prefer using StringBuilder.
### Converting StringBuilder to String
We can use **name.toString()** function to convert a StringBuilder into String.
For eg. Write a code to change character at 1st index to 'x' in the given String.
Code:
```java
String str = "Hello";
StringBuilder sb = new StringBuilder(str);
sb.setCharAt(1, 'x');
String ans = sb.toString();
System.out.println(ans);
```
Output:
``` java
Hxllo
```
To know more details about StringBuilder refer this link: [Link](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html#setCharAt(int,%20char))
Sign in with Wallet
Connect another wallet