use strict;
use warnings;
my @arr = ([
    {key=>12, pl=>1, lop=>9},
    {key=>12, pl=>1, lo =>9},
]);

foreach my $subArr_ref (@arr) {
    foreach my $hash_ref (@$subArr_ref) {
        while (my ($key, $value) = each %$hash_ref) {
            print "$key: $value\n";
        }
    }
}
OUTPUT:
pl: 1
lop: 9
key: 12
lo: 0
key: 12
pl: 1
[download]

You may find changing $j to $hr so you know it's a hashref makes things a bit clearer.

#!perl
use strict; 
use Data::Dumper;

my %hash = ( key => 12, pl  => 1, lop => 9 );
my %hash2 = ( key => 12, pl  => 1, lo => 9 );

my @arr = ( [\%hash,\%hash2] );

for my $i (0 .. $#arr){
    my $subd = @{$arr[$i]};
    print "subLen: $subd\n";
    for my $hr (@{$arr[$i]}){
      for my $key (keys %$hr){
        print $key.": ".$hr->{$key}."\n";
      }
    }
}
[download]

Obligatory link: Perl Data Structures Cookbook (perldsc).

loop through the outter loop and reference the hash with : <%-{-{-{-<

Here are a couple of examples using while and each to loop through the data structure (requires Perl minimum version 5.12), and using map to transform the array into a list of the key values.

(I used your data-building technique for consistency.)

use strict; use warnings; use feature 'say';
use Data::Dumper;

my @arr = get_data();

say "Data:";
while ( my ($n, $aref) = each @arr ) {
    say "  Aref: " . ($n + 1);
    while ( my ( $n, $href ) = each @{ $aref } ) {
        say "    Href: " . ($n + 1);
        while ( my ( $key, $val ) = each %{ $href } ) {
            say "      $key: $val";
        }
    }
}

say '~~~~~~~~~~~~~~';

my @vals = map { $_->{'myKey'} } map { @{ $_ } } @arr;

say "Inner values:";
say Dumper \@vals;

sub get_data {
    my @arr;
    my @subArr1;
    my @subArr2;
    my %hash1 = ( myKey => 1 );
    my %hash2 = ( myKey => 2 );
    my %hash3 = ( myKey => 3 );
    my %hash4 = ( myKey => 4 );
    push(@subArr1, \%hash1, \%hash2);
    push(@subArr2, \%hash3, \%hash4);
    push(@arr, \@subArr1, \@subArr2);

    return @arr;
}
[download]

$ perl 1182753.pl
Data:
  Aref: 1
    Href: 1
      myKey: 1
    Href: 2
      myKey: 2
  Aref: 2
    Href: 1
      myKey: 3
    Href: 2
      myKey: 4
~~~~~~~~~~~~~~
Inner values:
$VAR1 = [
          1,
          2,
          3,
          4
        ];
[download]

Hope this helps!

I changed the terminology a bit below. I called @subArr, @href_array, array of hash references.

#!/usr/bin/perl
use strict;
use warnings;

my @href_array;  #array of ref's to hash
my @arr;         #an array of ref's to @href_array arrays

my %hash  = ();
my %hash2 = ();
my %hash4 = ();
my %hash8 = ();


$hash{key} = 12;
$hash{pl}  = 1;
$hash{lop} = 9;

$hash2{key} = 88; #changed this to be different
                  #than $hash{key} = 12

$hash4{pl}  = 1;

$hash8{lo}  = 9;

push(@href_array, \%hash);  #array of ref's to hash
push(@href_array, \%hash2); #array of ref's to hash
push(@href_array, \%hash4); #array of ref's to hash
push(@href_array, \%hash8); #array of ref's to hash


dump_hashref_array (@href_array);


sub dump_hashref_array  # dump_hashes(\%h1,\%h2,...,\%hn)
{
   my @hrefs = @_;
   
   my $n_table =1;
   foreach my $href (@hrefs)
   {
      print "dumping hash table ", $n_table++,"\n";
      
      foreach my $key (keys %$href)
      {
         print "$key=>$href->{$key}\n";
      }
      print "\n"; #just a spacer line between hashes
   }
}

__END__
PRINTS:
dumping hash table 1
key=>12
pl=>1
lop=>9

dumping hash table 2
key=>88

dumping hash table 3
pl=>1

dumping hash table 4
lo=>9
[download]

A bit off topic, but I see you are flummoxed by this "1/8" sometimes result? This is kind of a weird thing, but here is how it could happen. A reference to hash could also result from different code. Anyway this is how you could get the string "1/8":

#!/usr/bin/perl
use strict;
use warnings;

my %hash;
$hash{anything} =1;

my $hash_result = %hash;

print "scalar value of a this hash = $hash_result\n";

__END__
PRINTS:
scalar value of a this hash = 1/8

# scalar values of a hash is a string, like "1/8"

# Means that 1 of 8 hash buckets is currently in use.
# A Perl hash always starts with 8 hash buckets.
#
# Perl will double the number of hash buckets as it
# sees fit. You have no control over that decision.
#
# Current versions of Perl have some randomization of
# the keys -- a run with the exact same data may
# result in a difference in # of keys used or total keys.

# Of course the code above will always result in "1/8".
[download]

your @arr array has never been populated with anything. So:

for my $i (0 .. $#arr){
[download]

use strict;
use warnings;
[download]

your @arr array has never been populated with anything

It is for me. When I run the 1st code snippet (no strictures), I see something in @arr:

use Data::Dumper; print Dumper(\@arr);
$VAR1 = [
          [
            {
              'key' => 12,
              'lop' => 9,
              'pl' => 1
            },
            {
              'key' => 12
            }
          ]
        ];
[download]

What happens when you run it? The 2nd snippet has compile errors for me.