How to sort integer array without losing location

How about storing your results in a Map<String,Integer> instead of two lists:

Map myMap = new HashMap<String,Integer>;

From there you can sort the Map by its values: Sort a Map<Key, Value> by values (Java)

Next you can iterate through the sorted map:

for(String s : myMap.keySet()){
    System.out.println(s+"("+myMap.get(s)+")");
}

If that is an option, your code can be made much simpler with Java 8.

First of all, removing punctuation can be done with a simple regular expression: you only want to keep letters, so we can just remove everything that is neither a letter nor a space. This is done by calling replaceAll("[^a-zA-Z\\s]", ""). After that, we can get a hold of all the words by splitting around "\\s+" (i.e. all whitespace characters).

Then, let's create a helper method returning the value of a String. As you have in your question, this would just be:

private static int value(String str) {
    return str.chars().map(c -> c - 'a' + 1).sum();
}

Finally, we need to sort the words array with a comparator comparing the value of each word. The comparator is created with the help of Comparator.comparingInt(keyExtractor) where the key extraction would be a function returning the value of a word. In this case, it could be expressed a lambda expression: word -> value(word).

To have the final output, we need to transform the words array into a String where each word is concatenated with its value in parentheses. This is done by creating a Stream<String> of the words (Arrays.stream(array)), sorting it according the comparator above (sorted(comparator)), mapping each word to the result of concatenating its value to it and finally collecting that into a String delimited by a space (Collectors.joining(delimiter)).

Whole code would be:

public static void main(String[] args) {
    String str = "Take advantage, do your best, don't stress.";
    String[] words = str.toLowerCase().replaceAll("[^a-zA-Z\\s]", "").split("\\s+");
    String output = 
        Arrays.stream(words)
              .sorted(Comparator.comparingInt(w -> value(w)))
              .map(w -> w + "(" + value(w) + ")")
              .collect(Collectors.joining(" "));
    System.out.println(output);
}

private static int value(String str) {
    return str.chars().map(c -> c - 'a' + 1).sum();
}

Use any of sorting algorithm and do sorting for both arrays. For example:

public static void bubbleSort(int[] numArray, String[] words) {

    int n = numArray.length;
    int temp = 0;
    String tt;

    for (int i = 0; i < n; i++) {
        for (int j = 1; j < (n - i); j++) {

            if (numArray[j - 1] > numArray[j]) {
                temp = numArray[j - 1];
                tt=words[j-1];
                numArray[j - 1] = numArray[j];
                words[j-1]=words[j];
                numArray[j] = temp;
                words[j]=tt;
            }

Then change last part of your main function to look like this:

    String[] words = output.split(" ");
    int[] points = new int[words.length];

    //Points assignment
    for(int j = 0; j < words.length; j++){
        for(int k = 0; k < words[j].length(); k++){
            points[j] += (int)words[j].charAt(k) - 96;
        }

    }
    bubbleSort(points,words);
    for(int j = 0; j < words.length; j++){
        System.out.print(words[j] + "(" + points[j] + ")" + " ");

    }

If you are not allowed to use Java 8 (else use @Tunaki's approach), create a Comparable object that keeps two values, a String (word) and an int (sum). Then, just add each word to a list and sort it using Collections.sort(yourList).

public class Word implements Comparable<Word>{

    private String word;
    private int sum;

    public Word(String word) {
        this.word = word;
        setSum();
    }

    private void setSum() {
        //your sum function, I just copy and paste it from your post
        for(int k = 0; k < word.length(); k++)
            sum += (int)word.charAt(k) - 96;
    }

    public String getWord() {
        return word;
    }

    public int getSum() {
        return sum;
    }

    @Override
    public int compareTo(Word o) {
        return this.sum > o.sum ? 1 : -1;
    }
}