-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathString_function.java
More file actions
218 lines (172 loc) · 12.3 KB
/
String_function.java
File metadata and controls
218 lines (172 loc) · 12.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
/*
author: Jaydatt Patel
Different String functions
String is immutable and characters or String length will be constant and can not modify it..
*/
class String_function {
public static class A_class{
int id;
String name;
A_class(int a,String s)
{id = a; name = s;}
// toString() function automatically called when class to String type cast needed.
public String toString(){
return(" id :" + id+" name : "+ name);
}
}
public static void main(String args[])
{
String str1 = "Welcome ";
char temp[] = {'T','o'};
String str2 = new String(temp);
String str3 = new String(str1+str2+" Java Programming");
System.out.println("\nstr1: "+str1+"\nstr2: "+str2+"\nstr3: "+str3);
//toString() overloaded
A_class obj = new A_class(123,"XYZ123");
String str4 = "Class toString() overloaded- str4 : " + obj;
System.out.println("\n"+str4);
//String variable s.isEmpty() to check empty or not, s.isBlank() to chech string is empty or white space only
System.out.println("\nstr3.isEmpty(): "+str3.isEmpty());
System.out.println("str3.isBlank(): "+str3.isBlank());
System.out.println("\" \".isBlank(): "+" ".isBlank());
//String variable s.toLowerCase(), s.toUpperCase() to get upper and lower case string
System.out.println("\n\"University\".toLowerCase(): "+"University".toLowerCase());
System.out.println("\"University\".toUpperCase(): "+"University".toUpperCase());
System.out.println("str3.toLowerCase(): "+str3.toLowerCase());
System.out.println("str3.toUpperCase(): "+str3.toUpperCase());
//String(byte[] byte_arr). Construct a new String by decoding the byte array. It uses the platform’s default character set for decoding.
byte[] byte_arr1 = {65,66,67,68,69};
String str5 =new String(byte_arr1);
System.out.println("\nstr4 = String(byte_arr) : "+str5);
/*
convert byte[],char[],int[] into String :
String(byte[] b_array, int start_index, int count)
String(char[] char_array, int start_index, int count)
String(int[] int_array, int start_index, int count) */
byte[] byte_arr2 = {75, 76, 77, 78, 79};
String str6 = new String(byte_arr2, 1, 3);
System.out.println("str6 = String(byte_arr2, 1, 3): "+ str6);
char[] char_arr1 = {75, 76, 77, 78, 79};
String str7 = new String(char_arr1, 1, 3);
System.out.println("str7 = String(char_arr1, 1, 3): "+ str7);
int[] int_arr = {75, 76, 77, 78, 79};
String str8 = new String(int_arr, 1, 3);
System.out.println("str8 = String(int_arr, 1, 3): "+ str8);
/*
v.getChars( start, end, c1, c1_start_index) used to convert substring or entire String into char array.
*/
char[] char_arr2 = new char[str3.length()];
str3.getChars(11,15,char_arr2,0);
System.out.print("char_arr2 = str3.getChars(11,15,char_arr2,0)["+str3+"] : ");
System.out.println(char_arr2);
//v.toCharArray() used to convert entire String to Character array
char[] char_arr3 = str3.toCharArray();
System.out.print("char_arr3 = str3.toCharArray()["+str3+"] : ");
System.out.println(char_arr3);
/*
v.length() : return length of String
v.charAt(int) : return character of specified poision
v.substring(start index) : return substring from starting to max length index.
v.substring(start index, end index) : return substring from starting to end index specified.
*/
System.out.println("\n\"Welcome To Java\".length(): "+ "Welcome To Java".length());
System.out.println("\"Welcome To Java\".charAt(11): "+ "Welcome To Java".charAt(11));
System.out.println("\"Welcome To Java\".substring(8): "+ "Welcome To Java".substring(8));
System.out.println("\"Welcome To Java\".substring(3,7): "+ "Welcome To Java".substring(3,7));
//concatenation : String v.concat(string).concat(String).concat(String)...........
String str9 = str1.concat(" "+str2+ " ").concat("Java").concat(" in ").concat("University");
System.out.println("\ns1.concat(str2).concat(str3).concat(\"in\").concat(\"University\") :\n str9 : "+ str9);
/*
String v.indexOf(string) : Match string and return first index number. If not match then -1.
String v.indexOf(string, from index) : Match string from specific index number and return first index number. If not match then -1.
*/
System.out.println("\n\"Welcome To Java\".indexOf(\"avj\"): "+ "Welcome To Java".indexOf("avj"));
System.out.println("\"Welcome To Java\".indexOf(\"Java\"): "+ "Welcome To Java".indexOf("Java"));
System.out.println("\"Learn Share Learn\".indexOf(\"a\",3): "+ "Learn Share Learn".indexOf("a",3));
//String v.lastIndexOf(string, from index) : Match string in reverse order and return last matching index number. If not match then -1.
System.out.println("\"Learn Share Learn\".lastIndexOf(\"a\"): "+ "Learn Share Learn".lastIndexOf("a"));
System.out.println("\"Learn Share Learn\".lastIndexOf(\"a\",4): "+ "Learn Share Learn".lastIndexOf("a",4));
/*
String v.equals(String) : return bool after compare characters between two string in Case sensitive
v.equalsIgnoreCase(String) : return bool after compare characters between two string ignoring Case sensitive
*/
System.out.println( "\n\"Java\".equals(\"Java\"): "+"Java".equals("Java")); // returns true
System.out.println( "\"Java\".equals(\"java\"): "+"Java".equals("java")); // returns false
System.out.println( "\"Java\".equalsIgnoreCase(\"Java\"): "+"Java".equalsIgnoreCase("Java")); // returns true
System.out.println( "\"Java\".equalsIgnoreCase(\"java\"): "+"Java".equalsIgnoreCase("java")); // returns true
/*
v.compareTo(String) : returns difference str1-str2 after compare characters between two string in Case sensitive in dictionary order.
v.compareToIgnoreCase(String) : returns difference str1-str2 after compare characters between two string ignoring Case sensitive dictionary order.
if out<0, str1 comes before str2. if out=0, str1 and str2 are equal. if out>0, str1 comes after str2. */
System.out.println( "\n\"Java\".compareTo(\"Java\"): "+"Java".compareTo("Java")); // returns 0
System.out.println( "\"Java\".compareTo(\"java\"): "+"Java".compareTo("java")); // returns -32
System.out.println( "\"Java\".compareTo(\"java\"): "+"java".compareTo("Java")); // returns 32
System.out.println( "\"Java\".compareToIgnoreCase(\"Java\"): "+"Java".compareToIgnoreCase("Java")); // returns 0
System.out.println( "\"Java\".compareToIgnoreCase(\"java\"): "+"Java".compareToIgnoreCase("java")); // returns 0
//String v.contains(String) Returns true if string match found else false.
System.out.println("\n\"Welcome To Java\".contains(\"Java\"): "+ "Welcome To Java".contains("Java"));
// Java String class intern() method returns the interned string. It can be used to return string from memory if it is created by a new keyword. It creates an exact copy of the heap string object in the String Constant Pool.
//Each time you create a string literal, the JVM checks the "string constant pool" first. If the string already exists in the pool, a reference to the pooled instance is returned. If the string doesn't exist in the pool, a new string instance is created and placed in the pool.
String str10 = new String("Java");
String str11 = new String("Java");
System.out.println("(str10 == str11)" +" ("+str10+" == "+str11+") : " +(str10 == str11)); // return false
String str12 = new String("Java").intern();
String str13 = new String("Java").intern();
System.out.println("(str12 == str13)" +" ("+str12+" == "+str13+") : " +(str12 == str13)); // return true
/*
v.regionMatches() : compares specific region inside a string
boolean regionMatches(int str1StartIndex, String str2, int str2StartIndex, int length_char)
boolean regionMatches(boolean ignoreCase, int str1StartIndex, String str2, int str2StartIndex, int length_char)
*/
String str14 = new String("Welcome To Java");
String str15 = new String("Java");
String str16 = new String("java");
System.out.println("\nstr14.regionMatches(11, str15, 0, 4) : "+
str14.regionMatches(11, str15, 0, 4));
System.out.println("str14.regionMatches(11, str16, 0, 4) : "+
str14.regionMatches(11, str16, 0, 4));
System.out.println("str14.regionMatches(true, 11, str16, 0, 4) : "+
str14.regionMatches(true,11, str16, 0, 4));
/*
v.startWith(string) , v.startWith(string,offset) :
This method of the String class checks whether the given string starts with the specified string prefix or not.
v.endsWith(string), v.endsWith(string,offset) :
This method of the String class checks whether the given string ends with the specified string suffix or not.
*/
System.out.println("\nstr3.startsWith(\"Wel\")"+"["+str3+"] : "+ str3.startsWith("Wel"));
System.out.println("str3.startsWith(\"To\")"+"["+str3+"] : "+ str3.startsWith("To"));
System.out.println("str3.endsWith(\"Java\")"+"["+str3+"] : "+ str3.endsWith("Java"));
System.out.println("str3.endsWith(\"ing\")"+"["+str3+"] : "+ str3.endsWith("ing"));
//String v.trim() : Returns the copy of the String, by removing whitespaces at both ends. It does not affect whitespaces in the middle.
System.out.println("\n\" University \".trim(): "+" University ".trim());
/*
String v.replace(old char, new char) :Returns new string by replacing all occurrences of oldChar with newChar.
String v.replaceFirst(old char, new char) : Returns new string by replacing first occurrences of oldChar with newChar.
*/
System.out.println("\n\"Welcome To Java\".replace(\"Java\", \"World\"): "+ "Welcome To Java".replace("Java", "World"));
System.out.println("\"Welcome To Java\".replaceFirst(\"a\", \"@\"): "+ "Welcome To Java".replaceFirst("a", "@"));
//String v.repeat(int) : Returns new string by repeating string as per number count.
System.out.println("\n\"Welcome \".repeat(3): "+ "Welcome ".repeat(3));
//String.valueOf(int/char/double/object) or v.valueOf() is static method to converts different data types of values into string.
System.out.println("\n(String.valueOf(30)+10): "+(String.valueOf(30)+10));
System.out.println("(String.valueOf(15.4)+10): "+(String.valueOf(15.4)+10));
System.out.println("(String.valueOf(obj): "+(String.valueOf(obj))); //obj.toString() passed as parameter
/*
String v.split("\\s") : splits the string based on whitespace
String v.split("\\s",word limit) : splits the entire string based on whitespace into specific word limit but zero for no limit
String v.split("string",word limit) splits the entire string based on whitespace into specific word limit but zero for no limit
*/
String str17[] = str3.split("\\s");
System.out.println("\nstr17[] = str3.split(\"\\s\") : ");
for(int i = 0; i < str17.length; i++ )
System.out.println("str17["+i+"] : "+str17[i]);
String str18[] = str3.split("\\s",2);
System.out.println("\nstr18[] = str3.split(\"\\s\",2) : ");
for(int i = 0; i < str18.length; i++ )
System.out.println("str18["+i+"] : "+str18[i]);
String str19[] = "Welcome@To@Java@Programming".split("@",2);
System.out.println("\nstr19[] = \"Welcome@To@Java@Programming\".split(\"@\",2) : ");
for(int i = 0; i < str19.length; i++ )
System.out.println("str19["+i+"] : "+str19[i]);
}
}