Generally you'd use one of the orderByAsc/Dsc methods on com.ibm.team.repository.common.query.IQuery, passing the query model field to order by.

Here's an example from the RTC Eclipse UI code that queries for build definitions in the selected project/team areas.

        IItemQuery itemQuery = IItemQuery.FACTORY.newInstance(IBuildDefinitionQueryModel.ROOT);

        // get the team areas for the connected project areas in the repo and

        // use them to narrow the search

        IProcessAreaHandle[] processAreaHandles = getProcessAreaHandles(repository, monitor);

        IItemHandleInputArg[] itemHandleArgs = new IItemHandleInputArg[processAreaHandles.length];

        for (int i = 0; i < processAreaHandles.length; i++) {

            itemHandleArgs[i] = itemQuery.newItemHandleArg();

        }

        // create the query

        IBuildDefinitionQueryModel buildDefinitionQueryModel = IBuildDefinitionQueryModel.ROOT;

        final IItemQuery query = IItemQuery.FACTORY.newInstance(buildDefinitionQueryModel);

        IPredicate filter = ((BuildDefinitionQueryModel) buildDefinitionQueryModel).processArea()._in(itemHandleArgs);

        query.filter(filter);

        query.orderByDscUsingLocale(buildDefinitionQueryModel.id());

        // get the results

        IItemManager itemManager = repository.itemManager();

        ItemQueryIterator<IBuildDefinitionHandle> iter = new ItemQueryIterator<IBuildDefinitionHandle>(

                ClientFactory.getTeamBuildClient(repository), itemQuery, new Object[0]);

        LinkedList<IBuildDefinition> buildDefinitions = new LinkedList<IBuildDefinition>();

        while (iter.hasNext(monitor)) {

            List<IBuildDefinitionHandle> definitionHandles = iter.next(IQueryService.ITEM_QUERY_MAX_PAGE_SIZE, monitor);

            buildDefinitions.addAll(itemManager.fetchCompleteItems(definitionHandles, IItemManager.DEFAULT, monitor));

        }

        Iterator definitionsIter = buildDefinitions.iterator();

        while (definitionsIter.hasNext()) {

            Object next = definitionsIter.next();

            if (next == null) {

                definitionsIter.remove();

            }

        }

        return buildDefinitions.toArray(new IBuildDefinition[buildDefinitions.size()]);

I think this is what it looks like (not working, just written)

from https://jazz.net/library/article/1118

there are proper literal ids.. of course

private static final String PENDING = "com.ibm.team.workitem.approvalState.pending";
private static final String REJECTED = "com.ibm.team.workitem.approvalState.rejected";
private static final String APPROVED = "com.ibm.team.workitem.approvalState.approved";
		
	

working code
<code>
    private List<IApproval> querySpecificApprovalsinProjectArea( IProjectAreaHandle ProjectArea, String ApprovalState)
    {
        // save space for the list of approvals found
        List<IApproval> selectedApprovals = new ArrayList<IApproval>();
        // create the query model, aka workitems
        BaseWorkItemQueryModel workItems = BaseWorkItemQueryModel.WorkItemQueryModel.ROOT;
        // setup one condition of the query
        // approvals in pending state
        IStringField state = workItems.internalApprovalDescriptors().cumulativeStateIdentifier(); //.internalApprovals().stateIdentifier();

        IPredicate ApprovalStateFilter = state._eq(ApprovalState);

        IItemQuery query = IItemQuery.FACTORY.newInstance((IItemQueryModel) workItems);   
        // setup space for the project area args in the query
        IItemHandleInputArg[] itemHandleArgs = new IItemHandleInputArg[]{query.newItemHandleArg()};
       
        // the second condition for the query, in the specified project area
        IPredicate projectAreaFilter = workItems.projectArea()._in(itemHandleArgs);
        // increment the counter for this approver
        // combine the conditions both satisfied
        IPredicate CombinedFilter =ApprovalStateFilter._and(projectAreaFilter);

        // set the filter on the query   
        query.filter(CombinedFilter);
        try
        {
            // allocate space for the returned workitems
            List<IWorkItem> selectedWorkItems = new ArrayList<IWorkItem>();
           
            // execute the query, passing in the projectarea specific info 
            IQueryPage qpage =  fQueryService.queryItems(query, new IProjectAreaHandle[]{ProjectArea}, IQueryService.ITEM_QUERY_MAX_PAGE_SIZE);

            do
            {
                // if there are some results on this page
                if(qpage.getSize()>0)
                {
                    // loop thru all the returned workitems
                    for(IWorkItem wi: (List<IWorkItem>)fItemService.fetchItemsPermissionAware((IItemHandle[]) (((IItemQueryPage) qpage).getItemHandles()).toArray(new IItemHandle[1]), new String[]{IWorkItem.APPROVALS_PROPERTY,IWorkItem.APPROVAL_DESCRIPTORS_PROPERTY}).getRetrievedItems())
                    {
                        // get their approvals
                        for(IApproval ap: wi.getApprovals().getContents())
                        {
                            // only copy the pending  state approvals
                            // workitem might contain multiple
                            if(ap.getStateIdentifier().equalsIgnoreCase(ApprovalState))
                                selectedApprovals.add(ap);
                        }
                    }
                }           
                if(qpage.hasNext())
                    qpage =  fQueryService.fetchPage(qpage.getToken(), qpage.getNextStartPosition(), IQueryService.ITEM_QUERY_MAX_PAGE_SIZE);
                else
                    break;
            } while(true);
         }
        catch (TeamRepositoryException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return selectedApprovals;
    }