NetBeans JFrame - Arrayausgabe im Fenster mit Scrollbar

[Nickelodius]

Hallo. ^^

Ich lerne Java in der Schule, daher kann ich noch noch sooo viel.
Demnach hätte ich eine kurze Frage:
Mein momentanes Programm öffnet beim Start ein Fenster mit 3 Auswahloptionen. Wenn man den Button "Start" drückt, öffnet sich ein JFrame mit 10 Sortierarten. Drück man einen dieser Buttons, öffnet sich ein neues Scrollfenster, wo ein sortiertes Feld mit 10000 Werten ausgegeben wird. Jetzt habe ich 2 Fragen:

a) (Wichtiger) Wie kann ich es hinkriegen, dass sich für die Ausgabe des sortierten Feldes nicht extra ein neues Fenster öffnet, sondern dass es neben den Buttons ausgegeben wird, aber so, dass man (weil das Feld sehr lang ist), in dem Feld raus und runter scrollen kann. Der Inhalt der Methode "Arrayfenster" (Ab Zeile 602) soll also in die Methode "Sortierfenster" (Ab Zeile 432).

b) Beim Startfenster kann man auch noch neben dem Button "Start" auch den Button "Einstellungen" drücken. Dort soll man eigentlich die Variable "Arraygröße" und die Variable "Zahlenwerte" einstellen können, sodass man nachher, ohne das Programm zu beenden, zu den Sortierbuttons gelangt und diese dann ein Feld mit den neu eingestellten Werten sortieren. Aber irgendwie funktioniert das nicht.

Relevantes ist von Zeile 432-632.
Bitte Verbesserungsvorschläge direkt in Code-Form angeben.

Hier der vielleicht etwas unübersichtliche Code. ^^

package sortierprojekt;

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import javax.swing.*;
import java.net.MalformedURLException;
import java.net.URL;


public class Sortierprojekt {
     
    public static int Arraygroeße=10000;
    public static int Zahlenwerte=99;
    public static JFrame Sortierfenster;
    public static JPanel panelButton;
    public static JLabel anzeige;
    public static JTextField Textfeld; 
    public static int Musicplayer=0;
    
    public static int [] Arraysortierer= new int [Arraygroeße];   
    public static int [] Insertionsortierer= new int [Arraygroeße];
    public static int [] Bubblesortierer= new int [Arraygroeße];
    public static int [] Selectionsortierer= new int [Arraygroeße];
    public static int [] Shakersortierer= new int [Arraygroeße];
    public static int [] Shellsortierer= new int [Arraygroeße];
    public static int [] Simplesortierer= new int [Arraygroeße];
    public static int [] Gnomesortierer= new int [Arraygroeße];
    public static int [] Countingsortierer= new int [Arraygroeße];
    public static int [] Pigeonholesortierer= new int [Arraygroeße];
    public static Integer [] array = new Integer[Arraygroeße];
    
    
static void Optionen () {
    
                JTextField ag = new JTextField();
                JTextField zw = new JTextField();

                Object[] message = {"Arraygröße:", ag, 
                        "Zahlenwerte:", zw};
 
                JOptionPane pane = new JOptionPane( message, 
                                                JOptionPane.PLAIN_MESSAGE, 
                                                JOptionPane.OK_CANCEL_OPTION);
                pane.createDialog(null, "Einstellungen").setVisible(true);
                
                
                Arraygroeße = Integer.parseInt(ag.getText());
                Zahlenwerte = Integer.parseInt(zw.getText());
                
     Sortierprojekt.main(null);
     
}

static void Arraysort () {
    
            for (int q=0; q<Arraygroeße; q++){
            Arraysortierer [q] = (int) (Math.random()*Zahlenwerte);}

            Long start2 = System.nanoTime();
            
            Arrays.sort(Arraysortierer);
            Arrayausgabe(Arraysortierer);


    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start2));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start2)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start2)/1000000));


}   
static void Insertionsort () {
    


            for (int q=0; q<Arraygroeße; q++){
            Insertionsortierer [q] = (int) (Math.random()*Zahlenwerte);}
            
            
            Long start4 = System.nanoTime();
            
        
            int i, j, k;
            for (i=1; i<Insertionsortierer.length; i++) {
            k = Insertionsortierer[i];
            j=i;
            while (j>0 && Insertionsortierer[j-1] > k) {
                  Insertionsortierer[j] = Insertionsortierer[j-1];
                  j--;}
            Insertionsortierer[j] = k;}
            
      
            Arrayausgabe(Insertionsortierer);
            
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start4));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start4)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start4)/1000000));


}          
static void Bubblesort () {
    

            for (int q=0; q<Arraygroeße; q++){
            Bubblesortierer [q] = (int) (Math.random()*Zahlenwerte);}

        
            Long start3 = System.nanoTime();
            
            
            for (int j=Bubblesortierer.length-1; j>0; j--){
                for (int i=0; i<j; i++){
                    if (Bubblesortierer[i]>Bubblesortierer[i+1]){
                        int temp=Bubblesortierer[i];
                        Bubblesortierer[i]=Bubblesortierer[i+1];
                        Bubblesortierer[i+1]=temp;
                    }
                }
            }
            
            Arrayausgabe(Bubblesortierer);

            
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start3));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start3)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start3)/1000000));

    
}
static void Selectionsort () {
    

            for (int q=0; q<Arraygroeße; q++){
            Selectionsortierer [q] = (int) (Math.random()*Zahlenwerte);}
            
            Long start5 = System.nanoTime();
            
            for(int a=0; a<Selectionsortierer.length-1; a++)
            {
                int tmp=Selectionsortierer[a];
                int b=a;
                for(int x=a+1; x<Selectionsortierer.length; x++)
                {
                    if(Selectionsortierer[x]<Selectionsortierer[b])
                    {
                        b=x;
                    }
                }
                Selectionsortierer[a]=Selectionsortierer[b];
                Selectionsortierer[b]=tmp;
                
            }
            
            
            Arrayausgabe(Selectionsortierer);
            
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start5));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start5)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start5)/1000000));

    
}
static void Shakersort () {


            for (int q=0; q<Arraygroeße; q++){
            Shakersortierer [q] = (int) (Math.random()*Zahlenwerte);}

        
            Long start6 = System.nanoTime();
            
                boolean a = false;
                boolean b = true;
                int start = 0;
                int end = Shakersortierer.length-1;
                int x; // Hilfsvariabel zum tauschen
                while (start<end && !a)
                {
                    a = true;
                    if (b)
                    {
                        for (int i=start; i<end; i++)
                        {
                            if (Shakersortierer[i] > Shakersortierer[i+1])
                            {
                                x = Shakersortierer[i];
                                Shakersortierer[i] = Shakersortierer[i+1];
                                Shakersortierer[i+1] = x;
                                a = false;
                            }
                        }
                        end--;
                   }       
                   else
                   {
                        for (int i=end; i>start; i--)
                        {
                            if (Shakersortierer[i] < Shakersortierer[i-1])
                            {
                                x = Shakersortierer[i];
                                Shakersortierer[i] = Shakersortierer[i-1];
                                Shakersortierer[i-1] = x;
                                a = false;
                            }
                        }
                   start++;
                   }
                b = !b;
                }
            
    Arrayausgabe(Shakersortierer);

            
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start6));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start6)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start6)/1000000));

    
}  
static void Shellsort() {
    

            for (int q=0; q<Arraygroeße; q++){
            Shellsortierer [q] = (int) (Math.random()*Zahlenwerte);}

            Long start7 = System.nanoTime();
    
    int sarray[]={9,5,3,1};
    
    for (int pass=0;pass<sarray.length;pass++) {
      
      int k=sarray[pass];
      int count = Shellsortierer.length / k;
      
      
      for (int d=0;d<k;d++) {
	
        
        for (int i=0;i<count-1;i++) {
          
          int j=d + i*k;
          
          int x=Shellsortierer[j+k];

          while (j>=0 && Shellsortierer[j]>=x) {
            Shellsortierer[j+k]=Shellsortierer[j];
            j-=k;
          }
          
          Shellsortierer[j+k]=x;
        }
      }
    } 
    Arrayausgabe(Shellsortierer);
            
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start7));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start7)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start7)/1000000));
    
    
  }
static void Simplesort(){


            for (int q=0; q<Arraygroeße; q++){
            Simplesortierer [q] = (int) (Math.random()*Zahlenwerte);}
    
            Long start8 = System.nanoTime();
            
            int k; 
            for (int i = Simplesortierer.length-1; i > 1; i--) { 
                for (int j = 0; j <= i - 1; j++) { 
                    if (Simplesortierer[j] >= Simplesortierer[i]) { 
                    k = Simplesortierer[i]; 
                    Simplesortierer[i] = Simplesortierer[j]; 
                    Simplesortierer[j] = k; 
                    }    
                } 
            } 
            
    Arrayausgabe(Simplesortierer);
    
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start8));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start8)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start8)/1000000));
    
    
}
static void Gnomesort() { 


            for (int q=0; q<Arraygroeße; q++){
            Gnomesortierer [q] = (int) (Math.random()*Zahlenwerte);}
            
            
            Long start9 = System.nanoTime();
            
            
            for ( int index = 1; index < Gnomesortierer.length; ) { 
                if ( Gnomesortierer[index - 1] <= Gnomesortierer[index] ) { 
                    ++index;}
          
                else { 
             
                    int tempVal = Gnomesortierer[index]; 
                    Gnomesortierer[index] = Gnomesortierer[index-1]; 
                    Gnomesortierer[index-1] = tempVal; 
                    --index; 
            
                    if ( index == 0 ) { 
                    index = 1;}        
                } 
                
            } 

            Arrayausgabe(Gnomesortierer);
    
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start9));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start9)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start9)/1000000));
      
} 
static void Countingsort(){


            for (int q=0; q<Arraygroeße; q++){
            Countingsortierer [q] = (int) (Math.random()*Zahlenwerte);}
            
    Long start10 = System.nanoTime();       
      
            
    int low= 0;
    int high= Countingsortierer.length;
    
    int[] counts = new int[high - low + 1];
    for (int x:Countingsortierer)
        {counts[x-low]++;}
 
    int current = 0;
    for (int i = 0; i < counts.length; i++)
        {
            Arrays.fill(Countingsortierer, current, current + counts[i], i + low);
            current += counts[i];
        }
     
    Arrayausgabe(Countingsortierer);
    
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start10));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start10)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start10)/1000000));

}
static void Pigeonholesort(){


            for (int q=0; q<Arraygroeße; q++){
            Pigeonholesortierer [q] = (int) (Math.random()*Zahlenwerte);}
            
    Long start11 = System.nanoTime();       

    int min = Pigeonholesortierer[0], max = Pigeonholesortierer[0];
    for (int x : Pigeonholesortierer) {
        min = Math.min(x, min);
        max = Math.max(x, max);
    }
    final int size = max - min + 1;
 
    // our array of pigeonholes
    int[] holes = new int[size];  
 
    // Populate the pigeonholes.
    for (int x : Pigeonholesortierer)
    {holes[x - min]++;}
 
    // Put the elements back into the array in order.
    int i = 0;
    for (int count = 0; count < size; count++)
    {while (holes[count]-- > 0){
            Pigeonholesortierer[i++] = count + min;}}
     
    Arrayausgabe(Pigeonholesortierer);
    
    System.out.println("Gebrauchte Zeit in Nanosekunden: "+(System.nanoTime()-start11));
    System.out.println("Gebrauchte Zeit in Mikrosekunden: "+((System.nanoTime()-start11)/1000));
    System.out.println("Gebrauchte Zeit in Millisekunden: "+((System.nanoTime()-start11)/1000000));

}

static void SoundausgabePling(){
        URL url = null;
        try {
                url = new URL("file:///F:/Informatik/Java/Pling.wav");
            } catch (MalformedURLException e) {
            e.printStackTrace();
            return;
        }
 

        AudioClip clip = Applet.newAudioClip(url);
 

        clip.play();
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       }
static void SoundausgabePacMan(){
        URL url = null;
        try {
                url = new URL("file:///F:/Informatik/Java/Pacman.wav");
            } catch (MalformedURLException e) {
            e.printStackTrace();
            return;
        }
 

        AudioClip clip = Applet.newAudioClip(url);
 

        clip.play();
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       }
static void Sortierfenster(){
    
    
        Sortierfenster = new JFrame();
        Sortierfenster.setLocation(600,600);
        Sortierfenster.setSize(500,500);
        Sortierfenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Sortierfenster.getContentPane().setBackground(Color.BLACK);
        
        

        JButton buttonarrsrt = new JButton("Arraysort");
        JButton buttoninsrt = new JButton("Insertionsort");
        JButton buttonbubsrt = new JButton("Bubblesort");
        JButton buttonslctsrt = new JButton("Selectionsort");
        JButton buttonshksrt = new JButton("Shakersort");
        JButton buttonshlsrt = new JButton("Shellsort");
        JButton buttonsmplsrt = new JButton("Simplesort");
        JButton buttongnmsrt = new JButton("Gnomesort");
        JButton buttoncntsrt = new JButton("Countingsort");
        JButton buttonpignsrt = new JButton("Pigeonholesort");
        JButton backtomenu = new JButton("Zurück zum Menü");
        JButton ende = new JButton("Ende");


        panelButton = new JPanel(new GridLayout(6,3));


        panelButton.add(buttonarrsrt);
        panelButton.add(buttoninsrt);
        panelButton.add(buttonbubsrt);
        panelButton.add(buttonslctsrt);
        panelButton.add(buttonshksrt);
        panelButton.add(buttonshlsrt);
        panelButton.add(buttonsmplsrt);
        panelButton.add(buttongnmsrt);
        panelButton.add(buttoncntsrt);
        panelButton.add(buttonpignsrt);
        panelButton.add(backtomenu);
        panelButton.add(ende);

        
        buttonarrsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Arraysort();
                Arrayfenster(Arraysortierer);
                
            }
        });
        
        buttoninsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Insertionsort();
                Arrayfenster(Insertionsortierer);
                
            }
        });

        buttonbubsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Bubblesort();
                Arrayfenster(Bubblesortierer);
                
            }
        });

        buttonslctsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Selectionsort();
                Arrayfenster(Selectionsortierer);
            }
        });

        buttonshksrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Shakersort();
                Arrayfenster(Shakersortierer);
            }
        });

        buttonshlsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Shellsort();
                Arrayfenster(Shellsortierer);
            }
        });

        buttonsmplsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Simplesort();
                Arrayfenster(Simplesortierer);
            }
        });

        buttongnmsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Gnomesort();
                Arrayfenster(Gnomesortierer);
            }
        });
 
        buttoncntsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Countingsort();
                Arrayfenster(Countingsortierer);
            }
        });

        buttonpignsrt.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                SoundausgabePling();
                Pigeonholesort();
                Arrayfenster(Pigeonholesortierer);
            }
        });

        backtomenu.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent ae)
            {
                Sortierprojekt.main(null);
            }
        });
        
        ende.addActionListener(new ActionListener() 
        { 
            public void actionPerformed(ActionEvent ae) 
            { 
                System.exit(0);
                
            }
        });
    
        
        Sortierfenster.getContentPane().add(BorderLayout.WEST, panelButton);

        Sortierfenster.pack();
        Sortierfenster.setVisible(true);

    }
    
static void Arrayfenster (int[] Array){

    

                final Integer[] array = new Integer[Array.length];
                    for (int ii=0; ii<Array.length; ii++) {
                       array[ii] = Array[ii];
                    }
                    
                SwingUtilities.invokeLater(new Runnable(){
                    @Override
                    public void run() {

                            JDialog arrfenster = new JDialog();
                            arrfenster.setTitle("Arrayausgabe");
                            arrfenster.setSize(200,300);

                            JPanel panel = new JPanel();

                            panel.add(new JList(array));
                          
                            JScrollPane scrollPane = new JScrollPane (panel, 
                            ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
                            ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
                            arrfenster.add(scrollPane);
                            arrfenster.setVisible(true);
                            
               }
               });

}
static void Arrayausgabe(int[] array) { 
    for (int i = 0; i < array.length; i++) { 
      System.out.println(array[i]); 
    } 
  } 


public static void main(String[] args) {
   

   if(Musicplayer==0){          //Damit nur 1 Mal die Musik ertönt
   SoundausgabePacMan();
   Musicplayer++;}
    
   Object[] start = {"Start", "Einstellungen"};
   int Startfenster = JOptionPane.showOptionDialog(null, "Willkommen bei meinem Sortierprojekt!",  
                                                    "Sortierprojekt",               
                                                    JOptionPane.DEFAULT_OPTION,        
                                                    JOptionPane.PLAIN_MESSAGE,    
                                                    null, start, null);
   
   
   switch(Startfenster){
    
       case 0:      //Start
       Sortierfenster();
       break;
        
       case 1:      //Einstellungen
       Optionen();
       break;
       
           
    }
}
}

Danke und LG,
Nick

 

[jsdkjasdajs]

Also, ersteinmal. Wieso sind alle Klassen static? Du weißt schon das Java OOP ist?

Static sollte man eigentlich so wenig wie möglich benutzen bzw. braucht man in den meisten fällen gar nicht. Es schaut so aus als hättest du das Objekte / Klassensystem noch nicht ganz verstanden.


Außerdem könntest du auch versuchen deine Logik von deiner Frame zu teilen so hast nicht eine "god-Klasse" vertraue mir ich hab auch mal so angefangen. Als dann die 2000. Zeile erreicht war hatte ich keine Lust mehr irgendetwas zu machen, weil ich nicht mehr wusste wo was steht.

Hier eine kleine Hilfe:
(Falls du es perfekt machen möchtest Stichwort MVC (Model-View-Controller)

public class UserInterface{
private Controller controller = new Controller(); 

//Hier steht deine komplette GUI mit alle Feldern Buttons etc. 

}

public class Controller{

/*Hier würde dein Array drinne stehen bzw. Variablen und die Logik der Gui, also KlickListener, Main Methode etc. Als anfänger ein MVC zu verwenden würde ich von abraten, da dies recht schnell sehr kompliziert werden kann */



}

Ich hoffe ich konnte helfen.

 

[Nickelodius]

Okay, erst einmal danke für deine Antwort. ^^
Ich versuche dann mal, mein Programm etwas "benutzerfreundlicher", d.h. übersichtlicher zu gestalten.
Wie gesagt, ich hatte noch nicht so lange Informatik, und bin noch ziemlicher Anfänger in Sachen Programmierung.
Deine Vorschläge werd ich sofort einbauen.

Danke für die Hilfe,
Nick