Inspired by some of the other replies to the OP (especially samtregar's reply mentioning Devel::Size) here is a comparison of some of the techniques suggested:

use warnings;
use strict;
use Devel::Size qw(total_size);

use warnings;
use strict;

my @large_list = (
    {key => 1, cond => 1},
    {key => 2, cond => 0},
    {key => 3, cond => 0},
    {key => 3, cond => 0},
    {key => 1, cond => 0},
    );

my $recordU = bless {};
my $recordA = bless {};
my $recordI = bless {};
my %record;

print "Empty sizes:\n";
print 'Packed: ', total_size ($recordU), "\n";
print 'Array:  ', total_size ($recordA), "\n";
print 'int:    ', total_size ($recordI), "\n";
print 'Hash:   ', total_size (\%record), "\n";

for my $item (@large_list) {
    $recordU->addU ($item);
    $recordA->addA ($item);
    $recordI->addI ($item);
    $record{$item->{key}}{count}++;
    $record{$item->{key}}{flag} ||= $item->{cond};
}

print "\nPopulated sizes:\n";
print 'Packed: ', total_size ($recordU), "\n";
print 'Array:  ', total_size ($recordA), "\n";
print 'int:    ', total_size ($recordI), "\n";
print 'Hash:   ', total_size (\%record), "\n";

for (sort keys %$recordU) {
    print "Item $_ count ", $recordU->getCountU ($_), ', flag ', $reco
+rdU->getFlagU ($_), "\n";
    print "Item $_ count ", $recordA->getCountA ($_), ', flag ', $reco
+rdA->getFlagA ($_), "\n";
    print "Item $_ count ", $recordI->getCountI ($_), ', flag ', $reco
+rdI->getFlagI ($_), "\n";
    print "Item $_ count ", $record{$_}{count}, ', flag ', $record{$_}
+{flag}, "\n";
}
[download]

sub addU {
    my ($self, $item) = @_;
    my $key = $item->{key};

    if (! exists $self->{$key}) {
        $self->{$key} = pack ('NN', 1, $item->{cond});
    } else {
        my ($count, $flag) = unpack ('NN', $self->{$key});
        $self->{$key} = pack ('NN', $count + 1, $flag || $item->{cond}
+);
    }
}


sub getFlagU {
    return (unpack ('NN', $_[0]->{$_[1]}))[1];
}


sub getCountU {
    return (unpack ('NN', $_[0]->{$_[1]}))[0];
}


sub addA {
    my ($self, $item) = @_;
    my $key = $item->{key};

    if (! exists $self->{$key}) {
        $self->{$key} = [1, $item->{cond}]
    } else {
        $self->{$key}[0]++;
        $self->{$key}[1] ||= $item->{cond};
    }
}


sub getFlagA {
    return $_[0]->{$_[1]}[1];
}


sub getCountA {
    return $_[0]->{$_[1]}[0];
}


sub addI {
    my ($self, $item) = @_;
    my $key = $item->{key};

    if (! exists $self->{$key}) {
        $self->{$key} = 2 | !!$item->{cond};
    } else {
        $self->{$key} += 2;
        $self->{$key} |= !!$item->{cond};
    }
}


sub getFlagI {
    return int ($_[0]->{$_[1]} & 1);
}


sub getCountI {
    return int ($_[0]->{$_[1]} / 2);
}
[download]

Prints:

Empty sizes:
Packed: 92
Array:  92
int:    92
Hash:   92

Populated sizes:
Packed: 260
Array:  497
int:    209
Hash:   682
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 1 count 2, flag 1
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 2 count 1, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0
Item 3 count 2, flag 0
[download]