Java Wrapper class, Math, Character and String Class
Topic 1: Java Wrapper Class
The built-in primitive types are not objects, and they do not have methods. To bridge the gap between the built-in types and the objects, Java defines Wrapper Classes for each of the primitive types. The wrapper classes are objects encapsulating primitive Java types:
Autoboxing: Automatically converting primitive values to their matching wrapper class objects.
Unboxing: Converting an object of a wrapper type to its corresponding primitive value.
Primitive Type
Wrapper Class
boolean
Boolean
char
Character
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
Wrapper Class Examples
Example - AutoBoxing and UnBoxing
The Character Class
Java provides a wrapper class named Character, which is an option for the variable's data type. The Character class object can hold a single character value just like a primitive char data type.
The Character class offers a number of useful methods for manipulating characters. All of the attributes, methods, and constructors of the Character class are specified by the Unicode Data file, which is maintained by the Unicode Consortium.
There are two ways to create a Character Class in Java:
Create a Character Literal: Character can be created by assigning a Character literal to a Character variable.
Use the new operator (Heap memory): JVM will create a new character object in normal (non-pool).
Example - Character and Char Data Type
In the below example, we are using both a Char primitive data type and a Wrapper class primitive data type.
Popular Methods in the Character Class
The Character class also provides several methods useful when manipulating, inspecting, or dealing with single-character data. Some popular methods of Character class are as follows:
Method
Description
isDigit(ch)
Returns True if the specified character is a digit.
isLetter(ch)
Returns True if the specified character is a letter.
isLetterOfDigit(ch)
Returns True if the specified character is a letter or a digit.
isLowerCase(ch)
Returns True if the specified character is a lowercase letter.
isUpperCase(ch)
Returns True if the specified character is an uppercase letter.
toLowerCase(ch)
Returns the lowercase of the specified character.
toUpperCase(ch)
Returns the uppercase of the specified character.
valueOf()
valueOf(String s),
valueOf(String s, int radix)
The valueOf method returns the relevant Number Object holding the value of the argument passed. The argument can be a primitive data type, string, etc.
Example - Methods in the Character Class
This example demonstrates how to use, declare, and initialize data type as character type using Character Class.
Character Class - Escape Sequence
You cannot have a String literal break across lines. How do you include a line break?
Solution: An escape sequence is a two-character sequence that represents a single special character.
An escape sequence is a character preceded by a backslash (\), which gives a different meaning to the compiler. The following table shows the escape sequences in Java:
Escape Sequence
Description
Inserts a tab in the text at this point.
\b
Inserts a backspace in the text at this point.
Inserts a new line in the text at this point.
Inserts a carrier return in the text at this point.
\f
Inserts a form feed in the text at this point.
\’
Inserts a single quote character in the text at this point.
\”
Inserts a double quote character in the text at this point.
\\
Inserts a backslash in the text at this point.
Example: Escape Sequence
Overview of String Class
String is a sequence of characters. For example, “Hello” is a string of five characters.
String is immutable. An Immutable Object means that the state of the object cannot change after its creation. “String is immutable,” means that you cannot change the object itself, but you can change the reference to the object.
There are methods for inserting and replacing characters of a String, but these methods return a brand new String object and do not modify the String on which the method was called.
Initializing and Declaring Strings
There are two ways to create Strings in Java:
Using String Literal: Strings can be created by assigning a String literal to a String variable:
String s1 = “welcome”;
String s2 = “welcome”; //it does not create a new instance.
Each time we 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 does not exist in the pool, a new string instance is created and placed in the pool.
Using the new operator:
String s = new String(“welcome"); //creates two objects and one reference variable.
In such a case, JVM will create a new string object in normal (non-pool) heap memory, and the literal “welcome" will be placed in the string constant pool. The variables will refer to the object on the heap (non-pool). The String class defines multiple constructors.
Popular String Methods
Java String class provides various methods to perform different operations on Strings. We will look into some of the commonly used string operations.
Conversion From String to Number
We can use parseInt() and valueOf() methods for conversion.
Conversion From Number to String
A
toString()
is an in-built method in Java that returns the value given to it in a string format. Hence, any object that this method is applied to will be returned as a string object. ThetoString()
method in Java has two implementations:The first implementation is when it is called a method of an object instance. See the example below:
The second implementation is when you call the member method of the relevant class by passing the value as an argument. See the example below:
Advanced String Manipulation - StringBuffer
StringBuffer is a peer class of String that provides much of the functionality of strings.
StringBuffer class creates objects that hold a mutable sequence of characters.
Substrings are inserted anywhere in the StringBuffer.
StringBuffer class extends (or inherits from) Object class.
The String represents fixed-length, immutable character sequences, while StringBuffer represents growable and writable character sequences.
A String is immutable. If you try to alter its value, another object gets created. A StringBuffer is mutable so it can change its value.
StringBuffer - Constructors
new StringBuffer()
→ Creates an empty String buffer with the initial capacity of 16.new
StringBuffer
(int capacity)
→ Creates an empty String buffer with the specified capacity as length.StringBuffer(100) → Room for 100 characters.
new
StringBuffer
(
String
str)
→ Creates a String buffer with the specified string.New StringBuffer(“Per Scholas”) → Room for given string and 16 additional characters.
Example One - StringBuffer
Create a class and add the code below to that class.
Example Two - StringBuffer
Create a class named StringbufferExampleTwo, and add the code below to that class.
Advanced String Manipulation - StringJoiner
StringJoiner is used to construct a sequence of characters separated by a delimiter; it optionally starts with a supplied prefix and ends with a supplied suffix.
Constructors.
New StringJoiner(“,”).
Creates StringJoiner that is comma-delimited (e.g., Mike, Bairon, and Erik).
new StringJoiner(“,”, “[“, “]”).
Creates StringJoiner that is comma-delimited, with each string surrounded by brackets (e.g., [Mike], [Bairon], [Erik]).
Example One - StringJoiner
Create a class named StringjoinnerDemoOne and add the code below to that class.
Example Two - StringJoiner
Create a class named StringjoinnerDemotwo and add the code below to that class.
Example Three - StringJoiner
Create a class named StringjoinnerDemothree and add the code below to that class.
Formatting Output on the Console
There are multiple ways to format Output in Java. Some of them are borrowed directly from old classics (e.g., printf from C), while others are more in the spirit of object-oriented programming (OOP).
Frequently used formatting ways include:
System.out.format().
System.out.printf().
String.format().
The printf() and format() Methods
Earlier, you saw the use of the print() and println() methods for printing strings to standard output (System.out). The Java programming language has other methods that allow you to exercise much more control over your print output when numbers are included. Those methods include:
System.out.printf(format, String... arguments);
System.out.format(format, String... arguments);
You can use format() or printf() anywhere in your code that previously used print or println.
Both methods are identical and behave similarly.
Examples One: format() Method Specifier
The Format Method Specifier expects at least one argument – the format string.
It can accept any number of additional arguments, and of any type.
The additional arguments are matched, in order to the format specifiers found within the format string.
The format specifiers must match the provided arguments; otherwise, an IllegalFormatException is thrown.
Examples Two: format() Method Specifier
This program shows some of the formatting that you can perform with format() methods.
The output is shown within the double quotes in the embedded comment:
Example One - printf() Method
If we have multiple printf() statements without a newline specifier:
Example Two - printf() Method
Create a new Java class and add the code below in that class:
Example Three - printf() Method
String.format() Method
Example - String.format()
Formatting Output on Console - DecimalFormat() Class
We often need to format numbers by taking two decimal places for a number or showing only the integer part of a number. Java provides a DecimalFormat class, which can help you to format numbers and use your specified pattern as quickly as possible.
DecimalFormat() class is actually designed to format any number in Java, be it integer, float or double.
Practice Problem: Monetary Units
Write a program that lets the user enter decimal dollars and cents, and outputs the monetary equivalent in single dollars, quarters, dimes, nickels, and pennies.
For example:
Input: 3.87
Output: 3 dollars
3 quarters
1 dime
0 nickels
2 pennies
Convert seconds to hh:mm:ss
The Math Class
Java provides many useful methods in the Math class for performing common mathematical functions.
Math class Methods Categories include:
Min, max, abs, and random methods.
Trigonometric methods.
Exponential methods.
Rounding methods.
We cannot create objects of the Java Math class because all of the variables and methods of Math class are ‘static.’
Math class contains two public static final variables, also called Constants:
PI.
E.
Example - Math Class Constant
The constants e and π are defined in the Math class.
By convention, names of constants are written in all uppercase: • Math.E and Math.PI
Create a class named MathDemo and write the code below in that class.
Overview of Min(), Max(), and Abs() Methods
Exponential and Logarithmic Methods
Example - Exponential Methods
Rounding Methods
The Math Class offers multiple methods to round off a number such as round(), ceil(), floor(), rint().
double ceil(double x).
x rounded up to its nearest integer. This integer is returned as a double value.
double floor(double x).
x is rounded down to its nearest integer. This integer is returned as a double value.
double rint(double x).
x is rounded to its nearest integer. If x is equally close to two integers, the even one is returned as a double.
int round(float x).
Return (int)Math.floor(x+0.5).
long round(double x).
Return (long)Math.floor(x+0.5).
Rounding Methods - Example One
Create a new class named “RoundingMethodDemo” and write the code below in that class.
The Random Method
Example One: The Random Method
Create a new class named RandonMethodDemoOne and write the code below in that class.
This Java program will generate integer numbers between 1 to 100.
Example Two: The Random Method
Create a new class named RandonMethodDemoTwo and write the code below in that class.
Java program to generate number between 100 to 1000.
Trigonometric Methods
The Math class contains methods for trigonometric operations such as cos(), sin(), tan(), tanh(), cosh(), atan() and etc.
Knowledge Check?
What are Wrapper Classes?
What is Autoboxing and Unboxing?
How do you declare a string in Java?
Is String a primitive or derived type in Java?
In Java, how can two Strings be compared?
How can we convert char into a String?
Wrapper Classes: Wrapper classes in Java are classes that wrap the primitive data types such as int, double, boolean, etc. They provide a way to use primitive data types as objects. Wrapper classes are often used in situations where an object is required, for example, when using collections, generics, or reflection.
Autoboxing and Unboxing: Autoboxing is the automatic conversion of a primitive data type into its corresponding wrapper class. Unboxing is the reverse process of converting an object of a wrapper class to its corresponding primitive data type. Autoboxing and unboxing are automatically performed by the Java compiler, so you can write code that uses primitive types and wrapper classes interchangeably.
Declaring a String in Java: To declare a String in Java, you can use the following syntax:
This creates a new String object with the value "Hello World" and assigns it to the variable
str.
String buffer
new String
String as a primitive or derived type in Java: In Java, String is not a primitive data type. It is a derived data type or a class. String is a built-in class in Java that provides methods for working with strings of characters.
Comparing two Strings in Java: In Java, you can compare two strings using the
equals()
method, which compares the content of the strings, or the==
operator, which compares the references to the strings. Here's an example:Converting char to String in Java: To convert a char to a String in Java, you can use the
valueOf()
method of the String class, like this:This creates a new String object with the value "a" and assigns it to the variable
str
Last updated