My perl program frequently needs to retrieve a cached set of data that is indexed by a positive but sparsely populated set of integers.

By the way it's Perl. Lower case perl is the command. Oh... never mind.

Based on what you said I'd go with a hash. If you really want to implement a sparse array you could to this:

package IndexedSparseArry;

sub new {
     shift;
     my $self={ array => [ ] };
     bless $self,"IndexedSparseArray";
}

sub insert {
      my ($self,$index,$data)=@_;
      my @work = @{$self->{array}};

      if ( $#work == -1 ) {  # Nothing there yet.
          push @work,{index => $index, data => $data};
      } else { 
          my $i=0;   # not to be confused with index.
          while ( ($i < $#work) && ($work[$i]->{index} < $index)){
              $i++
          }
          if ( $i == $#work ) {
               if ($work[$1] < $index ) {
                    push @work,{index => index, data => $data);
               } else {
                   $work[$i+1]=$work[$i];
                   $work[$i] = { index => $index, data=>$data};
               }
        } else { 
              my $j = $#work + 1;
              while ($j > $i){
                 $work[$j] = $work[$j-1];
                 $j--;
        }
        $work[$i] =  { index => $index, data => $data };
        $self->{array} = [@work];
}
1;
[download]

use strict;
use warnings;
use IndexedSparseArray;

my $repo = IndexedSparseArray->new();

while (<i am reading in data >){
       | handwaving
       $repo->insert($index,$data);
}
| etc.
[download]

I think I've given you something to chew on, hope it helps.