Asking for help with Sort-Program (Arrays)

[Roland Weber]

Hi

Some time ago, I've written this Code:

import java.util.*; 

class Student 
{ 
        String vorname; 
        String nachname; 
        int    id; 
        double noten; 

        Student(String vorname, String nachname, int id, double noten) 
        { 
                this.vorname  = vorname; 
                this.nachname = nachname; 
                this.id       = id; 
                this.noten    = noten; 
        } 
        
        public String toString() 
        { 
                return id + ", " + noten + ", " + vorname + " " + nachname; 
        } 
        
        public void setVorname(String Vorname) 
        {        
                this.vorname=vorname; 
        } 

        public String getVorname() 
        {          
                return this.vorname; 
        } 

        public void setNachname(String nachname) 
        {          
                this.nachname=nachname; 
        } 

        public String getNachname() 
        { 
                return this.nachname; 

        }    
        public void setID(int id) 
        {        
                this.id=id; 
        } 

        public int getID() 
        {          
                return this.id; 
        } 

        public void setNoten(double noten) 
        {          
                this.noten=noten; 
        } 

        public double getNoten() 
        { 
                return this.noten; 

        }  
} 

class VornameComparator implements Comparator 
{ 
        public int compare(Object stud1, Object stud2) 
        { 
                String stud1Vorname = ((Student)stud1).getVorname(); 
                String stud2Vorname = ((Student)stud2).getVorname(); 
                return stud1Vorname.compareTo(stud2Vorname); 

        } 
} 

class NachnameComparator implements Comparator 
{ 
        public int compare(Object stud1, Object stud2) 
        { 
                String stud1Nachname = ((Student)stud1).getNachname(); 
                String stud2Nachname = ((Student)stud2).getNachname(); 
                return stud1Nachname.compareTo(stud2Nachname); 
        }        
} 

class IDComparator implements Comparator 
{ 
        public int compare(Object stud1, Object stud2) 
        { 
                int stud1ID = ((Student)stud1).getID(); 
                int stud2ID = ((Student)stud2).getID(); 
                if(stud1ID > stud2ID) 
                { 
                        return 1; 
                } 
                else if(stud1ID < stud2ID) 
                { 
                        return -1; 
                } 
                else 
                { 
                        return 0; 

                } 
        } 
} 

class NotenComparator implements Comparator 
{ 
        public int compare(Object stud1, Object stud2) 
        { 
                double stud1Noten = ((Student)stud1).getNoten(); 
                double stud2Noten = ((Student)stud2).getNoten(); 
                if(stud1Noten > stud2Noten) 
                { 
                        return 1; 
                } 
                else if(stud1Noten < stud2Noten) 
                { 
                        return -1; 
                } 
                else 
                { 
                        return 0; 

                } 
        } 
} 

class Sortieren 
{ 
        public static void main(String[] args) 
        { 
                Student[] student2 = new Student[7]; 

                student2[0] = new Student("Alan"   , "Wake"    , 18791955, 5.95); 
                student2[1] = new Student("Serious", "Sam"     , 16431727, 5.55); 
                student2[2] = new Student("Max"    , "Payne"   , 15641642, 5.85); 
                student2[3] = new Student("Ezio"   , "Auditore", 15711530, 5.99); 
                student2[4] = new Student("James"  , "Horner"  , 18181889, 5.15); 
                student2[5] = new Student("John"   , "Williams", 18671934, 5.75); 
                student2[6] = new Student("Trevor" , "Rabin"   , 18241907, 5.35); 
                
                System.out.println("Before sort"); 
                System.out.println("-------------------------------------------"); 
                
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 

                Arrays.sort(student2, new VornameComparator()); 
                System.out.println("Sorted by Names"); 
                System.out.println("----------------------------------------------------------------------------"); 
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 
                
                Arrays.sort(student2, new NachnameComparator()); 
                System.out.println("Sorted by Lastnames"); 
                System.out.println("-----------------------------------------------------------------------------");      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 

                Arrays.sort(student2, new IDComparator()); 
                System.out.println("Sorted by ID"); 
                System.out.println("--------------------------------------------------------------------------");      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 

                Arrays.sort(student2, new NotenComparator()); 
                System.out.println("Sorted by Grades"); 
                System.out.println("-------------------------------------------------------------------------------------");      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
        } 
}

With that little proggie, you can sort some students by their name, lastname, id and grades but with no sorting options (no GUI), which means: after running the program,
5 entries will be printed on the console:

- All students (not sorted)
- All students (sorted by their name)
- All students (sorted by their lastname)
- All students (sorted by their ID)
- All students (sorted by their grades)

In the second version, you can now choose the sorting options (GUI => 4 JButtons). I didn't write that second version on my own, someone else did it for me
(for tutorial purposes). Here's the code:

import java.awt.BorderLayout; 
import java.awt.Container; 
import java.awt.EventQueue; 
import java.awt.GridLayout; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.LinkedList; 
import java.util.List; 

import javax.swing.JButton; 
import javax.swing.JFrame; 
import javax.swing.JList; 
import javax.swing.JPanel; 
import javax.swing.JScrollPane; 

public class SortStudents 
{ 
    public static void main( String[] args ) 
    { 
        // Create a sample list of students 
        final List<Student> students = new LinkedList<Student>(); 
        students.add( new Student( "Alan"   , "Wake"    , 18791955, 5.95 ) ); 
        students.add( new Student( "Serious", "Sam"     , 16431727, 5.55 ) ); 
        students.add( new Student( "Max"    , "Payne"   , 15641642, 5.85 ) ); 
        students.add( new Student( "Ezio"   , "Auditore", 15711530, 5.25 ) ); 
        students.add( new Student( "James"  , "Horner"  , 18181889, 5.15 ) ); 
        students.add( new Student( "John"   , "Williams", 18671934, 5.75 ) ); 
        students.add( new Student( "Trevor" , "Rabin"   , 18241907, 5.35 ) ); 
        
        // Sort according to name 
        sortNames( students );        
        System.out.println( "\nSorted by name:" ); 
        for ( Student student : students ) System.out.println( student ); 
        
        // Sort according to lastname 
        sortLastNames( students );        
        System.out.println( "\nSorted by lastname:" ); 
        for ( Student student : students ) System.out.println( student ); 
        
        // Sort according to id 
        sortIds( students );        
        System.out.println( "\nSorted by id:" ); 
        for ( Student student : students ) System.out.println( student ); 
        
        // Sort according to grades 
        sortGrades( students );        
        System.out.println( "\nSorted by grades:" ); 
        for ( Student student : students ) System.out.println( student ); 
        
        // Create a simple gui 
        try 
        { 
            EventQueue.invokeAndWait( new Runnable() 
            { 
                @Override 
                public void run() 
                { 
                    new StudentsWindow( students ).setVisible( true ); 
                } 
            } ); 
        } 
        catch ( Exception ex  ) 
        { 
            ex.printStackTrace(); 
        } 
    } 
    
    static void sortNames( List<Student> students ) 
    { 
        Collections.sort( 
            students, 
            new StudentComparator( 
                StudentComparator.Typ.NAME ) ); 
    } 
    
    static void sortLastNames( List<Student> students ) 
    { 
        Collections.sort( 
            students, 
            new StudentComparator( 
                StudentComparator.Typ.LASTNAME ) ); 
    } 
    
    static void sortIds( List<Student> students ) 
    { 
        Collections.sort( 
            students, 
            new StudentComparator( 
                StudentComparator.Typ.ID ) ); 
    } 
    
    static void sortGrades( List<Student> students ) 
    { 
        Collections.sort( 
            students, 
            new StudentComparator( 
                StudentComparator.Typ.GRADES ) ); 
    } 
} 

class Student 
{ 
    String  name; 
    String  lastname; 
    Integer id; 
    Double  grades; 
    
    public Student( 
        String  name, 
        String  lastname, 
        Integer id, 
        Double  grades ) 
    { 
        this.name     = name; 
        this.lastname = lastname; 
        this.id       = id; 
        this.grades   = grades; 
    } 
    
    public String toString() 
    { 
        return name + " " + lastname + ", " + id + ", " + grades; 
    } 

    public String getName() 
    { 
        return name; 
    } 

    public String getLastname() 
    { 
        return lastname; 
    } 

    public Integer getId() 
    { 
        return id; 
    } 

    public Double getGrades() 
    { 
        return grades; 
    } 
} 

class StudentComparator implements Comparator<Student> 
{ 
    public enum Typ { NAME, LASTNAME, ID, GRADES } 
    
    Typ typ = Typ.LASTNAME; 
    
    public StudentComparator( Typ typ ) 
    { 
        this.typ = typ; 
    } 
    
    @Override 
    public int compare( 
        Student s1, 
        Student s2 ) 
    { 
        try 
        {        
            switch( typ ) 
            { 
                case NAME: 
                { 
                    return s1.getName().compareTo( s2.getName() ); 
                } 
                case LASTNAME: 
                { 
                    return s1.getLastname().compareTo( s2.getLastname() ); 
                } 
                case ID: 
                { 
                    return s1.getId().compareTo( s2.getId() ); 
                } 
                case GRADES: 
                { 
                    return s1.getGrades().compareTo( s2.getGrades() ); 
                } 
                default: 
                    System.out.println( "Isn't this impossible?"); 
            } 
        } 
        catch( Exception ex ) 
        { 
            // Just in case some attributes could be null or something ... 
            ex.printStackTrace(); 
        } 
        
        return 0; 
    } 
} 

class StudentsWindow extends JFrame 
{ 
    List<Student> students; 
    JList         lStudents; 
    JButton       sortName; 
    JButton       sortLastName; 
    JButton       sortId; 
    JButton       sortGrades; 
    
    public StudentsWindow( final List<Student> students ) 
    { 
        super( "Some Demo" ); 
        
        this.students = students; 
        
        // Create a list for displaying of students 
        lStudents = new JList( students.toArray() ); 
        
        // Create sort buttons 
        sortName     = new JButton( "Sort name" ); 
        sortLastName = new JButton( "Sort last name" ); 
        sortId       = new JButton( "Sort id" ); 
        sortGrades   = new JButton( "Sort grades" ); 
        
        // Add search functionality to buttons 
        sortName.addActionListener( new ActionListener() 
        { 
            @Override 
            public void actionPerformed( ActionEvent e ) 
            { 
                SortStudents.sortNames( students ); 
                
                // After sorting refresh display 
                lStudents.setListData( students.toArray() ); 
                lStudents.revalidate(); 
            }            
        } ); 
        sortLastName.addActionListener( new ActionListener() 
        { 
            @Override 
            public void actionPerformed( ActionEvent e ) 
            { 
                SortStudents.sortLastNames( students ); 
                
                // After sorting refresh display 
                lStudents.setListData( students.toArray() ); 
                lStudents.revalidate(); 
            }            
        } ); 
        sortId.addActionListener( new ActionListener() 
        { 
            @Override 
            public void actionPerformed( ActionEvent e ) 
            { 
                SortStudents.sortIds( students ); 
                
                // After sorting refresh display 
                lStudents.setListData( students.toArray() ); 
                lStudents.revalidate(); 
            }            
        } ); 
        sortGrades.addActionListener( new ActionListener() 
        { 
            @Override 
            public void actionPerformed( ActionEvent e ) 
            { 
                SortStudents.sortGrades( students ); 
                
                // After sorting refresh display 
                lStudents.setListData( students.toArray() ); 
                lStudents.revalidate(); 
            }            
        } ); 
        
        // Add buttons to a panel with grid layout 
        JPanel buttons = new JPanel( new GridLayout( 0, 1 ) ); 
        buttons.add( sortName ); 
        buttons.add( sortLastName ); 
        buttons.add( sortId ); 
        buttons.add( sortGrades ); 
        
        // Add list and button panel to the content pane 
        Container pane = getContentPane(); 
        pane.add( new JScrollPane( lStudents ), BorderLayout.CENTER ); 
        pane.add( buttons, BorderLayout.SOUTH ); 
        
        setDefaultCloseOperation( DISPOSE_ON_CLOSE ); 
        setSize( 320, 320 ); 
    } 
}

Now, why am I posting in this forum: I'd like to have the sorting done only with arrays (array-sort, like I did in the first version) and not with lists and
collections (as it is done in the second version above).
I've already altered my own version of the code (first one posted) to match it better to the tutorial code. My new code consists of parts from my original code and
parts form the tutorial code. Here it is:

import java.util.*; 
import java.awt.*; 
import javax.swing.*; 

public class Sortieren 
{ 
        public static void main(String[] args) 
        {        
                Student[] student2 = new Student[7]; 

                student2[0] = new Student("Alan"   , "Wake"    , 18791955, 5.95); 
                student2[1] = new Student("Serious", "Sam"     , 16431727, 5.55); 
                student2[2] = new Student("Max"    , "Payne"   , 15641642, 5.85); 
                student2[3] = new Student("Ezio"   , "Auditore", 15711530, 5.99); 
                student2[4] = new Student("James"  , "Horner"  , 18181889, 5.15); 
                student2[5] = new Student("John"   , "Williams", 18671934, 5.75); 
                student2[6] = new Student("Trevor" , "Rabin"   , 18241907, 5.35);

                try 
                { 
                            EventQueue.invokeAndWait(new Runnable() 
                            { 
                                @Override 
                                public void run() 
                                { 
                                            new GUI(student2).setVisible(true); 
                                } 
                            }); 
                } 
                catch (Exception ex ) 
                { 
                            ex.printStackTrace(); 
                } 
            } 

//Placholder for Array-Sort-Methods (they don't work at the moment... what do I have to change, to get them working?) 

        static void sortVorname() 
        { 
                Arrays.sort(student2, new StudentenComparator(StudentenComparator.Typ.VORNAME)); 
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 
        } 
        
        static void sortNachname() 
        { 
                Arrays.sort(student2, new StudentenComparator(StudentenComparator.Typ.NACHNAME));      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 
        } 

        static void sortID() 
        { 
                Arrays.sort(student2, new StudentenComparator(StudentenComparator.Typ.ID));      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
                System.out.println(" "); 
        } 
        
        static void sortNoten() 
        { 
                Arrays.sort(student2, new StudentenComparator(StudentenComparator.Typ.NOTEN));      
                for(int i=0; i<student2.length; i++) 
                { 
                        System.out.println(student2[i]); 
                } 
        } 
} 

class Student 
{ 
        String  vorname; 
        String  nachname; 
        Integer id; 
        Double  noten; 

        public Student(String vorname, String nachname, Integer id, Double noten) 
        { 
                this.vorname  = vorname; 
                this.nachname = nachname; 
                this.id       = id; 
                this.noten    = noten; 
        } 
        
        public String toString() 
        { 
                return id + ", " + noten + ", " + vorname + " " + nachname; 
        } 

        public String getVorname() 
        {          
                return vorname; 
        } 

        public String getNachname() 
        { 
                return nachname; 
        }    

        public Integer getID() 
        {          
                return id; 
        } 

        public Double getNoten() 
        { 
                return noten; 
        }  
} 

class StudentenComparator implements Comparator<Student> 
{ 
            public enum Typ {VORNAME, NACHNAME, ID, NOTEN} 
    
            Typ typ = Typ.NACHNAME; 
    
            public StudentenComparator( Typ typ ) 
            { 
                this.typ = typ; 
            } 
    
            @Override 
            public int compare(Student s1, Student s2) 
            { 
                try 
                {        
                            switch( typ ) 
                            { 
                                case VORNAME: 
                                { 
                                            return s1.getVorname().compareTo(s2.getVorname()); 
                                } 
                                case NACHNAME: 
                                { 
                                            return s1.getNachname().compareTo(s2.getNachname()); 
                                } 
                                case ID: 
                                { 
                                            return s1.getID().compareTo(s2.getID()); 
                                } 
                                case NOTEN: 
                                { 
                                            return s1.getNoten().compareTo(s2.getNoten()); 
                                } 
                                default: 
                                            System.out.println("Unmoeglich..."); 
                            } 
                } 
                catch( Exception ex ) 
                { 
                            ex.printStackTrace(); 
                } 
                return 0; 
            } 
} 
        
class GUI extends JFrame 
{ 
            List<Student> students;                                                         // <= Change List; no lists wanted 
            JList         lStudents;                                                        // <= JList is ok, I think...
            JButton       sortVorname; 
            JButton       sortLastNachname; 
            JButton       sortID; 
            JButton       sortNoten; 
    
            public GUI(final List<Student> students)                                        // <= Change List; no lists wanted 
            { 
                super("Sortieroptionen");                                                 
        
                this.students = students; 
        
                lStudents = new JList(students.toArray());                                  // <= JList is ok, I think... 
        
                sortVorname  = new JButton("Sortieren nach Vornamen"); 
                sortNachname = new JButton("Sortieren nach Nachnamen"); 
                sortID       = new JButton("Sortieren nach ID"); 
                sortNoten    = new JButton("Sortieren nach Notendurchschnitt"); 
        
                sortVorname.addActionListener(new ActionListener() 
                { 
                            @Override 
                            public void actionPerformed(ActionEvent e) 
                            { 
                                Sortieren.sortVorname(student2);                         // <= Name for the first Array-Sort-Method (name)
                
                                lStudents.setListData(students.toArray()); 
                                lStudents.revalidate(); 
                            }            
                }); 
        
                sortNachname.addActionListener(new ActionListener() 
                { 
                            @Override 
                            public void actionPerformed(ActionEvent e) 
                            { 
                                Sortieren.sortNachname(student2);                        // <= Name for the second Array-Sort-Method (lastname)
                
                                lStudents.setListData(students.toArray()); 
                                lStudents.revalidate(); 
                            }            
                }); 
                
                sortID.addActionListener(new ActionListener() 
                { 
                            @Override 
                            public void actionPerformed(ActionEvent e) 
                            { 
                                Sortieren.sortID(student2);                              // <= Name for the second Array-Sort-Method (ID) 
                
                                lStudents.setListData(students.toArray()); 
                                lStudents.revalidate(); 
                            }            
                }); 
                
                sortNoten.addActionListener(new ActionListener() 
                { 
                            @Override 
                            public void actionPerformed(ActionEvent e) 
                            { 
                                Sortieren.sortNoten(student2);                           // <= Name for the second Array-Sort-Method (grades) 
                
                                lStudents.setListData(students.toArray()); 
                                lStudents.revalidate(); 
                            }            
                }); 
        
                JPanel buttons = new JPanel(new GridLayout(0, 1)); 
                buttons.add(sortVorname); 
                buttons.add(sortNachname); 
                buttons.add(sortID); 
                buttons.add(sortNoten); 
        
                Container pane = getContentPane(); 
                pane.add(new JScrollPane(lStudents), BorderLayout.CENTER);                // <= JList is ok, I think... 
                pane.add(buttons, BorderLayout.SOUTH); 
        
                setDefaultCloseOperation(DISPOSE_ON_CLOSE);                                
                setSize(320, 320); 
            } 
}

Unfortunately, I've encountered some problems:

- How do I get the Array-Sort-Methods working again (what do I have to change / write), so that it is possible to invoke them by pressing the corresponding JButton?
- How do I get the student2 variable working outside of the main-method? Declare it as final? But how...?
- How do i get rid off the remaining list-objects, so that it is (still) possible to run the program?
- Are there other things I have to change in my Code to make it work properly?

I hope you understand what I've written and can help me. English is not my native language.


Greeting

Learner

[Ulrika Tingle]

Why don't you take this opportunity to rethink your design?

The problem is that you've strewn implementation detail throughout the whole program so that when you want to change a data structure you have to change in lots of places.

Try instead to use OO and hide implementation detail in classes so you can change data structures without effecting the whole program. Try to hide exactly how you store students.

Rather than engaging this forum into helping you debug a program with a fawlty design, it's better you fix the design to make your program easier to change. Making programs easy to change is why you use OO in the first place.

[chandrakant karale]

Would like to know why you want an Array based sorting?

For your approach Lists can be converted to Array using toArray method.