It certainly is. For instance, the first element in your array is $array[0]; since this is a hash reference, you can deference it and turn it into a proper hash again by saying %{ $array[0] } (the whitespace isn't necessary; it just improves readability). And since that's just a hash, you can access its elements as usual, e.g. ${ $array[0] }{'somekey'}.

That last bit of syntax is clunky, of course, so Perl provides the -> postfix operator for dereferencing and element access as well; using that, you can also write $array[0]->{'somekey'}, which is much more readable and makes it more obvious what's going on.

Example:

#!/usr/bin/perl

use feature qw/say/;
use warnings;
use strict;

my @array = (
    {
        'Fred' => 'Flintstone',
        'Barney' => 'Rubble'
    }
);

say $array[0];
say %{ $array[0] };
say ${ $array[0] }{'Fred'};
say $array[0]->{'Fred'};

$array[0]->{'Betty'} = 'Rubble';

say $array[0]->{'Betty'};
[download]

Output:

$ perl test.pl
HASH(0x8002bc80)
BarneyRubbleFredFlintstone
Flintstone
Flintstone
Rubble
$
[download]

EDIT: removed superfluous use Data::Dumper; -- good catch, hexcoder. :)

That last bit of syntax is clunky ... the -> postfix operator for dereferencing and element access as well ...

And for even less clunky syntax, Perl understands that any array/hash/code/etc. reference below the topmost level can only be a reference, so it will use the  -> operator implicitly if you do not use it explicitly. It's only at the topmost level that you have to supply a  -> or not based on the nature of the variable you are accessing:  -> must be used with an array/hash/code reference: see Anonymonk's reply for an example of this.

c:\@Work\Perl>perl -wMstrict -le
"use feature qw/say/;
 use Data::Dump;
 ;;
 my @array = (
   { 'Fred'   => 'Flintstone',
     'Barney' => 'Rubble',
     }
   );
 ;;
 say $array[0]{'Fred'};
 ;;
 $array[0]{'Marge'} = 'Simpson';
 say $array[0]{'Marge'};
 ;;
 dd \@array;
"
Flintstone
Simpson
[
  { Barney => "Rubble", Fred => "Flintstone", Marge => "Simpson" },
]
[download]

See also perldsc (Perl Data Structures Cookbook).

Ah, I didn't know that! Thanks for the tip, my enlightened brother!

I would discourage not using the postfix dereferencing, it's the first clue that something is a reference! It matters because modifying references can have side effects on the thing that is referenced!

#!/usr/bin/perl --
use strict;
use warnings;
use Data::Dump qw/ dd /;
my %hash = ( 1,2 );
my $ref = \%hash;
dd( $ref );
$ref->{alec}='smart';
dd( $ref );
__END__
{ 1 => 2 }
{ 1 => 2, alec => "smart" }
[download]

It is reviewed and recommended by Perl Tutorial Hub

Thanks a lot for the reply. Is there a way to directly use, instead of using a package?

Data::Dump is only there for showing you the output. Access is done through plain Perl. See the links that Anonymous Monk already provided.

Yes, try Applefritters demo code. Just leave out the line use Data::Dumper; before trying. It is not necessary.

1. Perl refcard in PDF, in landscape, 3 columns per page.
2. perlcheat

my $array_ref = [
  { foo=> 1, herp => 'a'},
  { bar => 2, derp => 'b'},
  { baz => 3, burp => 'c'},
];

# to iterate
foreach my $h (@$array_ref) {
  foreach $k (keys %$h) {
    ++$h->{$k}; # note ++ "increments" strings as well
  }
}
[download]

my $array_ref = [
  { foo=> 1, herp => 'a'},
  { bar => 2, derp => 'b'},
  { baz => 3, burp => 'c'},
];

# unrolled iteration loop
++$array_ref->[0]->{foo}; # now 2
++$array_ref->[0]->{herp}; # now b
++$array_ref->[1]->{bar}; # now 3
++$array_ref->[1]->{derp}; # now c
++$array_ref->[2]->{baz}; # now 4
++$array_ref->[2]->{burp}; # now d
[download]

#!/usr/bin/perl -w

use strict;
use warnings;

use Data::Dumper;

my @foo = (
  { 'name' => 'rover' },
  { 'name' => 'felix' }
);

# Modify the first hashref in @foo

print Dumper (\@foo);
$foo[0]->{'food'} = 'Scooby Snacks';
print Dumper (\@foo);
[download]

And so you have added a key to one of the hash references in your array.