You need to have your Member class implement Comparable and then implement the compareTo function however you want

https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html

If your Java version is 1.8 or greater , you can use Stream with an easiest way.

final List<Member> memberListWhichIsMaleAndScoreGreaterThan50 = Arrays.stream(memberList)
        .filter(member -> member.getGender().equals("male") && member.getScore() > 50)
        .collect(Collectors.toList());
//do  whatever you want on this list.

Here filter is filtering the list with gender and score. After that collecting to list to make an operation if you want.

I have a nice solution for you. Using constructors and getters and setters, without complex functions. Due to you only need to print name and score you can concatenate them as a single string, sort them and finally divide the string.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class foo {

public Member me = new Member();

public void displayAllMaleMembers() {

    System.out.println("List of male members:");
    for (Member member : me.getMembers()) {
        if (member.getGender().equals("male") && member.getScore() > 50) {
            System.out.println("Name:  " + member.getName());
            System.out.println("Score: " + member.getScore());
            System.out.println();
        }
    }

    System.out.println("The sorted names by score are:");
    String[] sort = new String[me.getMembers().size()];
    // concatenate name + comma + score
    for (int i = 0; i < sort.length; i++) {
        sort[i] = me.getMembers().get(i).getName() + "," + me.getMembers().get(i).getScore();
    }
    Arrays.sort(sort, Collections.reverseOrder()); // sort the concatenated string
    // prints
    for (String s : sort) {
// Split() divides the concatenated string, 
// [0] is the first position of the string[] returned by spit(",");
        System.out.println("Name:     " + s.split(",")[0]); // string before comma: name
        System.out.println("Handicap: " + s.split(",")[1]); // string after comma: score
    }
}

//Main
public static void main(String[] args) {

    foo f = new foo();
    ArrayList<Member> m = new ArrayList<Member>();
    // Creates an arraylist using the constructor field from Member class
    m.add(new Member("Criss", 80, "male"));
    m.add(new Member("Frank", 20, "male"));
    m.add(new Member("Ann", 80, "femmale"));

    // adds the arraylist through setMembers method
    f.me.setMembers(m);
    // print data
    f.displayAllMaleMembers();
}

}

Getters and setters class: The arraylist<Members> stores all attributtes you need (score, name, gender)

import java.util.ArrayList;
public class Member {

String Name;
int Score;
String Gender;
ArrayList<Member> members = new ArrayList<>();

//Constructor using fields
public Member(String name, int score, String gender) {
    super();
    Name = name;
    Score = score;
    Gender = gender;
} 

// default
Member(){
}

public ArrayList<Member> getMembers() {
    return members;
}

// Creates an arrayList of Members
public void setMembers(ArrayList<Member> members) {
    this.members.addAll(members); //adds all arraylist items
}

public String getName() {
    return Name;
}

public void setName(String name) {
    Name = name;
}

public int getScore() {
    return Score;
}

public void setScore(int score) {
    Score = score;
}

public String getGender() {
    return Gender;
}

public void setGender(String gender) {
    Gender = gender;
}
}

Output:

List of male members:
Name:  Criss
Score: 80

The sorted names by score are:
Name:     Frank
Handicap: 20
Name:     Criss
Handicap: 80
Name:     Ann
Handicap: 80

First, the sort operation should be outside the for loop as tyou want to do that only one time. Second, you can sort the list in this way:

memberList.sort(Comparator.comparing(Member::getScore));

If your data are not stored in a List you can sort them in this way:

Arrays.sort(memberList, Comparator.comparingInt(Member::getScore));

Otherwise let your Member class implement Combarable interface.