Strings in Java

StringTokenizer

The java.util.StringTokenizer class allows you to break a String into tokens. It is simple way to break a String

delimiter by default - spaces

import java.util.StringTokenizer;
public class Test{
    public static void main(String arg[]){
        String s = "Java is a general-purpose, class-based, and object-oriented language";
        StringTokenizer st = new StringTokenizer(s);
        while(st.hasMoreTokens()){
            String word = st.nextToken();
            System.out.println(word);
        }
    }
}

delimiter   characters '/', ':' and '.'

import java.util.StringTokenizer;
public class Test{
    public static void main(String arg[]){
        String s1 = "http://www.javasoft.com";
        StringTokenizer st1 = new StringTokenizer(s1,"/:.");
        while(st1.hasMoreTokens()){
            String word = st1.nextToken();
            System.out.println(word);
        }
    }
}

StringBuffer, StringBuilder

Java provides three classes to represent a sequence of characters: String, StringBuffer, and StringBuilder. The String class is an immutable class whereas StringBuffer and StringBuilder classes are mutable. The String class is much more faster under most implementations than StringBuffer, and StringBuilder

A StringBuffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls. String buffers are safe for use by multiple threads.

A StringBuilder provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.

The principal operations are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string builder. The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.

The methods length(), deleteCharAt(index), delete(start, end) , setCharAt(index, ch), setLength(newLength) are also commonly used.

public class Test{
    public static void main(String arg[]){
        StringBuffer sBuf = new StringBuffer ("new ") ;
        sBuf.append("test string buffer");
        System.out.println (sBuf) ;
        sBuf.setCharAt (3, 'J'); System.out.println (sBuf) ;
        sBuf.append (" 2") ; System.out.println (sBuf) ;
        sBuf.insert (3, "langage ") ; System.out.println (sBuf) ;
    }
}

public class Test{
    public static void main(String arg[]){
        StringBuilder sBuf = new StringBuilder ("new ") ;
        sBuf.append("test string builder");
        System.out.println (sBuf) ;
        sBuf.setCharAt (3, 'J'); System.out.println (sBuf) ;
        sBuf.append (" 2") ; System.out.println (sBuf) ;
        sBuf.insert (3, "langage ") ; System.out.println (sBuf) ;
    }
}

Enum Types

An enum declaration specifies a new enum type, a special kind of class type.
EnumDeclaration:
[ClassModifier] enum <Identifier> <EnumBody>

It is a compile-time error if an enum declaration has the modifier abstract or final.

An enum declaration is implicitly final unless it contains at least one enum constant that has a class body.

It is a compile-time error if the same keyword appears more than once as a modifier for an enum declaration.

An enum type has no instances other than those defined by its enum constants. It is a compile-time error to attempt to explicitly instantiate an enum type.

enum Coin { PENNY, NICKEL, DIME, QUARTER }
enum Weekday {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

Weekday d1,d2;
d1 = Weekday. MONDAY;
d2 = Weekday. TUESDAY;

It is possible to use operator == or the method equals().
Not possible to use the arithmetic operators.
It is possible to use the method compareTo() based of the order of constant's declarations.

System.out.println(d1+"");
will has as resut " MONDAY ".

Weekday.valueOf("TUESDAY")
will result as reference to Weekday. TUESDAY.

public class Test{
    enum Weekday {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }
    public static void main(String[] arg){
        Weekday d1,d2,d3;
        d1 = Weekday.MONDAY;
        d2 = Weekday.MONDAY ;
        d3 = Weekday.WEDNESDAY;
        System.out.println("operator=:\t"+(d1==d2)+"\t"+(d1==d3));
        System.out.println("method equal():\t"+d1.equals(d2));
        if(d1.compareTo(d3)<0){
            System.out.println(d1+" is before "+d3);
        }
    }
}

public class Test {
    enum Coin { PENNY, NICKEL, DIME, QUARTER }
    public static void main(String[] args) {
        Coin coin = Coin.NICKEL;
        switch (coin){
            case PENNY : System.out.println("1 cent"); break;
            case NICKEL : System.out.println("5 cents"); break;
            case DIME : System.out.println("10 cents"); break;
            case QUARTER: System.out.println("25 cents"); break;
            default : System.out.println("not possible");
        }
    }
}

Iterating over enum constants with an enhanced for loop for...each (after the creation an array with the méthode value() - static values() method returns an array containing all of the values of the enum in the order they are declared)

public class Test{
    enum Weekday {
       MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }
    public static void main(String[] arg){
       for(Weekday d: Weekday.values()){
           System.out.print(d+"; ");
       }
    }
}

public class Test{
    enum Weekday {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
        FRIDAY, SATURDAY, SUNDAY;
        String workTime(){
            if(this ==SUNDAY ){
                return "10 - 14";
            }
            if(this == SATURDAY){
                return "10 - 18";
            }
            return "8 - 22";
        }
    }
    public static void main(String[] arg){
        System.out.println("Working time:");
        for(Weekday d: Weekday.values()){
            System.out.println(d+": "+d.workTime());
        }
    }
}

The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions. You can find a detailed description of the class here

which returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. Returned values are chosen pseudorandomly with (approximately) uniform distribution from that range

Strings in java

Java.lang.String class creation

Java String Functions - see the Oracle's documentation for details

StringTokenizer

StringBuffer, StringBuilder

Enum Types