Finding the missing value in a proportion
public static double CombinedGasLaw ( double [] original, double [] end, String query)



As a general rule, methods have verb names.  Noun names represent objects or classes.  

To get what you want, you need a way to represent a missing value.  One possibility in Java is a null.  Consider 

public class CombinedGasLaw {

    private double pressure;
    private double volume;
    private double temperature;
    private double constant;

    public CombinedGasLaw(double pressure, double volume, double temperature) {
        this.pressure = pressure;
        this.volume = volume;
        this.temperature = temperature;
        constant = pressure * volume / temperature;
    }

    public CombinedGasLaw(double[] values) {
        this(values[0], values[1], values[2]);
    }

    public double getConstant() {
        return constant;
    }

    public static int findIndexOfNull(Object [] values) {
        for (int i = 0; i &lt; values.length; i++) {
            if (values[i] == null) {
                return i;
            }
        }

        return -1;
    }

    public Double solve(Double [] end) {
        switch (findIndexOfNull(end)) {
        case 0:
            return constant * end[2] / end[1];
        case 1:
            return constant * end[2] / end[0];
        case 2:
            return end[0] * end[1] / constant;
        }

        return null;
    }

    public static void main(String[] args) {
        CombinedGasLaw original = new CombinedGasLaw(1, 1, 1);
        Double [] end = {1.0, null, 1.0};
        Double fin = original.solve(end);
        System.out.println("The missing value:  " + fin);
    }

}


Now we have a class named CombinedGasLaw and we can name the method solve, as in solve for the missing value.  

We pass the array of values with one missing.  

We search for the missing value with a for loop.  Note that this will break if there is more than one missing value.  

This version also allows us to find multiple triples and only calculates the constant value once.  

There are two constructors because I don't know how you get your input.  I wouldn't use an array for original but perhaps you had some reason to do so.  So I made it so that you can call the constructor with an array.  If so, it just calls the other constructor.  I don't use that constructor though, so you could just delete it.  

If there is a name used both by an object field and a method parameter, Java defaults to using the parameter.  You can override this by saying this.pressure, which tells it to use the field instead.  So one easy way to assign values to fields in a constructor is to use the same name for both sides.  

The this. is not needed any other time, although you can use it if you want.  It's basically saying that it is the pressure associated with the current object.  Absent a method parameter with the same name, that's the default, so you don't normally need it.  Documentation.