In Java and other object-oriented languages, objects are collections of related data that come with a set of methods. These methods operate on the objects, performing computations and sometimes modifying the object’s data. Here we introduce three simple but important Java built-in object types: Number, String and Array.
Basically, we use primitive number types such as byte, int, double etc. However, sometimes we need to use objects instead of primitive data types. Java provides wrapper classes for primitive data types. They are Byte, Short, Long, Integer, Double, Float etc. A wrapper object can be converted back to a primitive data type. This process is called unboxing. The Number class is part of the java.lang package. Packages will be talked about later.
Following is a list of some of the common class methods that the subclasses of the Number class implement:
Example:
Write the following code in the /home/labex/project/numberTest.java file:
public class numberTest
{
public static void main(String[] args){
Integer x = 1; // boxes int to an Integer object
x = x + 1; // unboxes the Integer to an int
System.out.println(Integer.parseInt("10")); // parse int from a string
System.out.println( "x = " + x);
}
}Output:
Run the numberTest.java file using the following command:
javac /home/labex/project/numberTest.java
java numberTestSee the output:
10
x = 2Strings are objects, so you might ask: “What is the data contained in a String object?” and “What are the methods we can invoke on String objects?” The components of a String object are characters. Not all characters are letters; some are numbers, some others are special symbols and the rest are other classes of characters. For simplicity, we call all of them characters. There are many string methods in String class, but we will use only a few of them. The rest can be referred to in the documentation at the official website.
Note: The String class is immutable, so once created a String object cannot be modified. If there is a necessity to make a lot of modifications to Strings of characters, then you should use StringBuffer and StringBuilder classes.
Following is a list of some of the common methods of the String, StringBuffer and StringBuilder classes:
index argument, is returned.dst.StringBuffer. The substring begins at the specified index and extends to the end of the StringBuffer.String that contains a subsequence of characters currently contained in this StringBuffer.Example:
Write the following code in the /home/labex/project/stringTest.java file:
public class stringTest
{
public static void main(String[] args){
String greeting = "Hello world!";
String hello = new String("Hello !");
System.out.println("greeting is: "+ greeting);
System.out.println("hello is: "+ hello);
System.out.println("length of greeting: " + greeting.length());
System.out.println("first char of greeting: " + greeting.charAt(0));
System.out.println("index of 'e' in hello: "+ hello.indexOf('e'));
System.out.println("substring of greeting: "+ greeting.substring(6)); //substr: world
}
}Output:
Run the stringTest.java file using the following command:
javac /home/labex/project/stringTest.java
java stringTestSee the output:
greeting is: Hello world!
hello is: Hello !
length of greeting: 12
first char of greeting: H
index of 'e' in hello: 1
substring of greeting: world!An array structure is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of a single type. Instead of declaring individual variables, such as number0, number1,..., number99, you declare one array variable numbers and use numbers[0], numbers[1], ..., numbers[99] to represent individual variables. The first element of array is at an index of 0.
Following is a list of some of the common methods that arrays have:
(–(insertion point + 1)).longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. The same method could be used by other primitive data types (byte, short, int etc.) also.int value to each element of the specified array of ints. The same method could be used by other primitive data types (byte, short etc.) also.byte, short, int etc.) also.Example:
Write the following code in the /home/labex/project/arrayTest.java file:
public class arrayTest
{
public static void main(String[] args){
// you can use new to initialize an empty array.
String[] nameArray1 = new String[5];
// fill the empty nameArray1 items with same name "abc"
java.util.Arrays.fill(nameArray1,"abc");
// the for loop can also be used to iterate an Array
for (String name:nameArray1){
System.out.println(name);
}
// you can use some value to initialize the array.
String[] nameArray2 = {"Candy", "Fancy", "Ann", "Ella", "Bob"};
// you can get the length of the array
System.out.println("Length of nameArray2: " + nameArray2.length);
// you can get value by index
System.out.println("The last item of nameArray2 is " + nameArray2[4]);
// sort an array object
java.util.Arrays.sort(nameArray2);
System.out.println("Sorted nameArray2 by alphabet:");
for(String name:nameArray2){
System.out.println(name);
}
}
}Output:
Run the arrayTest.java file using the following command:
javac /home/labex/project/arrayTest.java
java arrayTestSee the output:
abc
abc
abc
abc
abc
Length of nameArray2: 5
The last item of nameArray2 is Bob
Sorted nameArray2 by alphabet:
Ann
Bob
Candy
Ella
FancyMost of the tasks are to manipulate data like numbers and strings, so using Java built-in classes to perform the tasks is easy and efficient. For advanced usage, you can read official documentation.
