Infix to Postfix Converter Program
I like this opportunity for a code review because I hopefully can share some good programming techniques that I didn't have a chance to learn until I actually got out of school and into the industry. I can edit to explain anything further.


Your variable infixExpression can be defined as final:

private final String infixExpression;


This isn't necessary but is good practice as it's a good idea to maximize the immutability of your classes. Anything variable which is only modified when declared, or in a constructor, may be final.
The convertInfixExpression method should also be public. I know this is for an assignment, but that should not stop you from thinking about using it outside the main method. Alternatively, you could do away with the constructor altogether, and just make this method static. That way, you would use it by calling

PostfixConverter.convertInfixExpression("my infix expression");


This is possible by changing your current convertInfixExpression method signature to

public static String convertInfixExpression(String infixExpression)

I don't know what library ArrayStack came from, but I can assume how it works. That being said, you don't parametize it which is a big no no, and causes yourself some extra work later. This should be 

Stack&lt;String&gt; operatorStack = new ArrayStack&lt;String&gt;();

In Java, appending to a String is typically a bad idea. If you have an object you know you'll be appending too, use a StringBuilder:

StringBuilder converted = new StringBuilder();

Concerning the first while loop in the method, I don't like the looks of it from a glance. There's way too many nested while, if, and else statements. We'll see if we can simplify some of that. To start, let's look at the highest level of what's going on:

If token is a '(' push to stack
If token is a ')' do complicated stuff
If token is an Operator do complicated stuff
Otherwise append the token to the result


So the hint here is that you want to move all that complicated stuff to separate methods. Your code benefits from this by being much easier to read and reason about.
There's almost never a reason to use the new keyword next to String in Java.

operatorStack.push(token);


not 

operatorStack.push(new String(token));

The first complicated block (fixed formatting):

while(operatorStack.top().equals("(") != true) {
    converted = converted + " " + operatorStack.pop();
}
if(operatorStack.top().equals("(")) {
    operatorStack.pop();
}


I guess this isn't too complicated, but I don't like seeing nested while statements... This is how I would write it:

while(!operatorStack.top().equals("(")) {
    converted.append(" ").append(operatorStack.pop());
}
operatorStack.pop();


I'll highlight the differences:


There's no reason to ever compare anything to true or false in an if statement. 
Used append from the StringBuilder. Check out the Oracle tutorial on this class to find out why.
There's no reason for the if statement. We already know the a ( is on the top of the stack, otherwise the previous loop wouldn't have ended.

Regarding the second complicated bit, I would write it like so:

else if (isOperator(token)){
    if(operatorStack.isEmpty()) {
        operatorStack.push(token);
    }
    else {
        if(ICP(token) &lt; ISP(operatorStack.top())) {
            converted.append(" ").append(operatorStack.pop());
            operatorStack.push(token);
        }
        else {
            operatorStack.push(token);
        }
    }
}


Pretty much the same comments as above, but notice you don't need to cast to a String because you've now parametized your stack. Too be honest, though I'm still not entirely sure of the purpose of the logic here, but mainly because I have no idea what ICP and ISP mean!
Use descriptive and conventional method names. If ICP and ISP return a value, they should start with get. I know they're return the precedence of operators, but the S and C is still unclear to me. That being said, you can simplify all of this by using some Map constants. For example, 

private static final Map&lt;String, Integer&gt; S_PRECEDENCE;
static {
    Map&lt;String, Integer&gt; map = new HashMap&lt;String, Integer&gt;();
    map.put("+", 2);
    map.put("-", 2);
    map.put("*", 4);
    ....
    S_PRECEDENCE = Collections.unmodifiableMap(map);
}


And then you can change the ISP method to something like

public int ISP(String token) {
    return S_PRECEDENCE.contains(token) ? S_PRECEDENCE.get(token) : 0;
}


I'll note that S_PRECEDENCE is a bad name and should be expanded with whatever S means.
Along the same lines, you can make a Set of your operators, and simply check if that collection contains the token.