deleting duplicates from array list

I recommend you use a class that extends java.util.Set:

• If order is not important for you, you can use HashSet;
• If order of insertion is important, you can use LinkedHashSet;
• If natural order is important (alphabetical by name or other property), you can use TreeSet and implement the interface Comparable onto the class inserted in the collection.

However, regardless of your choice, it's recommended you implement hashCode() (for optimization) and equals() (to let collection identify which item is equal to other and avoid duplication).

If you can use third party libraries, I'd recommend using a Bag from Eclipse Collections.

With your Item class implementing equals and hashCode on ItemName field, your example usage could look like:

final MutableBag<Item> backPack = new HashBag<>();

final Item rustySword = new Item("Rusty sword", "Just a rusty sword", 3, 2);
final Item leatherArmour = new Item("Leather Armor", "Old leather armor", 6, 3);
     
backPack.add(rustySword);
backPack.add(leatherArmour);
backPack.add(rustySword);

System.out.println(backPack.toMapOfItemToCount());     // prints {Item[ItemName='Rusty sword']=2, Item[ItemName='Leather Armor']=1}
System.out.println(backPack.occurrencesOf(rustySword));  // prints 2

The API is rich, and provides a lot more: https://www.eclipse.org/collections/javadoc/11.0.0/org/eclipse/collections/api/bag/Bag.html

I would use a Map.

Here's my suggestion:

 import java.util.*;

 class Player  {
    public Backpack backpack= new Backpack();
}

class Monster { }

 class Skieleton extends Monster {

  public Backpack backpack= new Backpack();

  public Skieleton() {
       
       backpack.add(new Weapon("Rusty sword", "Just a rusty sword", 3, 2 ));
       backpack.add(new Armor("Leather Armor", "Old leather armor", 6, 3));
    }
}

class Backpack {
    private HashMap<Item,Item> items = new HashMap<>();
    
    public Item add(Item item){
        if (items.containsKey(item)){
            items.get(item).Amount=+ item.Amount;
            return items.get(item);
        } else {
            items.put(item,item);
            return item;
        }
    }
    
    public Item get(Item item){
        return items.getOrDefault(item, null);
    }
}
class Item {

    public String ItemName;
    public String Description;
    public int ItemSize;
    public int ItemWeight;
    public int Amount;

    public Item(String ItemName, String Description, int ItemSize, int ItemWeight)
    {
        this.ItemName = ItemName;
        this.Description = Description;
        this.ItemSize = ItemSize;
        this.ItemWeight = ItemWeight;
    }

    public Item() {
    }
    
    public boolean equals(Object o){
        if (o instanceof Item){
            return ItemName.equals( ((Item)o).ItemName);
        }
        return false;
    }
}

You can use a HashMap for storing the items. First, I would like to change the Item class to not have amount field in it. Let an item denote what an item is (name, description, size and weight).

Here's the updated backpack:

Map<Item, Integer> backpack = new HashMap<>();

To add an item, you can use Map#merge method.

public void addItemToBackpack(Item item, int quantity) {
    backpack.merge(item, quantity, (oldQuantity, newQuantity) -> oldQuantity + newQuantity);
}

We insert the item and its quantity. If the item is not already present, it will be inserted with the passed quantity.

If it is already present, then the BiFunction which is a mapping function will be called with the existing value (oldQuantity) and the new value which we tried to insert (newQuantity). We sum them both, return it and the item's value (quantity) will be updated with this value.

Using method references, we can write the above as,

backpack.merge(item, quantity, Integer::sum);