Elements that can be added to the Vector must be of type java.lang.Object. In other words, vectors cannot handle primitive data types like int, float, char and double as they are not objects. So in order to work with primitive type variables as if they were objects, Java provides class for each of the primitive types. These classes are known as wrapper classes. [Read more…] about What is Wrapper Class in Java With Example

Arrays have fixed length, they are not suitable for group of things that grow and shrink over the lifetime of an application. In such situations, Java provides the Vector class which is available in the standard java.util package.

A Vector is similar to an array in that it holds multiple objects and you can retrieve the stored objects by using an index value. However, the primary difference between an array and a Vector is that it can grow itself automatically when its initial capacity is exceeded. A Vector also provides methods for adding and removing elements that you would have to normally do manually in array. To sum up, the Vector class represents an ordered collection of objects that can be referenced using indexes, and can grow and shrink in size.

At any time, a Vector contains a number of elements that is less than or equal to its capacity. The capacity represents the size of the vector in memory. After the capacity is reached, the vector must grow before a new element can be added. The amount by which the Vector should grow is represented by its attribute capacity increment. If the capacity increment is 0, the array simply doubles in capacity each time its needs to grow.

The standard Vector class, java. uti1. Vector, is a parameterized class i.e. when you create an object of that class, you must supply the underlying type. For example, to create a vector of strings, the statement is

Vector<String> v = new Vector<String>();

A Vector can only add elements of object type, you cannot directly add a primitive data type such as int to a Vector

import java.util.Vector; 
 public class VectorinJava 
 { 
        public static void main(String[]args) 
     { 
          Vector<String> v = new Vector<String>(); 
          String[] days = {"Mon","Tue","fri","sat"}; 
          for(String str : days) 
             v.add(str); 
          System.out.println("No.of Elements in Vector is : "+ v.size()); 
          v.add("sun"); 
          v.add(2,"Wed"); 
          System.out.println("No.of Elements in Vector is : "+ v.size()); 
          System.out.println("First Elements in Vector is : "+v.firstElement()); 
          System.out.println("Last Elements in Vector is : "+ v.lastElement()); 
          System.out.println("Elements at Index 3 is : "+ v.get(3)); 
          v.remove("Sun"); 
          v.remove(5); 
          System.out.println("Element in Vector After Removel are...."); 
          for(String str : v) 
          System.out.println(str); 
     }   
 }  
 

StringBuffer deleteCharAt (int index): This method deletes the character at the specified position index from the string buffer. For example,

StringBuffer s1= new StringBuffer (“Helloo Java”);

str.deleteCharAt(4);

As a result, the character at the index 1 from the string buffer will be deleted and will now contain “Hello Java”.

public class StringBufferdeleteCharAt 
 { 
           public static void main(String[] args) 
       { 
              StringBuffer s1 = new StringBuffer("Helloo Java"); 
              s1.deleteCharAt(4); 
              System.out.println("s1 : " + s1); 
           } 
 } 
 

StringBuffer delete (int start, int end): This method is used to remove a sequence of characters from the StringBuffer object. The start represents the index of the first character to be deleted and end represents the index of one past the last character to remove. Therefore, the deleted substring runs from start to end -1. For example,

StringBuffer s1 = new StringBuffer(“Mr Dinesh Thakur “) :

str.delete(2,9);

results in deleting the substring starting from index 2 to 9 from this string buffer. The string buffer will now contain only “Mr Thakur”.

public class StringBufferDelete 
 { 
           public static void main(String[] args) 
       { 
              StringBuffer s1 = new StringBuffer("Mr Dinesh Thakur"); 
              s1.delete(2,9); 
              System.out.println("sl : " + s1); 
        } 
 } 
 

StringBuffer insert (int index, char [] str, int offset, int len) :This method inserts a substring into the StringBuffer object starting at position index. The substring is the string representation of len characters from the str []array starting at index position offset.

For example,

char[] chArr ={‘D’,’i’,’n’,’e’,’s’,’h’,’ ‘};

StringBuffer s2 = new StringBuffer(“Mr Thakur”);

s2.insert(3,chArr,0,7);

As a result, characters from chArr array starting from position 0 will be inserted in the invoking

string buffer at the position 3.So the resulting string buffer will be “ Mr Dinesh Thakur “.

public class StringBufferInsert 
 { 
           public static void main(String[] args) 
       { 
              StringBuffer s1 = new StringBuffer("Welcome Java"); 
              s1.insert(7," to"); 
              System.out.println("sl : " +s1); 
              StringBuffer s2 = new StringBuffer("Mr Thakur"); 
              char[] chArr ={'D','i','n','e','s','h',' '}; 
              s2.insert(3,chArr,0,7); 
              System.out.println("s2 : " + s2); 
           } 
 } 
 

StringBuffer append(char[] str,int offset,int len) :This method appends the substring to the end of the string buffer. The substring appended is a character sequence beginning at the index offset with the number of characters appended equal to len of the character array str. For example,

char [] chArr = {, t’ ,’o’ ” ‘,’ J’ ,’a’,’v’,’a’};

s1.append(chArr,2,5);

willl append’ ‘,’ J’ ,’a’,’v’,’a’ characters at the end of the string “Welcome”, which results in “Welcome Java”.

public class StringBufferAppendMethod 
 { 
        public static void main(String[] args) 
      { 
             StringBuffer s1 = new StringBuffer("Welcome"); 
             s1.append(" Dinesh Thakur"); 
             System.out.println("s1 : " +s1); 
             s1.append(" ").append("to").append(" Home").append("!"); 
             System.out.println("s1 : " +s1); 
             StringBuffer s2 = new StringBuffer("Welcome"); 
             char[] chArr = {'t','o',' ','j','a','v','a'}; 
             s2.append(chArr,2,5); 
             System.out.println("s2 : " + s2); 
       } 
 } 
 

String toString () : This method returns the value of the invoking StringBuffer object that invoked the method as a string. For example: The statement,

String s = s1.toString();

The String object s will contain “Hello Java”.

public class StringBuffertoString 
 { 
         public static void main(String[] args) 
      { 
             StringBuffer sl = new StringBuffer("Hello Java"); 
             System.out.println("sl.toString() : " + sl.toString());        
       } 
 } 
 

void setCharAt (int index, char ch) : This method sets the character at the specified index in the string buffer to the new character ch. For example, s1. setCharAt (6, ‘J’) will return Hello Java.

public class StringBuffersetCharAt 
 { 
         public static void main(String[] args) 
      { 
             StringBuffer sl = new StringBuffer("Hello java"); 
             sl.setCharAt(6,'J'); 
             System.out.println("sl.setCharAt(6,'J') : " + sl);          
       } 
 } 
 

String substring (int beginIndex) : This method returns a substring of the invoking StringBuffer. The substring returned contains a copy of characters beginning from the specified index position beginIndex and extends to the end of the string. For example, s1. substring (3) returns the substring lo Java.

String substring (int beginIndex, int endIndex) : This method is another version of previous method. It also returns a substring that begins at the specified index begin Index and extends to the character at the index endIndex-l. For example, the statement s1.substring (3, 6); returns the substring “lo”. One should always specify the valid index range.

public class StringBufferSubstring 
 { 
         public static void main(String[] args) 
      { 
             StringBuffer sl = new StringBuffer("Hello Java"); 
             System.out.println("sl.substring(3) =" + sl.substring(3)); 
             System.out.println("sl.substring(3,6)=" + sl.substring(3,6));             
       } 
 } 
 

char charAt (int index) : This method returns the character in the string buffer at the specified index position. The index of the first character is 0, the second character is 1 and that of the last character is one less than the string buffer length. The index argument specified must be greater than or equal to 0 and less than the length of the string buffer. For example, strl.charAt(1) will return character e i.e. character at the index position 1 on the StringBuffer str1.

public class StringBuffercharAt 
 { 
         public static void main(String[] args) 
      { 
             StringBuffer sl = new StringBuffer("Hello Java"); 
             System.out.println("sl.charAt(1) : " + sl.charAt(1)); 
       } 
 } 
 

void setLength(int newLength) : This method sets (change) the length of the string contained in the StringBuffer object. If the newly specified length is less than the current length of the string buffer, then the string buffer is truncated to contain exactly the number of characters contained in the newlength parameter. If the specified argument is greater than or equal to the current length, sufficient null characters (‘\ u0000′) are appended to the string buffer until the total number of characters in the string buffer is equal to the specified length. For example, if following is part of a statement, strl.setLength(10) As a result of this, the string referenced by strl will now contain “Welcome\u0000\u0000\u0000” Similarly, strl. setLength (5) will result in “Hell” .

public class StringsetLength 
 { 
          public static void main(String[] args) 
     { 
             StringBuffer s3 = new StringBuffer("Hello Java"); 
             s3.setLength(10); 
             System.out.println("s3.capacity () =  " + s3.capacity()); 
             System.out.println("s3.length() =  "  +  s3.length()); 
              
      } 
 } 
 

int length (): This method returns the number of characters currently in the invoking string buffer. For example,

str1.1ength ()

will return 10, which is the number of characters in the string literal Welcome that is referenced by strl.

public class StringLength 
 { 
          public static void main(String[] args) 
     { 
             StringBuffer s1 = new StringBuffer(); 
             StringBuffer s2 = new StringBuffer(35); 
             StringBuffer s3 = new StringBuffer("Hello Java"); 
             System.out.println("s1.length() =  "  + s1.length()); 
             System.out.println("s2.length()  = " + s2.length()); 
             System.out.println("s3.length() =  "  + s3.length()); 
              
      } 
 } 
 

int capacity () : This method returns the current capacity of the string buffer i.e. number of characters it is able to store without allocating more memory. While discussing capacity () methods, we assume that the StringBuffer object str1 exists which is defined as follows,

StringBuffer str1 = new (“Hello java”);

For example,

str1. capacity ()

it will return 26 which is the sum of length of the string literal referenced by str1 and 16.

public class StringCapacity 
 { 
          public static void main(String[] args) 
     { 
             StringBuffer sl = new StringBuffer(); 
             StringBuffer s2 = new StringBuffer(35); 
             StringBuffer s3 = new StringBuffer("Hello Java"); 
             System.out.println("sl.capacity()  =  " +sl.capacity()); 
             System.out.println("s2.capacity() = "+s2.capacity()); 
             System.out.println("s3.capacity () =  " + s3.capacity()); 
              
      } 
 } 
 

The String class also provide methods for extracting characters from a string in an array of bytes. This is achieved using the getBytes () method in the String class. This method converts the original string characters into the character encoding used by the underlying operating system which is usually ASCII . For example : The statement,

byte[] txtArray = s1.getBytes();

extracts character from the String object s1 and stores them in the byte array txtArray. There are many other forms of getBytes () available.

public class GetBytesMethods 
 { 
        public static void main(String[] args) 
        { 
            String sl = "Hello Java" ; 
            byte[] txtArray = sl.getBytes(); 
            for( int i=0 ;i<txtArray.length; i++) 
               System.out.println("txtArray["+i+"] = " + txtArray[i]); 
        } 
 } 
 

As we know that strings are not arrays so the String class also provides methods to convert a string to an array of characters and vice versa. These include

toCharArray();

getChars();

valueOf();

char [] toCharArray (): This method converts the invoking string to an array of individual characters. For example : The statement,

char[] ch = sl.toCharArray();

will convert the string Welcome which is referenced by sl to an array of characters such that ch [0] contains ‘W’, ch [1] contains ‘e’ and so on.

void getChars(int srcBegin, int srcEnd, chsr[] dest, int destBegin): This method copies a substring of the invoking string from index srcBegin to index srcEnd-1 into a character array dest starting from index destBegin. For example: The statement,

char[] txtArray = new char[3];

sl.getChars(3,6,txtArray,O);

will copy characters from the String object slat index position 3 to 5 (i.e. 6 – 1) inclusive, so txtArray[0] will be ‘c’, txtArray[1] will be ‘0’ and txtArray[2] will be ‘m’.

static String valueOf (char [] ch): This method will covert an array of characters to a string. For example : The statements,

char[] ch = {‘W’, ‘E’, ‘L’, ‘C’, ‘0’, ‘M’, ‘E’};

String str String.valueOf(ch);

will return the string Welcome from a character array ch and store the reference in str. There are several versions of valueOf () method that can be used to convert a character and numeric values to strings with different parameter types including in t, long, float, double and char.

Now let us consider a example to show how these work.

public class ConversionMethods 
 { 
          public static void main(String[] args) 
       { 
          
           String s1 = "Welcome" ; 
           char[] txtArray = new char[3]; 
           char [] ch = s1.toCharArray(); 
           for( int i =0; i<ch.length; i++) 
                System.out.println("ch["+i+"] = " +ch[i]); 
                s1.getChars(3,6,txtArray,0); 
                for( int i=0;i<txtArray.length;i++) 
                     System.out.println("txtArray["+i+"] = "+txtArray[i]); 
                     char[] c = {'W','E','L','C','O','M','E'}; 
                     String str = String.valueOf(ch); 
                     System.out.println("str = " + str); 
       } 
 } 
 

boolean matches (String regex): This method tests whether or not the invoking string matches the given regular expression regex. It returns true if invoking string matches the given regular expression otherwise it returns false.It is different from the equals () method where you can only use the fixed strings. Forexample,

” DineshThakur”.matches(“Dinesh”) // returns false

” DineshThakur”.matches(“Dinesh.*”) // returns true

public class StringMatches 
 { 
        public static void main(String[] args) 
     { 
             String s1 = "DineshThakur" ; 
             System.out.println("Use of matches() methods"); 
             System.out.println("s1.matches(\"Dinesh\") : " + s1.matches("Dinesh")); 
             System.out.println("s1.matches(\"Dinesh.*\") : " + s1.matches("Dinesh.*")); 
      } 
 } 
 

String [] split (String regex):This method splits the invoking string into substrings at each match for a specified regular expression regex and returns a reference to an array of substrings. For example, consider the statements.

String str = “Hello Java”;

String[] s = str.split(“[]”);

The first statement defines the string to be analyzed. The second statement calls the split () method for the str object to decompose the string. The regular expression includes the delimiterspace so it will return a reference to array of strings where s[0] contains Welcome, s[1] contains toand s[2] contains Java.

public class StringSplit 
 { 
      public static void main(String[] args) 
      { 
             String str3 = "Where there is a Will , there is a way"; 
             String str[] = str3.split(" "); 
                  for(int i=0;i<str.length;i++) 
                       System.out.println("str[" + i + "]  : " + str[i]); 
       } 
 } 
 

String replaceFirst (String regex, String replace): This method replaces the first substring in the invoking string that matches the given regular expression with the specified replacement string replace. For example,

s3.replaceFirst(“is”,”was”);

It will replace the first occurrence of substring is with the substring was in the given string.

public class StringReplaceFirst 
 { 
      public static void main(String[] args) 
      { 
             String str3 = "Where there is a Will , there is a way"; 
             System.out.println("str3.replaceFirst(\"is\" ,\"was\") = " +str3.replaceFirst("is" ,"was")); 
       } 
 } 
 

String replaceAll (String regeX, String replace): This method replaces all substrings in the invoking string that matches the given regular expression pattern regeX with the specified replacement string replace. For example,

Str1.replaceAll(“[aeiou]”,”#”);

It will replace all vowels in the invoking string with # symbol. Here [aeiou] is a regular expression which means any of the characters between the square brackets will match

Str3.replaceAll(“is”,”was”);

This statement will replace the substring is with the substring was in the given string. You can get the details of the regular expression from the Sun’s website.

public class StringReplaceAll 
 { 
      public static void main(String[] args) 
      { 
             String strl = "Welcome"; 
             String str3 = "Where there is a Will , there is a way"; 
             System.out.println("str3.replaceAll(\"is\",\"was\") = " +str3.replaceAll("is" ,"was")); 
             System.out.println("strl.replaceAll(\"[aeiou]\" ,\"#\") = " +strl.replaceAll("[aeiou] " ,"#")); 
       } 
 } 
 

String replace (char oldchar, char newchar): This method returns a new string resulting from replacing all the occurrence of oldchar in the invoking string with newchar. For example,

sl.replace(‘e’, ‘E’); //returns Hello DinEsh

public class StringReplace 
 { 
      public static void main(String[] args) 
      { 
             String str1 = "Hello Dinesh"; 
             System.out.println("str1.replace('e','E') = "+str1.replace('e','E')); 
       } 
 } 
 

String trim (): This method returns a copy of the string, with leading and trailing white spaces omitted. For example,

String str1 = “Hello Dinesh    “ ;

strl.trim(); //returns Hello Dinesh

String str1 = “Hello Dinesh    “ ; 
 strl.trim(); //returns Hello Dinesh 
 public class StringTrim 
 { 
      public static void main(String[] args) 
      { 
             String str1 = "     Hello Dinesh        "; 
              System.out.println("str1.trim() = " + str1.trim()); 
       } 
 }