Here's a snippet that I think does what you mean?

# assuming that...
my $string = "Perl Monks";
my $n = length($string);
my $i = 1;
my $result = 0;

# here it is.

$result += ord($_) * 31^($n-$i++) for split '', $string;
        ^   ^   ^         ^  ^ ^             ^    ^
        |   |   |         |  | |             |    +-- String to split
        |   |   |         |  | |             +-- split all the charact
+ers
        |   |   |         |  | +-- post increment $i
        |   |   |         |  +-- $i is the index
        |   |   |         +--- $n is the length of $string
        |   |   +--- this is the character returned from split   
        |   +--- ord() returns the ascii code of the character
        +--- add what we have to $result
[download]

When you say "using int arithmetic"; signed or unsigned? 32-bit?

Could you supply the hash value generated for "The quick brown fox jumps over the lazy dog" so that we may have something to check our attempts against.

This might be close, and reasonable efficient as it avoids the exponentiation by processing the string backwards and accumulating the exponent, and uses integer math. However truncating to 32-bits in reverse order maybe screwing up the result?

#! perl -slw
use strict;
# s[0]*31^(n-1)+s[1]*31^(n-2)+ ... +s[n-1]

sub JavaHash {
    use integer;

    my ($s) = @_;
    my $n = length $s;
    my @s = unpack 'C*', $s;
    my $hash = 0;
    my $p = 1;

    for ( reverse @s ) {
        print "$hash : $_: $p";
        $hash += $_ * $p;
        $p *= 31;
    }
    return $hash;
}

die 'No arguments' unless @ARGV;

printf '%10d:%s' , JavaHash( $_ ), $_ for @ARGV;
[download]

What exactly is your problem? you happen to have the algorithm, all you have to do is write it down in perl ;) Here is a rather clumsy solution, since you don't provide a test-sample, I don't know if the results are correct:

use strict;
use warnings;
my @strings = ('abzdefghijk',
'a b z d e f g h i j k',
'',
'abzde          fghijk',);

print $_, " => ", hc($_), "\n" for @strings;

sub hc {
    my $string = shift;
    my $erg = 0;
    my $max = int(length($string) - 1);
    # this line is your algorithm!
    $erg += (ord(substr($string,$_,1)))*31**($max-$_) for 0..$max;
    $erg;
}
[download]

regards,
tomte

Hlade's Law:

If you have a difficult task, give it to a lazy person --
they will find an easier way to do it.

sub hashing {
    my $s = shift;
    my $acc = 0;
    foreach my $c (unpack 'C*', $s) {
        $acc *= 31;
        $acc += $c;
    }
    return $acc;
}
[download]

sub hashing {
    my $s = shift;
    my $acc = 0;
    foreach my $c (unpack 'C*', $s) {
        $acc *= 31;
        $acc += $c;
        $acc %= 0x100000000;
    }
    return $acc;
}
[download]

thor

Two things:
1. You don't have to wonder, you can read it for yourself.
2. Seondly, and more importantly, the way the hashCode() method works in java allows for objects of any type to serve as hash keys. The original poster asked a question about the implementation of that method for Strings. (also: Perl allows for arbitrarily long hash keys, too, since any strings are hash keys, and strings are arbitrarily long)
3. Three things: there is no third thing.

To address your items, point by point:
1. I could have, but I'm lazy. And laziness is a virtue.
2. I understand what purpose hashCode() has. However, in perl, hash codes are not of arbitrary length. There is an algorithm described here that describes an algorithm that takes an arbitrary input and produces a 32-bit hash code. A bit slower, I suppose, but keeps you from having to keep track of an arbitrarily large integer for your hash key. So, it's not necessarily the case that one use arbitrarily large hash codes (which is different from arbitrarily large hash keys)
3. Good, because I don't either...:).

thor