Checking if all the characters from an A-Z is present in the string A string is said to be complete if it contains all the characters from
  a to z. Given a string, check if it complete or not.
  
  Input First line of the input contains the number of strings N. It is
  followed by N lines each contains a single string.
  
  Output For each test case print "YES" if the string is complete, else
  print "NO"
  
  Constraints 1 &lt;= N &lt;= 10 The length of the string is at max 100 and
  the string contains only the characters a to z.


Here are the two solutions that I wrote:

class TestClass {
    private static byte N;
    public static void main(String args[] ) throws Exception {
        BufferedReader keyboard = new BufferedReader(new InputStreamReader(
                System.in));
       N = Byte.parseByte(keyboard.readLine());
        for (byte i = 0; i &lt; N; i++) {
            String testingString = keyboard.readLine();
            isCompleteString(testingString);
        }
    }

    private static void isCompleteString(String testingString) {
        String resultString= "";
        char[] toChar = testingString.toCharArray();
        int length = toChar.length;
        for (int i = 0; i &lt; length; i++) {
            if(resultString.indexOf(toChar[i])==-1){
                resultString=resultString.concat(toChar[i]+"");

            }


        }

        if(resultString.length()==26)System.out.println("YES");
        else System.out.println("NO");
    }

}


This took 1.6469 secs against various inputs, while this code took:

class TestClass {
    private static byte N;
    public static void main(String args[] ) throws Exception {
        BufferedReader keyboard = new BufferedReader(new InputStreamReader(
                System.in));
       N = Byte.parseByte(keyboard.readLine());
        for (byte i = 0; i &lt; N; i++) {
            String testingString = keyboard.readLine();
            isCompleteString(testingString);
        }
    }

    private static void isCompleteString(String testingString) {

        char[] toChar = testingString.toCharArray();
        int length = toChar.length;
        boolean[] findingAlphabet = new boolean[26];
        for (int i = 0; i &lt; length; i++) {
            byte alphabets = (byte) toChar[i];
            findingAlphabet[122-alphabets]=true;

        }
        int count=0;
        for(boolean b:findingAlphabet){
            if(b)
            count++;
        }
        if(count==26)System.out.println("YES");
        else System.out.println("NO");
    }

}


1.5818 secs against various inputs.

How can I optimize these programs further (I have used BitSet)? What are other possible optimized methods of doing the same?
private static byte N;

We know that N&lt;=100, but this is a very premature optimization. In theory, you're saving 3 bytes total. Actually, it'll get rounded up to a nearest multiple of 8 or whatever and you save nothing at all.
It's also no good idea top make everything static.
BufferedReader keyboard = new BufferedReader(new InputStreamReader(
            System.in));

But the input does not come from the keyboard. Or can you type 100 lines in two seconds? I'd call it in as I'm lazy, something like reader would be fine.
isCompleteString(testingString);

According to the name, isCompleteString returns boolean. And there should be a method doing just this. Coupling output with computation makes you method 100% non-reusable.
First version
    String resultString= &quot;&quot;;

Switch on your warning to see unused variables.
    char[] toChar = testingString.toCharArray();
    int length = toChar.length;
    for (int i = 0; i &lt; length; i++) {

This looks like a premature optimization. And toChar is a bad name as there's no char but char[]. The IDE proposes charArrays or chars, which is both better.
If you want to use a char[], then use simply
   for (char c : chars)

This is clearly non-optimal
        if(resultString.indexOf(toChar[i])==-1){
            resultString=resultString.concat(toChar[i]+&quot;&quot;);
        }

for many reasons

indexOf - you're running through the string for each char
toChar[i]+&quot;&quot; creates a String from each char needlessly
resultString.concat(...) creates a new String every time

You could use a StringBuilder here.
But creating a String only to measure it's length is plain wrong. You could count the chars instead.
But counting the chars is plain wrong too. If you want to know if a beer crate is full, do you count the bottles? Or do you if there's a bottle missing?

    if(resultString.length()==26)System.out.println(&quot;YES&quot;);
    else System.out.println(&quot;NO&quot;);

This should be written as
   System.out.println(resultString.length()==26 ? &quot;YES&quot; : &quot;NO&quot;);

apart from that 1. there should be no resultString, 2. there should be a method computing and a method printing.
Second version
    boolean[] findingAlphabet = new boolean[26];

No good name. What about foundChars or simply found?
        byte alphabets = (byte) toChar[i];

What byte? Never use a byte, unless either it's exactly what's needed or you have a big bunch of them.
        findingAlphabet[122-alphabets]=true;

Nice obfuscation. What about
       found[chars[i] - 'a'] = true;

? And bottle counting again
    int count=0;
    for(boolean b:findingAlphabet){
        if(b)
        count++;
    }

This should be
    for (boolean b : found) {
        if (!b) {
            return false;
        }
    }
    return true;


How can I optimaize these programs further (I have used BitSet)?

You haven't. But BitSet is slower than a boolean[] (except when memory locality comes in play).
It looks like most of the time gets spend on IO. Not surprising, even the first solution with doing 26 times indexOf on a 100 chars string is not computationally intensive.
It could be sped up by avoiding strings and working with the input bytes directly. But I'd concentrate on readability first, otherwise it'll become a huge mess.
You may want to specify input encoding as US-ASCII as it's sufficient and much faster than UTF-8 which may be your platform default.