Item pickup manager - help needed

Hi fellas!

I'm working on a plugin that makes sure that only the original item-owner and the killer can pick up the item drops on death. And I'm nearly done!
There's just one problem though. If a player holds more than one similars itemstack in their inventory, only one of the 2 stacks get saved. Everthing else works! It hurts so bad not to be able to solve the problem...
Here's the source btw:

Show Spoiler Hide Spoiler

Code:java

package me.punch;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import org.bukkit.inventory.ItemStack;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.plugin.java.JavaPlugin;
 
public final class Main extends JavaPlugin implements Listener {
 
    @Override
    public void onEnable() {
        this.getServer().getPluginManager().registerEvents(this, this);
    }
 
    boolean enabled = true;
    HashMap<Player, ItemStack[]> itemOwners = new HashMap<Player, ItemStack[]>();
    HashMap<ItemStack, Player> itemOwners2 = new HashMap<ItemStack, Player>();
    HashMap<ItemStack, Player> itemOwners3 = new HashMap<ItemStack, Player>();
    HashMap<String, Player> killers = new HashMap<String, Player>();
    ArrayList<ItemStack> itemz = new ArrayList<ItemStack>();
    ArrayList<ItemStack> nonPrivateItems = new ArrayList<ItemStack>();
    ArrayList<Player> disabled = new ArrayList<Player>();
 
    public boolean onCommand(CommandSender sender, Command command,
            String label, String[] args) {
        if (sender instanceof Player) {
            Player player = (Player) sender;
            if (label.equalsIgnoreCase("toggleloot")) {
                if (enabled) {
                    player.sendMessage("You have disabled the AutoLoot plugin.");
                    player.sendMessage("Repeat this command to re-enable");
                    enabled = false;
                } else if (!enabled) {
                    player.sendMessage("You have enabled the AutoLoot plugin.");
                    player.sendMessage("Repeat this command to disable");
                    enabled = true;
                }
            } else if (label.equalsIgnoreCase("ignoreloot")) {
                if (!enabled) {
                    player.sendMessage("The AutoLoot plugin is currently disabled.");
                    player.sendMessage("Perform /toggleloot to enable the plugin.");
                } else if (enabled && player.hasPermission("ignoreloot")
                        && !disabled.contains(player)) {
                    disabled.add(player);
                    player.sendMessage("You can now bypass the antiloot functions.");
                    player.sendMessage("Perform /ignoreloot again to enable the functions.");
                } else if (enabled && player.hasPermission("ignoreloot")
                        && disabled.contains(player)) {
                    disabled.remove(player);
                    player.sendMessage("You have enabled the antiloot functions.");
                }
            }
        }
        return false;
    }
 
    @EventHandler
    void Death(final PlayerDeathEvent event) {
        if (enabled) {
            Player player = event.getEntity();
            Player killer = event.getEntity().getKiller();
            ItemStack[] items = event.getDrops().toArray(new ItemStack[0]);
            itemOwners.put(player, items);
            for (ItemStack allItems : event.getDrops()) {
                itemOwners2.put(allItems, player);
                itemOwners3.put(allItems, killer);
                itemz.add(allItems);
            }
 
            new Thread() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(60000);
                        itemz.removeAll(event.getDrops());
                    } catch (InterruptedException ex) {
                    }
                }
            }.start();
            if (killer != null | killer instanceof Player) {
                killers.put(killer.getName(), player);
            }
        }
    }
 
    @EventHandler
    public void dropItem(PlayerDropItemEvent event) {
        nonPrivateItems.add(event.getItemDrop().getItemStack());
    }
 
    @EventHandler
    public void pickupItem(PlayerPickupItemEvent event) {
        ItemStack item = event.getItem().getItemStack();
        if (enabled && !nonPrivateItems.contains(item)) {
            event.setCancelled(true);
            Player p0 = event.getPlayer();
            ItemStack[] items0 = (ItemStack[]) itemOwners.get(p0);
            ItemStack[] items1 = (ItemStack[]) itemOwners.get(killers.get(p0
                    .getName()));
            if (disabled.contains(p0)) {
                event.setCancelled(false);
            }
            if (items0 != null) {
                for (ItemStack it : items0) {
                    if (event.getItem().getItemStack().isSimilar(it)) {
                        if (itemOwners2.containsKey(it)) {
                            if (itemOwners2.get(it).equals(p0)) {
                                event.setCancelled(false);
                                itemOwners2.remove(it);
                                if (itemOwners3.containsKey(it)) {
                                    itemOwners3.remove(it);
                                }
                            }
                        }
                    }
                }
            }
 
            if (items1 != null) {
                for (ItemStack it : items1) {
                    if (event.getItem().getItemStack().isSimilar(it)) {
                        if (itemOwners3.containsKey(it)) {
                            if (itemOwners3.get(it).equals(p0)) {
                                event.setCancelled(false);
                                itemOwners3.remove(it);
                                if (itemOwners2.containsKey(it)) {
                                    itemOwners2.remove(it);
                                }
                            }
                        }
                    }
                }
            }
            if (!itemz.contains(event.getItem().getItemStack())) {
                event.setCancelled(false);
            }
        }
    }
 
    public static <T> T[] addToArray(T[] array, T obj) {
        ArrayList<T> arrayList = new ArrayList<T>(Arrays.asList(array));
        arrayList.add(obj);
        return arrayList.toArray(array);
    }
 
    public static <T> T[] concatArray(T[] first, T[] second) {
        T[] result = Arrays.copyOf(first, first.length + second.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }
 
}
 

It's gonna be a bit confusing to read through this. I just can't simply explain how it works. If you really want to help, please figure out how the plugin works at the moment and then see if you can come up with a sulution.

Thank you!