CareerCup

public class CheckDuplicatesInJavaArray {

    public static void main(String args[])  {

        String[] withDuplicates = new String[] {"one","two","three","one"};
        String[] withoutDuplicates = new String[] {"one","two","three"};

        System.out.println("Checking array with duplicate using Set and List: " + checkDuplicateUsingAdd(withDuplicates));
        System.out.println("Checking array without any duplicate using Set and List: " + checkDuplicateUsingAdd(withoutDuplicates));

    }

    /*
     * Since Set doesn't allow duplicates add() return false
     * if we try to add duplicates into Set and this property
     * can be used to check if array contains duplicates in Java
     */
    public static boolean checkDuplicateUsingAdd(String[] input) {
        Set tempSet = new HashSet();
        Map<String, Integer> tempMap = new HashMap<String, Integer>();
        boolean flag = false;
        for (String str : input) {
            if (!tempSet.add(str)) {
                tempMap.put(str, tempMap.get(str) + 1);
                flag = true;
            } else {
                tempMap.put(str, 1);
            }
        }

        for(Map.Entry<String, Integer> entry : tempMap.entrySet()){
            System.out.println(entry.getKey() + "/" + entry.getValue());
        }
        return flag;
    }
}

Performance will be much faster this way.

public class StringReverseExample {

    public static void main(String args[]) throws FileNotFoundException, IOException {

        //original string
        String str = "Sony is going to introduce Internet TV soon";
        System.out.println("Original String: " + str);

        //recursive method to reverse String in Java
        String reverseStr = reverseRecursively(str);
        System.out.println("Reverse String in Java using Recursion: " + reverseStr);

    }

    public static String reverseRecursively(String str) {

        //base case to handle one char string and empty string
        if (str.length() <= 1) {
            return str;
        }

        return reverseRecursively(str.substring(1)) + str.charAt(0);

    }
}

public class LongSequenceTest {

    public static ArrayList<Integer> LongSequence(Integer... sequence) {
        if (sequence == null || sequence.length == 0)
            return null;

        List<Integer> seqList =  new ArrayList<Integer>(Arrays.asList(sequence));
        Collections.sort(seqList);

        List<Integer> currentSeq = new ArrayList<Integer>();
        List<Integer> retSeq = new ArrayList<Integer>();

        currentSeq.add(seqList.get(0));
        int lastValue = seqList.get(0);
        int longSeq = 0;

        for(int i=1; i < seqList.size(); i++){

            if(lastValue+1 == seqList.get(i)){
                currentSeq.add(seqList.get(i));
                lastValue++;
            } else {
                if(longSeq == 0 || currentSeq.size() > longSeq){
                    longSeq = currentSeq.size();
                    retSeq = currentSeq;
                }
                lastValue = seqList.get(i);
                currentSeq = new ArrayList<Integer>();
                currentSeq.add(seqList.get(i));
            }
        }

        if (longSeq == 0 || currentSeq.size() > longSeq){
            retSeq = currentSeq;
        }

        return (ArrayList<Integer>) retSeq;
    }

    public static void main(String arg[]) {
        ArrayList<Integer> ret = LongSequence(7, 2, 3, 5, 6, 9);

        for(Integer i : ret) {
            System.out.print(i + " ");
        }
    }
}

public class Pets implements Comparable<Object>{

    String name;

    public Pets(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Pets){
            return name.compareTo(o.toString());
        }
        throw new RuntimeException("Only works for Pets Class.");
    }

    @Override
    public String toString() {
        return name;
    }
}

public class Cat extends Pets {

    public Cat(String name) {
        super(name);
    }
}

public class Dog extends Pets {

    public Dog(String name) {
        super(name);
    }
}

public class Test {
    public static void main(String arg[]) {
        Object[] pets = { new Dog("Max"), new Cat("Snow Ball"),
                new Dog("Brownie"), new Cat("Not so Brownie") };

        System.out.println("\nBefore Sorting:\n");
        displayHouse(pets);

        Arrays.sort(pets);

        System.out.println("\nAfter Sorting:\n");
        displayHouse(pets);
    }

    private static void displayHouse(Object[] pets) {
        for (Object pet : pets) {
            System.out.println(pet);
        }
    }
}

Before Sorting:
Max
Snow Ball
Brownie
Not so Brownie

After Sorting:
Brownie
Max
Not so Brownie
Snow Ball

From the book: Effictive Java(Page 20)
Avoid creating unnecessary objects -
It is often appropriate to reuse a single object instead of creating a new function-ally equivalent object each time it is needed. Reuse can be both faster and more stylish. An object can always be reused if it is immutable.

As an extreme example of what not to do, consider this statement:

String s = new String("stringette"); // DON'T DO THIS!

The statement creates a new String instance each time it is executed and none of those object creations is necessary. The argument to the String constructor("stringette") is itself a String instance, functionally identical to all of the objects created by the constructor. If this usage occurs in a loop or in a frequently invoked, millions of String instances can be created needlessly.

The improved version is simply the following:

String s = "stringette";

This version uses a single String instance, rather than creating a new one each time it is executed. Furthermore, it is guaranteed that the object will be reused by any other code running in the same virtual machine that happens to contain the same string literal.

I am just the messenger, just wanted to list the questions they asked.

This is a really good article(and site) on how hashmap works:

javarevisited.blogspot.com/2011/02/how-hashmap-works-in-java.html