Shelling out for file lists is pretty inelegant. Built-in glob can handle that,

my @ll = map {
    (glob "$path/$_")[0]
} qw/*B1006* *B1106-* *B11062*/;
[download]

You can dispense with the index $next by pushing elements onto the arrays. Your regex can be dressed up a little with quantifiers and built-in character classes.

my (@stamp, @name);

foreach (@ll) {
    if (m#([A-Z][a-z]{2}\s\d{2}\s\d{2}:\d{2})\s(/.+\.+Z)$#) {
        push @stamp, $1;
        push @name,  $2;
    }
}
[download]

I left off printing until they can happen in one discrete block.

for (0..#$stamp) {
    printf "\$name[$_]:\t%s\n\$stamp[$_]:\t%s\n\n",
        $name[$_], $stamp[$_];
}
[download]

Update: Woops, japhy++ spotted a feature I completely overlooked. That simplifies everything, and makes the regex completely unnecessary. With the above @ll is @name. New version, minus printing:

my @name = map {
    (glob "$path/$_")[0]
} qw/*B1006*.Z *B1106-*.Z *B11062*.Z/;

my @stamp = map { scalar localtime( (stat)[9]) } @name;
[download]

There area number of things I'd alter here. For a start using \d rather than the more cumbersome character class [0-9] helps as does using the quantifier {2} in the regex. Personally I prefer to reserve # for comments where possible so I'd choose something else for the regex delimiters.

Rather than using two arrays which you have to keep in sync, I'd use one array of hashes. That avoids having to use indexes everywhere to access the arrays.

Assigning the capture list directly to variables is often cleaner than using the special capture variables (my ($stamp, $name) = m<...>;), although in this case just using the capture variables directly is clean.

use strict;
use warnings;

my @ll = <DATA>;
my @items;

chomp @ll;

foreach (@ll) {
    next if ! m<([A-Z][a-z]{2}\s\d{2}\s\d{2}:\d{2})\s(/.+\.Z)>;
    push @items, {stamp => $1, name => $2};
}

print "$_->{name}: $_->{stamp}\n" for @items;

__DATA__
Jun 05 20:08 /<path>/B1006-cnvexp.20060605.200841.Z
Jun 05 20:09 /<path>/B1106-cnvexp.20060605.2008.Z
Jun 05 20:09 /<path>/B11062-cnvexp.20060605.2008.Z
[download]

Prints:

/<path>/B1006-cnvexp.20060605.200841.Z: Jun 05 20:08
/<path>/B1106-cnvexp.20060605.2008.Z: Jun 05 20:09
/<path>/B11062-cnvexp.20060605.2008.Z: Jun 05 20:09
[download]

my @months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
my @dates;
for my $f (@files) {
  my $mod_time = (stat $f)[9];
  my ($min, $hour, $day, $mon) = (localtime $mod_time)[1..4];
  print "$f modified on $months[$mon] $day, $hour:$min\n";
  # or if you want zero-padding...
  printf "%s modified on %3s %02d, %02d:%02d\n", $f, $months[$mon], $d
+ay, $hour, $min;
}
[download]

Hi hasimir44, Try this,

use strict;
use warnings;

my $next = 0;
my (@stamp, @name);

while (<DATA>){
    chomp;
    ($stamp[$next], $name[$next]) = $_ =~ m/([a-z]{3}(?:\s[0-9]{2}){2}
+:[0-9]{2})\s(\/.+\.Z)/i;
    print "\$name[\$next]: $name[$next]\n";
    print "\$stamp[\$next]: $stamp[$next]\n";
    $next++;
}

__DATA__
Jun 05 20:08 /test/B1006-cnvexp.20060605.200841.Z
Jun 05 20:09 /test/B1106-cnvexp.20060605.2008.Z
Jun 05 20:09 /test/B11062-cnvexp.20060605.2008.Z

Output is:

$name[$next]: /test/B1006-cnvexp.20060605.200841.Z
$stamp[$next]: Jun 05 20:08
$name[$next]: /test/B1106-cnvexp.20060605.2008.Z
$stamp[$next]: Jun 05 20:09
$name[$next]: /test/B11062-cnvexp.20060605.2008.Z
$stamp[$next]: Jun 05 20:09
[download]

   m<
      (                 # Start of capture #1
         [A-Z][a-z]{2}  # Month name
         \s
         \d{2}          # Day
         \s
         \d{2}:\d{2}    # Hour:Minutes
      )                 # End of capture #1
      \s
      (/.+\.Z)          # Capture #2: File name
    >x;                 # End of regex, note 'x' modifier
[download]