Why the second product quantity override the first product quantity in java?

I think your design is not the best. The below code demonstrates my design. It consists of several classes. Refer to the comments in the below code which explain the design.

An Order contains Items where an Item is a Product together with a quantity.

(Notes after the code.)

package ordering;

import java.math.BigDecimal;

public record Product(int id, String name, BigDecimal price) {

    public boolean equals(Object obj) {
        boolean equal = this == obj;
        if (!equal) {
            if (obj != null) {
                Class<?> thisClass = getClass();
                Class<?> objClass = obj.getClass();
                if (thisClass.equals(objClass)) {
                    Product other = (Product) obj;
                    equal = id == other.id();
                }
            }
        }
        return equal;
    }

    public int hashCode() {
        return id;
    }
}

package ordering;

import java.util.Objects;

/**
 * An item in an order. An item consists of a product and the number of units of that product.
 * 
 * @see ordering.Order
 */
public class Item {

    /** Number of units ordered. */
    private int  amount;

    /** Ordered product. */
    private Product  product;

    /**
     * Creates and returns an instance of this class.
     * 
     * @param prod - product being ordered (cannot be null).
     * @param amt  - number of units of ordered product (must be positive).
     */
    public Item(Product prod, int amt) {
        Objects.requireNonNull(prod, "Null product.");
        if (amt <= 0) {
            throw new IllegalArgumentException("Amount must be positive.");
        }
        product = prod;
        amount = amt;
    }

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public boolean equals(Object obj) {
        boolean equal = this == obj;
        if (!equal) {
            if (obj instanceof Item) {
                Item other = (Item) obj;
                equal = product.equals(other.product);
            }
        }
        return equal;
    }

    public int hashCode() {
        return product.hashCode();
    }

    public String toString() {
        return String.format("%3d\u00D7%s", amount, product);
    }

    /**
     * Adjusts current amount by adding <var>amount</var> to it. Note that <var>amount</var> may be
     * negative.
     * 
     * @param amount - will be added to this instance's current amount.
     * 
     * @throws UnsupportedOperationException  if updated amount is not positive.
     */
    public void updateAmount(int amount) {
        int newAmount = this.amount + amount;
        if (newAmount <= 0) {
            throw new UnsupportedOperationException("Updated amount is not positive.");
        }
        this.amount += amount;
    }
}

package ordering;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * An order consists of a list of items.
 * 
 * @see ordering.Item
 */
public class Order {
    private List<Item> items;

    /**
     * Creates and returns an instance of this class. Creates an order with zero items.
     */
    public Order() {
        items = new ArrayList<>();
    }

    public List<Item> getItems() {
        return new ArrayList<>(items);
    }

    /**
     * Removes <var>item</var> from the list of items in this order. Does nothing if this order
     * does not contain <var>item</var>. A particular {@code Product} appears once only in a single
     * order.
     * 
     * @param item - item to remove.
     */
    public void removeItem(Product item) {
        findItem(item).ifPresent(i -> items.remove(i));
    }

    /**
     * Updates the list of items in this order. If the order already contains <var>item</var> then
     * <var>amount</var> is added to the current amount. Note that <var>amount</var> may be
     * negative.
     * 
     * @param item   - item to update.
     * @param amount - quantity of items.
     * 
     * @throws UnsupportedOperationException  if product amount, after update, is not positive.
     */
    public void updateItem(Product item, int amount) {
        findItem(item).ifPresentOrElse(itm -> itm.updateAmount(amount),
                                       () -> items.add(new Item(item, amount)));
    }

    private Optional<Item> findItem(Product prod) {
        if (prod != null) {
            for (Item item : items) {
                if (prod.equals(item.getProduct())) {
                    return Optional.of(item);
                }
            }
        }
        return Optional.empty();
    }
}

This last class is the actual program.

package ordering;

import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Ordering {
    private static final char YES = 'Y';
    private static final Scanner STDIN = new Scanner(System.in);
    private static final String DELIMITER = "|";
    private static final String PRODUCTS = "product.txt";

    private static List<Item> stock;
    private static Order order;

    private static boolean checkStock(Product prod, int amount) {
        boolean enough = false;
        for (Item item : stock) {
            Product p = item.getProduct();
            if (p.equals(prod)) {
                int inStock = item.getAmount();
                int newAmount = inStock - amount;
                enough = newAmount >= 0;
                if (enough) {
                    item.setAmount(newAmount);
                }
                else {
                    System.out.printf("Less than %d %s in stock.%n", amount, p.name());
                }
            }
        }
        return enough;
    }

    private static int getAmount() {
        System.out.print("Enter quantity: ");
        return STDIN.nextInt();
    }

    private static Product getProduct() {
        System.out.print("Enter product ID: ");
        int id = STDIN.nextInt();
        Product prod = null;
        for (Item item : stock) {
            Product p = item.getProduct();
            if (p.id() == id) {
                prod = p;
                break;
            }
        }
        if (prod == null) {
            System.out.println("Unknown product.");
        }
        return prod;
    }

    private static void initializeStock() throws IOException {
        Path path = Paths.get(PRODUCTS);
        try (Stream<String> lines = Files.lines(path)) {
            stock = lines.map(Ordering::makeItem)
                         .filter(i -> i != null)
                         .collect(Collectors.toList());
        }
    }

    private static Item makeItem(String line) {
        Item item;
        String[] parts = line.split("\\" + DELIMITER);
        if (parts.length == 4) {
            int id = Integer.parseInt(parts[0]);
            BigDecimal price = new BigDecimal(parts[2]);
            Product prod = new Product(id, parts[1], price);
            item = new Item(prod, Integer.parseInt(parts[3]));
        }
        else {
            item = null;
        }
        return item;
    }

    private static void makeOrder() {
        order = new Order();
        boolean more = true;
        do {
            showMenu();
            Product prod = getProduct();
            if (prod != null) {
                int amount = getAmount();
                if (checkStock(prod, amount)) {
                    try {
                        order.updateItem(prod, amount);
                    }
                    catch (UnsupportedOperationException x) {
                        // Ignore.
                    }
                }
                showOrder();
            }
            STDIN.nextLine();
            System.out.print("Continue Order?(Y|N) ");
            String answer = STDIN.nextLine();
            more = answer.length() > 0 && answer.toUpperCase().charAt(0) == YES;
        } while (more);
    }

    private static void showMenu() {
        System.out.println("Stationaries");
        System.out.println("============");
        System.out.println("ID  Name                Price Quantity");
        System.out.println("=== =================== ===== ========");
        for (Item item : stock) {
            Product p = item.getProduct();
            System.out.printf("%3d %-19s %5.2f %d%n",
                              p.id(),
                              p.name(),
                              p.price().doubleValue(),
                              item.getAmount());
        }
    }

    private static void showOrder() {
        if (order != null) {
            List<Item> items = order.getItems();
            if (items.size() > 0) {
                System.out.println("Your order:");
                System.out.println("ID  Name                Price Quantity Cost");
                System.out.println("=== =================== ===== ======== ======");
                BigDecimal total = new BigDecimal(0);
                for (Item item : order.getItems()) {
                    Product prod = item.getProduct();
                    int amount = item.getAmount();
                    BigDecimal cost = prod.price().multiply(new BigDecimal(amount));
                    total = total.add(cost);
                    System.out.printf("%3d %-19s %5.2f %8d %.2f%n",
                                      prod.id(),
                                      prod.name(),
                                      prod.price().doubleValue(),
                                      amount,
                                      cost);
                }
                System.out.printf("Total: %.2f%n", total);
            }
            else {
                System.out.println("Nothing ordered.");
            }
        }
    }

    public static void main(String[] args) {
        try {
            initializeStock();
            makeOrder();
            showOrder();
            System.out.println("\nGood bye.");
        }
        catch (IOException x) {
            x.printStackTrace();
        }
    }
}

• It is recommended to use [class] BigDecimal, rather than [primitive] double for handling money.
• I believe you need at least JDK 9 to run the above code.

Output from a sample run of the above code:

Stationaries
============
ID  Name                Price Quantity
=== =================== ===== ========
  1 rulers               1.00 400
  2 pen                  4.00 700
Enter product ID: 1
Enter quantity: 1
Your order:
ID  Name                Price Quantity Cost
=== =================== ===== ======== ======
  1 rulers               1.00        1 1.00
Total: 1.00
Continue Order?(Y|N) y
Stationaries
============
ID  Name                Price Quantity
=== =================== ===== ========
  1 rulers               1.00 399
  2 pen                  4.00 700
Enter product ID: 1
Enter quantity: 1
Your order:
ID  Name                Price Quantity Cost
=== =================== ===== ======== ======
  1 rulers               1.00        2 2.00
Total: 2.00
Continue Order?(Y|N) y
Stationaries
============
ID  Name                Price Quantity
=== =================== ===== ========
  1 rulers               1.00 398
  2 pen                  4.00 700
Enter product ID: 2
Enter quantity: 1
Your order:
ID  Name                Price Quantity Cost
=== =================== ===== ======== ======
  1 rulers               1.00        2 2.00
  2 pen                  4.00        1 4.00
Total: 6.00
Continue Order?(Y|N) n
Your order:
ID  Name                Price Quantity Cost
=== =================== ===== ======== ======
  1 rulers               1.00        2 2.00
  2 pen                  4.00        1 4.00
Total: 6.00

Good bye.

The code

finalQuantity += orderList[index].getOrderQuantity();

will always increase the value in the variable finalQuantity, which you save later with the code

orderList[index].setOrderQuantity(finalQuantity);

However, you don't set (or reset) the variable finalQuantity to the current quantity of your order/product. That's why you will get the current result of 3 instead of the expected result of 1, because in the previous loop/iteration, that variable was set to 2.

When you want to update the quantity, you need to read the current quantity first and set it in the variable finalQuantity before increasing it by the user input.

On a side note: Your code is structured in an unclear way, which looks (and maybe is) wrong. Your Order class contains different code logic, one for managing one order entry, but also for managing the menu/userinteraction. That makes it weird to have Order[] orderList = new Order[size]; inside the Order class (specially as a field member). It is also not clear if the Order class is in fact for one single order of possible multiple products (in different quantities) or if it has multiple orders (of what?).

You might also want to look into java.util.List<T> and java.util.Map<K,V> to have a container with dynamic size and to save the quantities for each product selected.