Java String Array

I have a piece of elegant code for this, but first I need to know if the scores increment according to the alphabet. In other words, every letter is 1 less/more than the next/previous letter, or are the scores random?
-nat

Don't like == with Strings (even if it works ;-)) This approach can be used:

public static int turnAnswerToScore(String[] myGrades) {
    int score = 0;
    final int REF = 'A' + 3;
    for (int i = 0;i < myGrades.length;i++) {
      score += REF - Character.toUpperCase(myGrades[i].charAt(0));
    }
    return score;
  }

   public int turnAnswersToScore(String[] myGrades)
     {
         int score = 0;

         for (int i = 0; i < myGrades.length; i++)
         {
             switch (myGrades[i].charAt(0))
             {
               case 'A':
                 score += 3;
                 break;
               case 'B':
                 score += 2;
                 break;
               case 'C':
                 score += 1;
                 break;
             }
         }
         
         return score;
     }

for the performance, it's better to change this:
for (int i = 0; i < myGrades.length; i++)

into:
int grades = myGrades.Length;
for (int i = 0; i < grades; i++)

try to avoid to terminate loops with method calls. it's more performant to use the integer variable "grades". first of all because operations on primitive datatypes (and especially the integer) are the fastest and because the int variable is directly accessible from the heap.

i know for this little piece of code, it won't have a big influence, but when you fine tune every loop in your program, you'll see some improvements

grtz

Lee

Thank you all!  my problem is solved less than a day!  Thank you all of you, and sorry becos I can not accept all of your answer, eventhough your code are all excellent!

Thank you for the points, but I must point out that CEHJ is right.  You should not use == to test the strings, you should use .equals().

Some of the answers given are just plain wrong or misleading...and why would you add them up without dividing by the count?

For example...
   "for the performance, it's better to change this:
   for (int i = 0; i < myGrades.length; i++)
   into:
   int grades = myGrades.Length;
   for (int i = 0; i < grades; i++)
   try to avoid to terminate loops with METHOD CALLS. ..."

but myGrades.length is not a method call.  Methods have () after them.

And, no, using "==" does NOT work in this case unless you convert to char first.  Beyond that...perhaps some modularity is better...USE SUBROUTINES!  Even this solution is short-sighted, considering many schools use "A+", "A-" etc.

class SOMECLASS
{
    public static double turnAnswersToScore(String[] myGrades)
    {
         int score = 0;

         for (int i = 0; i < myGrades.length; i++)
          score += GradeToScore(myGrades[i].charAt(0));
         return score/(double)myGrades.length;
    }

   public static int GradeToScore(char grade)
   {
        switch (grade)
             {
               case 'A':
                 return 4;
               case 'B':
                 return 3;
               case 'C':
                 return 2;
               case 'D':
                 return 1;
               default:
                 return 0;
             }
         }
     }

> switch (grade)

agreed :)

>>but myGrades.length is not a method call.  Methods have () after them.

While what you say is strictly true, the spirit of leeprovoost's comment is correct: it still causes a relatively expensive instruction to be called in a loop which can be avoided

i'd think the permance difference would be negligible (if any), and not that relevant for this example anyway.
Not saying there's anything wrong with leeprovoost's comment though, and it was clarified with the fact that it won't make much difference.

I'd actually argue that in this particular case (since it's not a method call) it'll be slower to assign mygrades.length outside the loop.

The program is probablying going to be run on an x86 so you're going to be short on registers and pushing the values onto the stack. No if you assign it early rather than 'ad-hoc' you're going to be popping a lot more data off to get to the value you need.

Just ran a quick test with the two versions:

import java.util.*;

public class LoopTest1{

public static void main(String[] args){
  Date start, end;
  start = new Date();
 
  Double[] theArray = new Double[20];
  int result = 0;
 
  for (int j=0;j<90000000;j++)
  {
    for (int i =0; i < theArray.length;i++)
      result = result + i;
  }
  end = new Date();
  System.out.println("Top of stack version(inside loop) took : "+ ( end.getTime() - start.getTime() ) );
       
}
}

AND THE OTHER VERSION:

import java.util.*;

public class LoopTest2{

public static void main(String[] args){
  Date start, end;
  start = new Date();
 
  Double[] theArray = new Double[20];
  int result = 0;
 
  int arrayLength =  theArray.length;
  for (int j=0;j<90000000;j++)
  {
    for (int i =0; i < arrayLength;i++)
      result = result + i;
  }
  end = new Date();
  System.out.println("Bottom of stack version (outside loop) took : "+ ( end.getTime() - start.getTime() ) );
       
}
}

Times:
C:\myjava>java LoopTest1
Top of stack version(inside loop) took : 6438

C:\myjava>java LoopTest1
Top of stack version(inside loop) took : 6500

C:\myjava>java LoopTest1
Top of stack version(inside loop) took : 6485

C:\myjava>java LoopTest1
Top of stack version(inside loop) took : 6516

C:\myjava>java LoopTest2
Bottom of stack version (outside loop) took : 7484

C:\myjava>java LoopTest2
Bottom of stack version (outside loop) took : 7485

C:\myjava>java LoopTest2
Bottom of stack version (outside loop) took : 7515

C:\myjava>java LoopTest2
Bottom of stack version (outside loop) took : 7578


This seems to confirm it since the loop is inside a method all the variables are local and use the stack.  I'm pretty sure this is right.

That's very interesting....I didn't expect that result.

For timings, though, I would not use Date but System.getCurrentTimeMilli() -- that's not exactly the right method name, but it's something like that.

and to be a fare comparison with the code, the order should be different...but it should make your comparison eve more correct:

  for (int j=0;j<90000000;j++)
  {
    int arrayLength =  theArray.length;
    for (int i =0; i < arrayLength;i++)
      result = result + i;
  }

I have to say, though, this seems like a lot quibbling over a minor item...I see this a lot in software development...people start arguing over some minor point while the major issues go left unresolved or even unrecognized.  

And this seems to be an issue of 1 X 10 ** -5 ms

Of course, in "real time" software, these issues are potentially important if that item is hit millions of times...I should know, I do real-time java...sometimes you just have to try various ways and find ways to time them....(but not with Date)

Gee, all this to help a guy doing his home work?  come on guys

hey...but thanks to these guys for helping me, I actually understood it!!! who knows I might have given up on java if not because of these guys.  BTW, the first code is very plain simple, which for the beginner it is very helpful.  At the same time, i think the code from other guys are very good as well! thanks again,

long thread ..

this just caught my eye ;

----
 for the performance, it's better to change this:
for (int i = 0; i < myGrades.length; i++)

into:
int grades = myGrades.Length;
for (int i = 0; i < grades; i++)
----

- you gotta be kidding, right ? (not intended in the offensive style) ... if my JVM/javac cant optimize *that* .. what the hell *can* it ?
Ill have to test that out....

I agree as well.  This is how I have always done it and I have NEVER seen a performance hit.  PhD's use method calls within interation.  

I just don't see how adding in local instance data can help on an O^n operation.  It's still O^n.

CyTG:long thread ..

this just caught my eye ;

----
 for the performance, it's better to change this:
for (int i = 0; i < myGrades.length; i++)

into:
int grades = myGrades.Length;
for (int i = 0; i < grades; i++)
----

- you gotta be kidding, right ? (not intended in the offensive style) ... if my JVM/javac cant optimize *that* .. what the hell *can* it ?
Ill have to test that out....

yeah, it doesn't help performance and it makes the code harder to read.  why using

(for ... i++) any more anyway?

use "for each"

and why not subroutines/

public int turnAnswersToScore(String[] myGrades)
     {
         int score = 0;
         for (for String g : myGrades)
         {
             score += scoreFor(g);
         }
         
         return score;
     }

 int scoreFor(String g)
 {
             switch (g.charAt(0))
             {
               case 'A':
                 return 3;
               case 'B':
                 return 2;
               case 'C':
                 return 1;
               default: return 0;
             }