Somar valores em ArrayList sobre um preço e não sobre index

Boa noite.
Preciso criar um indicador em uma plataforma de trade onde aceita java.
Fiz 2 testes, um com array normal e outro com arrayList.
Com array normal não é o ideal porque preciso redimensionar mas nesse exemplo já tenho uma dificuldade em vincular a soma de um determinado volume ao seu preço.
Eu preciso fica somando volume ao preço, mesmo esse preço trocando de index, ele deve carregar o que já foi somado anteriormente com o novo volume.
No primeiro código tem um erro onde ele soma pelo index.

        public static void main(String[] args) {

    Scanner in = new Scanner(System.in);

    int escolha = 0;
    double array[][] = new double[3][1];
    double x[] = new double[3];
    double y[] = new double[1];
    
    while(escolha != -1){
        System.out.println("1 para continuar, -1 parar ");
        escolha = in.nextInt();
        if(escolha == -1){
            break;
        }
    
        for (int i = 0; i < 3; i++) {
            System.out.println("Digite o " + (i+1) + "º Preço: ");
            x[i] = in.nextDouble();
            
            for (int j = 0; j < 1; j++) {
                System.out.println("Digite o volume: ");
                y[j] = in.nextDouble();
                array[i][j] += y[j];
                System.out.println("preço: " + x[i] + " volume " + y[j] );
                
                System.out.println("Total: " + array[i][j]);
            }
        }
    }    
}

Neste print pode visualizar que não soma pelo preço e sim pelo index.

Com arrayList bidimensional.
Eu preciso somar e conseguir pegar tanto o preço quanto o volume que já foi somado nele.
Percebi que precisava redimensionar o array, por isso vou usar o arrayList.
Percebi que precisava reorganizar o array, então vou usar o Collections.sort().
Percebi que duplicaria números, então vou usar Set para remover os duplicados.

1º Não consegui fazer a soma.
2º Não consegui adicionar o que coletei via scanner ao Set.
3º Tirando o Set, fiz um teste inserindo valores, e não consegui coletar preço e volume separados, duplica no resultado.

Código abaixo com um print.

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    
    ArrayList<ArrayList<Double>> array = new ArrayList<>(); //Array final que deve conter o volume somado ao preço
    ArrayList<Double> pr = new ArrayList<>(); //Array para receber o preço
    ArrayList<Double> vl = new ArrayList<>(); //Array para receber o volume
    Set<Double> remove = new TreeSet<>(); //Remove números duplicados.

    int escolha = 0;
    
    while(escolha != -1){
        System.out.println("1 para continuar, -1 parar ");
        escolha = in.nextInt();
        if(escolha == -1){
            break;
        }
    
        for (int i = 0; i < 3; i++) {
            System.out.println("Digite o " + (i+1) + "º Preço: ");
            pr.add(in.nextDouble());
            Collections.sort(pr,Collections.reverseOrder()); //Organizar de baixo para cima
            array.add(i,pr);
            
            for (int j = 0; j < 1; j++) {
                System.out.println("Digite o volume: ");
                vl.add(in.nextDouble());
                array.add(j,vl);
                System.out.println("preço: "+ array.get(i) + " Volume: " + array.get(j)); //Não esta aparecendo os dados individuais, esta duplicando

            }
        }
    }
}

Print

Desculpe o texto longo, mas é um pouco confuso para explicar, por isso vou deixar um print do que deseja fazer.
OBS: Essa plataforma não aceita criação de classes e métodos, o que deixei no código funcionou porque já estava importada, mas se precisar fazer teste com outra coisa não tem problema em testar.

Vejam que cada preço ali recebeu uma quantidade de volume, e em laranja foi o maior, isso que preciso coletar.

Cara, você pode me dizer qual é o propósito do código por favor? Confesso que me perdi um pouco e por não saber ao certo o que ele deveria fazer não consigo ajudar.

Veja essa última foto, os preços são 100.xxx, ali já foi feito uma lista dos preços já atingidos.
Cada vez que o preço atual passar por um valor dessa lista que é o próprio preço, deve somar um volume a esse preço.
No caso vou pegar de exemplo o preço 100.495 que esta com 46.94k, e supomos que o preço 100.500 esteja ainda com 55k, então o preço se deslocou para o 100.500 e o volume naquele momento foi somado com esses 55k, onde ficou o total de 57.73k.
No print abaixo, a linha do preço fica subindo e descendo, e nesse movimento existe o volume que pretendo somar em cada preço que passar.
Naquele risco no quadrado que marquei no preço 101.060 foi a soma total do dia naquele preço.

Fazendo uma analogia
Imagine um restaurante com 5 mesas, o cliente senta na mesa de número 5, consome, isso gera um valor a se pagar.
Mas colocaram mais mesas, e o cliente escolheu mudar de lugar foi para a mesa 20, logo o cliente já tinha um valor para pagar, e esse custo foi com ele para a mesa 20 + o restante do consumo
Essa é a dificuldade que estou tendo, o preço ali seria o cliente, e o volume que preciso somar é o consumo.
Da forma que fiz, acabei somando pelo index e não pelo cliente/preço.
E o acréscimo de mesas seria o redimensionamento de array que preciso fazer, porque a lista da direita onde esta aqueles valores somados, começa zerado e vai aumentando conforme o preço se movimenta durante o dia.
Se precisar esclarecer mais alguma coisa, por favor pede, preciso resolver isso e sei como é díficil para quem não sabe do que se trata, por isso coloquei o exemplo do restaurante.

Vou dar um up com um avanço que fiz.
A estrutura principal do código que fiz parece que esta ok.
O que falta é transformar o preço em index, problema que ele é double.

public static void main(String[] args) {
        
        ArrayList<Double> pr = new ArrayList<>(); //Array para receber o preço original
        Set<Double> remove   = new TreeSet<>();   //Remove números duplicados e organiza o array
        double array[][]     = new double[5][1];  //Array para somar na posição do preço o volume
        Scanner in           = new Scanner(System.in);

        double vl[]  = new double[1];       //Array de volume
        int    index = 0;
        double valor = 0;

        for ( int i = 0; i < 5; i++ ) {     //For para coleta e conversão do preço
            System.out.println( "Digite o " + (i+1) + "º Preço: " );
            pr.add(in.nextDouble());        //Entrada de dados temporária, vai entrar automático esse preço
            remove.addAll(pr);              //Remove valores duplicados no array e organiza de forma crescente o preço

            ArrayList<Double> convert = new ArrayList<>(remove); //Converter Set para ArrayList para pegar o preço na posição

            for( int k = 0; k < remove.size(); k++ ) {
                valor = convert.get(k);     //Varre o array pegando cada preço e guardando na variável valor 

                if(pr.get(i) == valor){     //Compara o preço na variável valor com o último preço digitado
                    index     = k;          //Se existe, index recebe essa posição
                    break;
                }
                else{ index = i; }          //Se não existe, nova posição para index
            }

            for ( int j = 0; j < 1; j++ ) { //For para aplicar o volume ao preço
                System.out.println( "Digite o volume: " );
                vl[j] = in.nextDouble();

                array[index][j] += vl[j];   //Soma do volume no index coletado no for anterior

                System.out.println( "Array preço: " + remove + ", Volume atual " + vl[j] + ", Último preço: " + pr.get(i) );
                System.out.println( "Total Somado: " + array[index][j] +" na posição " + index );
                System.out.println();
            } 
        }
    }

Nesse código acima, ele soma por index, se o preço ficar na mesma posição, tudo bem, vai acumulando, parecendo que esta funcionando, mas quando o array é reorganizado, a soma daquele preço fica para trás.
Parecendo certo:

Agora quando o preço troca de index:

Então seria isso para solucionar, que o preço vire o index para não acontecer isso

Usa Map<Double, Integer>.
Voce chama map.put(preço, map.get(preço) + volume);

Assim você vai ter o volume total por preço.

Boa noite.
Fiz um teste, mas se eu deixar Integer no map a linha onde marquei com uma seta fica com erro.
E mesmo deixando Double, gera um erro com o map da forma que fiz.
Esse map a plataforma que uso aceita, fiz o teste e seria uma boa se ele realmente somar em cada preço o volume correspondente.
Vou deixar o print de como fiz e o erro.

Por que você tem todos estes loops encadeados?

double preco = in.nextDouble();
int volume = in.nextInt(); //seu volume não precisa ser double, já que não tem ponto flutuante. No máximo long pelo tamanho.

map.put(preco, map.get(preco) + volume);

A linha map.get(preco) vai retornar o ultimo valor de volume que vc salvou no map, onde o preco é a chave. Você soma isso ao volume inserido e adiciona de volta ao map(map.put…)

Esses loops são o seguinte.
Onde vou aplicar isso, existe um loop principal, tudo roda dentro dele o tempo todo.
Depois os outros dois são para realmente fazer o que preciso, coletar preço e volume e somar na posição correspondente.
Preciso usar o arrayList porque o preço vai aumentando em espaço.
E ambos são double, não digitei com casa decimal para facilitar, mas entram double tendo casa decimal.
Um print do erro que deu com sua dica.