Objekte, bspw. konkret Arraylists,manuell aus Speicher löschen?

B

berndoa

Bekanntes Mitglied
Hallo, da mein Programm/Programme schon ziemlich speicherverbrauchend sind da ich für alles Mögliche dauernd Objekte (verschachtelte Arraylists und Dergleichen) in abartiger Mengenanzahl anlege und mir das den ein oder anderen Outofmemory Error beschert, wollte ich mal wissen ob man bei java irgendwie auch direkt ein Objekt wieder entfernen kann von dem ich genau weiß dass es seinen Zweck erfüllt hat und das ich nie wieder brauche?

Gibts da irgendwie einen befehl um das zu löschen oder so?

Ich weiß zwar dass Java einen Garbage Collector hat der irgendwann Sachen löscht.
Aber meine noch definierten aber nciht mehr benutzten Sachen scheint er nicht bei Zeiten zu löschen, weshalb der Speicher da zu voll wird.

Kann man da auch manuell erstellte Objektgebilde wieder löschen?


habe da bspw. eine 17700 ELemente lange Arraylist, deren Elemente wieder arraylists von arraylists von Long Elementen sind.

Die ich einmalig brauche um daraus eine ebenso monströses neues Arraylistwesen zu erschaffen.
Aber danahc kann das m Prinzip inklusive aller inenren Arralyisten und so beseitigt werden.
 
J

Joreyk

Bekanntes Mitglied
ganz einfach wenn niemand mehr auf das Objekt deutet wird das Objekt vom garbage collector gelöscht
 
F

fhoffmann

Top Contributor
Man weiß zwar nicht, wann der Garbage Colloctor arbeitet, es ist jedoch garantiert, dass er versucht alles, was geht, wegzuschmeißen, bevor ein OutOfmemory-Error geworfen wird.
Möglicherweise ist deine ArrayList noch irgendwie in deinem Programm zugreifbar.

EDIT: Du kannst deine ArrayList, die noch zugreifbar ist aber nicht mehr benötigt wird, auf null setzen.
 
J

Joreyk

Bekanntes Mitglied
arrayGroß = superGroßesArray

arrayGroß = null

wenn dann kein Objekt mehr auf superGroses Array mehr deutet wirds vom gc geschreddert... der arbeitet halt nicht immer sofort aber "versucht sein bestes" :D
 
J

Joreyk

Bekanntes Mitglied
Was willst du damit aussagen? Von Hand auf null setzen sollte fast nie nötig sein, wenn man die Variablen richtig scoped
"falls man"

anscheinend wurde das nicht getan ansonsten würde das problem nicht auftauchen bzw es ist nicht möglich in seinem fall was in den Sternen steht was da so passiert
 
B

berndoa

Bekanntes Mitglied
Ich weiß auch nicht warum das eigentlich Alles so lange braucht und so viel Speicher frisst.

Die Programme sind vermutlich viel zu wuchtig und umständlich und ausser mir blickt da keiner mehr durch :-/
 
F

fhoffmann

Top Contributor
habe da bspw. eine 17700 ELemente lange Arraylist, deren Elemente wieder arraylists von arraylists von Long Elementen sind.
Das hört sich aus unterschiedlichen Gründen sehr komisch an:

1. Eine "ArrayList von ArrayList von ArrayList von Long" sollte durch sinnvolle Objekte (oder eine ArrayList von sinnvollen Objekten) oder alternativ durch ein long[][][] ersetzt werden. (Ein long benötigt deutlich weniger Speicher als ein Long.)

2. Woher kommen die 17700 ELemente? Liest du sie aus einer Datei ein? Musst du sie wirklich alle im Arbeitsspeicher halten? Viele Algorithmen lassen sich so umschreiben, dass man immer nur einen Wert verarbeiten (und ihn dann wieder löschen) kann.

3. Und - wie gesagt - du solltest deinen Code sauber (verständlich) schreiben!

4. Und bitte - das ist hier nun ein Verdacht - kein static benutzen.
 
B

berndoa

Bekanntes Mitglied
Und wenn du dir dein eigenes Programm in ein paar Wochen wieder anguckst, wirst du selber auch nicht mehr durchblicken.
Mach es heute ordentlich!
Ich wüsste nur nicht wie ich es besser machen könnte ohne die Grundstruktur zu verändern oder ganz andere Datentypen zu verwenden.

Zum Einen habe ich die Klasse Test9:

Test9 Klasse:
import java.util.*;

//fertiges Optimierungsprogramm für gegebene 6Tupel Menge!

public class Test9{
    
    static int k=6; //anzahl zahlen pro getipptem feld
    static int n=49; //menge an verfügbaren zahlen   
    static int max=27;
    /*------------------------------------------------------------------------------------------------------------------------------------
    --Erzeugt sixtuples arraylist mit funktion und input aus der eingabe. optimiert eingabe bis keine weitere optimierung mehr möglich ist-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    public static void main(String[] args){/*
    ArrayList<ArrayList<Long>> sixtuples=sixtuples();
      ArrayList<ArrayList<Long>> input=sixtuples();
        //zeile 16 zu ändern auf realen input
        
        
//Lese input mittels eines Scanners ein:

      
        
        while(optimize(sixtuples,input)>0){
            System.out.println("Optimiert! Das neue System hat noch "+input.size()+" Tippreihen!");
        }
        
        System.out.println("Fertig! Das perfekte System hat "+input.size()+" Tippreihen!!");
        
        System.out.println("Das perfekte System lautet :");
        System.out.println();
        
        for(ArrayList<Long> stuple: input){
            for(Long a: stuple){
                System.out.print(a+" ");
            }
            System.out.println();
        }
    */
    }
    
    public static void createperfectlist(ArrayList<ArrayList<Long>> A,ArrayList<ArrayList<Long>> B){
    ArrayList<ArrayList<Long>> sixtuples=B;
      ArrayList<ArrayList<Long>> input=A;
      
        
//        while(optimize(sixtuples,input)>0){
            if(optimize(sixtuples,input)>0){
                System.out.println("Optimiert! Das neue System hat noch "+input.size()+" Tippreihen!");
            }
            else{System.out.println("Konnte nicht optimiert werden.");}

//        }
        
        System.out.println("Fertig! Das perfekte System hat "+input.size()+" Tippreihen!!");
        
        System.out.println("Das perfekte System lautet :");
        System.out.println();
        
        for(ArrayList<Long> stuple: input){
            for(Long a: stuple){
                System.out.print(a+" ");
            }
            System.out.println();
        }
            
    }
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    --testet alle Reihen des input arraylist durch bis eine gefunden wird die sicher entfernt werden kann. falls erfolgreich, gib 1 zurück. ansosnten 0.-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    public static long optimize(ArrayList<ArrayList<Long>> sixtuples,ArrayList<ArrayList<Long>> input){
        
        for(long ignoreindex=0;ignoreindex<input.size();ignoreindex++){
            long n=calculatewithoutj(sixtuples,input,ignoreindex);
            System.out.println("Nach calcwithoutj mit ignoreindex= "+ignoreindex);
            //falls weglassen von jter zeile noch mind. 3 richtige liefert
            if(n>=3){
                input=copywithoutj(input,ignoreindex);
                return 1;
            }
        }
        return 0;
        
    }
    
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    --Erzeugt eine deep copy des verschachtelten Arraylist Gebildes, wobei aber das j'te Element der äussersten Arraylist weggelassen wird-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    public static ArrayList<ArrayList<Long>> copywithoutj (ArrayList<ArrayList<Long>> Array, long j){
        //Sei Array das alte arraylistgebilde
        ArrayList<ArrayList<Long>> copy = new ArrayList<ArrayList<Long>>();

        for (int i=0;i<copy.size();i++) {
            if(i!=j){
                ArrayList<Long> copyi = new ArrayList<Long>();
                for (long Arrayii : Array.get(i)) {
                    Long a=new Long(Arrayii);
                    copyi.add(a);
                }
                copy.add(copyi);
            }
        }
        //copy hat nun die selben inhalte wie array und das ohne referenzen
        return copy;
    }
    
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    -------Diverse Funktionen zum Erzeugen von deep copys von 3, 2 oder 1fach geschachtelter arraylists. kommen aber fast nie zum Einsatz.-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    
    
    
    public static ArrayList<ArrayList<ArrayList<Long>>> copy3 (ArrayList<ArrayList<ArrayList<Long>>> Array){
        //Sei Array das alte arraylistgebilde
        ArrayList<ArrayList<ArrayList<Long>>> copy = new ArrayList<ArrayList<ArrayList<Long>>>();

        for (ArrayList<ArrayList<Long>> Arrayi : Array) {
            ArrayList<ArrayList<Long>> copyi = copy2(Arrayi);
            copy.add(copyi);
        }
        //copy hat nun die selben inhalte wie array und das ohne referenzen
        return copy;
    }
    
    public static ArrayList<ArrayList<Long>> copy2 (ArrayList<ArrayList<Long>> Array){
        //Sei Array das alte arraylistgebilde
        ArrayList<ArrayList<Long>> copy = new ArrayList<ArrayList<Long>>();

        for (ArrayList<Long> Arrayi : Array) {
            ArrayList<Long> copyi = copy1(Arrayi);
            copy.add(copyi);
        }
        //copy hat nun die selben inhalte wie array und das ohne referenzen
        return copy;
    }
    
    public static ArrayList<Long> copy1 (ArrayList<Long> Array){
        //Sei Array das alte arraylistgebilde
        ArrayList<Long> copy = new ArrayList<Long>();
        for (long Arrayi : Array) {
                Long a=new Long(Arrayi);
                copy.add(a);
        }
        //copy hat nun die selben inhalte wie array und das ohne referenzen
        return copy;
    }

    
    
    
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    -----Keine kurze Erklärung verfügbar. findet die geringstmögliche Anzahl an Richtigen, unabhängig davon welche lottozahlen gezogen werden.
    ----------------------------die j'te Zeile des Inputs wird hierbei übersprungen----------------------------------------------------------------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    
    public static long calculatewithoutj(ArrayList<ArrayList<Long>> sixtuples, ArrayList<ArrayList<Long>> input, long ignoreindex){
      //anzahl richtige für jedes tupel in input finden   
        long minimum=999999999;
      for(ArrayList<Long> sixtuple:sixtuples){
            long maximum=0;
            //setze maximum gleich dem maximum, also den größtmöglichen richtigen die mit irgendeiner inputreihe getroffen werden
            for(long inputindex=0;inputindex<input.size();inputindex++){
                if(inputindex!=ignoreindex){
                    long inttemp=equalnum(sixtuple,input.get((int)inputindex));
                    if(inttemp>maximum){
                        maximum=inttemp;
                    }
                }
            }
            //hier ist nun maximum bestimmt, Abgleich ob kleiner als das bisherige minimum
            if(minimum>maximum){
                minimum=maximum;
            }
        }
      
        return minimum;
    }
    
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    -------Simple Funktion zum Finden des Minimums in einer Arraylist-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    
    public static long getmin(ArrayList<Long> array){
        long n=array.get(0);;
        for (long zahl:array){
            if(zahl<n){
                n=zahl;
            }
        }
        return n;
    }
    
    
    /*------------------------------------------------------------------------------------------------------------------------------------
    -------Findet durch parallelen Durchlauf durch die 2 Arraylists die Anzahl an Elementen, die in beiden Arraylists vorkommen-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
    
            
    public static long equalnum(ArrayList<Long> a, ArrayList<Long> b){
        int indexa=0;
        int indexb=0;
        long count=0;
        
        while((indexa<a.size())&&(indexb<b.size())){
            if(a.get(indexa)==b.get(indexb)){count++;indexa++;indexb++;}
            else{
                if(a.get(indexa)<b.get(indexb)){indexa++;}
                else{
                    if(a.get(indexa)>b.get(indexb)){indexb++;}
                }
            }
        }
        
        return count;
    }
    
        
    public static long equalnum(long[] a, ArrayList<Long> b){
        int indexa=0;
        int indexb=0;
        long count=0;
        
        while((indexa<a.length)&(indexb<b.size())){
            if(a[indexa]==b.get(indexb)){count++;indexa++;indexb++;}
            else{
                if(a[indexa]<b.get(indexb)){indexa++;}
                else{
                    if(a[indexa]>b.get(indexb)){indexb++;
                    }
                }
            }
        }
        return count;
    }


    
    
    /*-----------------------------------------------------------------------------------------------------------
    -------Ab hier aktuelle Version der Funktion zum Bilden der sixtuples und hierzu nötiger Funktionen-----------
    -------------------------------------------------------------------------------------------------------------*/
    
    
    public static ArrayList<ArrayList<Long>> sixtuples(){

        

        long mini=1;
        long maxi=n;

        
        ArrayList<ArrayList<Long>> sixtuples=new ArrayList<ArrayList<Long>> ();
        
        //setze array=mini={1,2,3,4,5,6} zu Beginn   
        long[] array=new long[k];
        for(long i=0;i<array.length;i++){
            array[(int)i]=mini+i;
        }
        adding(sixtuples,array);
        
        //erhöhe array um 1 im rahmen der randbedingungen, solange wie möglich, und füge jeweils zu sixtuples hinzu
        while(increasing(array,max)){
            adding(sixtuples,array);
        }
        
        return sixtuples;
            
    }
    
    //fügt eine neue Reihe in sixtuples mit den Zahlen aus array hinzu
    public static void adding(ArrayList<ArrayList<Long>> sixtuples, long[] array){
        ArrayList<Long> line=new ArrayList<Long>();
        for(long a:array){
            line.add(a);
        }
        sixtuples.add(line);
    }
    

    //unabhängig von Länge
    //erhöht array um 1, unter beachtung der Randbedingungen
    public static boolean increasing(long[] array,long max){
        //beispiel: array={0,1,2}, array.length=3, index=3, max=6
        int index=array.length-1;
        //6-3+1 +index=4+index ={4,5,6}
        while((index>=0)&&(array[index]==(max-array.length+1+index))){
            index--;
        }
        if(index<0){return false;}
        
        array[index]++;
        
        for (int i=1;index+i<array.length;i++){
            array[index+i]=array[index]+i;
        }
        
        return true;
    }
    
    //erzeugt deep copy eines long arrays und gibt sie zurück
    public static long[] copyarray(long[] array){
        long[] copy=new long[array.length];
        for(int i=0;i<array.length;i++){
            copy[i]=array[i];
        }
        return copy;
    }
    
    
    
    /*----------------------------------------------------------------------------
    ---------Alte Version der Funktion zum Bilden der sixtuples-------------------
    ------------------------------------------------------------------------------*/
    
    /*
    public static ArrayList<ArrayList<Long>> sixtuples(){
        ArrayList<ArrayList<Long>> sixtuples=new ArrayList<ArrayList<Long>>();
        
        for(long a=1;a<=n;a++){
            for(long b=1;b<=n;b++){
                for(long c=1;c<=n;c++){
                    for(long d=1;d<=n;d++){
                        for(long e=1;e<=n;e++){
                            for(long f=1;f<=n;f++){
                                if((a<b)&(b<c)&(c<d)&(d<e)&(e<f)){
                                    ArrayList<Long> temp=new ArrayList<Long>();
                                    temp.add(a);
                                    temp.add(b);
                                    temp.add(c);
                                    temp.add(d);
                                    temp.add(e);
                                    temp.add(f);
                                    sixtuples.add(temp);
                                }
                            }
                        }
                    }
                }
            }
        }
        return sixtuples;
    }
    
    */
    
    
}

Zum Anderen die Test10 Klasse:


Java:
import java.util.*;

//wähle tippfelder mit 6 aus 27 zahlen, gezogen werden aber 4 gewinnzahlen


public class Test10{
    
    
    static int k=6; //anzahl zahlen pro getipptem feld
    static int n=27; //menge an verfügbaren zahlen, zahlen gehen dann von 1 bis n
    
    
  public static void main (String[] args){
        
        ArrayList<ArrayList<Long>> list4tuples=new ArrayList<ArrayList<Long>>();
        ArrayList<ArrayList<ArrayList<Long>>> list4tuplestriples=new ArrayList<ArrayList<ArrayList<Long>>>();
        ArrayList<ArrayList<Long>> listtriples=new ArrayList<ArrayList<Long>>();
    ArrayList<ArrayList<Long>> list6tuples = new ArrayList<ArrayList<Long>>();
        
        list4tuples=Tuples(1,n,4);
        System.out.println("Länge von list4tuples: "+list4tuples.size());
        
        list4tuplestriples=findtriples(list4tuples);
        System.out.println("Länge von list4tuplestriples: "+list4tuplestriples.size());
        
        listtriples=choosetriples(list4tuplestriples);
        System.out.println("Länge von listtriples: "+listtriples.size());
        
        list6tuples=find6tuples(listtriples);
        System.out.println("Länge von list6tuples: "+list6tuples.size());
        
        System.out.println("did create stuff so far");
//        printlist(list6tuples);
        
        Test9.createperfectlist(list6tuples,list4tuples);
    }

public static void printlist(ArrayList<ArrayList<Long>> list6tuples){
    for(ArrayList<Long> stuple: list6tuples){
        for(Long a: stuple){
            System.out.print(a+".");
        }
        System.out.println();
    }
}
    
//maht aus Long arraylist ein long[] Array
    public static long[] tolongarray(ArrayList<Long> list){
        long[] result=new long[list.size()];
        for(int i=0;i<list.size();i++){
            result[i]=(long)list.get(i);
        }
        return result;
    }

//fügt triples aus liste in 6tupel-liste platzsparend ein   
    public static ArrayList<ArrayList<Long>> find6tuples(ArrayList<ArrayList<Long>> listtriples){
        ArrayList<ArrayList<Long>> list6tuples = new ArrayList<ArrayList<Long>>();
    list6tuples.add(new ArrayList<Long>(k));
    
    
    for(ArrayList<Long> triple:listtriples){   
        einfuegen(tolongarray(triple),list6tuples);
        }
        return list6tuples;
    }
    
 //fügt triple in der zeile von list6tuples ein wo es am besten passt. falls nix passende, füge es in einer neuen zeile ein
  public static void einfuegen(long[] triple, ArrayList<ArrayList<Long>> list6tuples){
        long bestpos=-1;
        long minnum=99999;
        for (int i=0;i<list6tuples.size();i++){
            long eqn=equalnum(triple,list6tuples.get(i));
            long q=triple.length+list6tuples.get(i).size()-eqn;
            if((q<=6)&(eqn<minnum)){
                bestpos=i;
                minnum=eqn;
            }
        }
        if(bestpos!=-1){
            einfuege(triple,list6tuples.get((int)bestpos));
            return;
        }
        
        
        //if not possible to insert in existing 6tuples, create new 6tuple
        ArrayList<Long> temp2=new ArrayList<Long>(3);
        for (int i=0;i<3;i++){
            temp2.add(triple[i]);
        }
        list6tuples.add(temp2);
        
  }
    
//fügt tripel in gegebener Zeile ein
  public static boolean einfuege(long[] triple, ArrayList<Long> stuple){
      //new arraylist with elements of stuple
        ArrayList<Long> temp=new ArrayList<Long>(k+3);
      temp.clear();
      for (long a:stuple){
          temp.add(a);
      }
      
      
      //adds elements that are in triple but not yet in stuple
      for(int i=0;i<triple.length;i++){
          if(!temp.contains(triple[i])){
              temp.add(triple[i]);
          }
      }
      //copying content of temp to stuple, thereby overwriting it
      if(temp.size()<=k){
      stuple.clear();
            for(long a: temp){
                stuple.add(a);
            }
            stuple.sort((a, b) -> Long.compare(a, b));
      return true;       
      }
      return false;
  }

//wählt nach hochwissenschaftlichen Methoden je zeile eins der vorhandenen tripel aus, das behalten wird   
    public static ArrayList<ArrayList<Long>> choosetriples(ArrayList<ArrayList<ArrayList<Long>>> list4tupletriples){
        ArrayList<ArrayList<Long>> result=new ArrayList<ArrayList<Long>>();
        result.add(list4tupletriples.get(0).get(0));
        
        for(ArrayList<ArrayList<Long>> triplelist: list4tupletriples){
            int[] array=new int[triplelist.size()];           
            for(int j=0;j<triplelist.size();j++){
                array[j]=maxequals(result,triplelist.get(j));
            }
            
            int index=getmaxindex(array);
            
            if(array[index]<triplelist.get(0).size()){
                result.add(triplelist.get(index));
            }
        }
        return result;
    }
    
//maximale anzahl an gleichen elementen mit irgendeiner der zeilen   
    public static int maxequals(ArrayList<ArrayList<Long>> result, ArrayList<Long> temp){
        int max=0;
        for(int i=0;i<result.size();i++){
            int a=(int)equalnum(result.get(i),temp);
            if(a>max){
                max=a;
            }
        }
        return max;
    }
        
    /*------------------------------------------------------------------------------------------------------------------------------------
    -------Simple Funktion zum Finden des Maximumsindex in einem Array-----------
    ------------------------------------------------------------------------------------------------------------------------------------*/
    
//index des maximalen elements, duh   
    public static int getmaxindex(int[] array){
        int maxindex=0;
        for (int i=0;i<array.length;i++){
            if(array[maxindex]<array[i]){
                maxindex=i;
            }
        }
        return maxindex;
    }
    
//4tuples werden zu menge4 aus 3tupeln   
    public static ArrayList<ArrayList<ArrayList<Long>>> findtriples(ArrayList<ArrayList<Long>>  list4tuples){
        ArrayList<ArrayList<ArrayList<Long>>> result= new ArrayList<ArrayList<ArrayList<Long>>>();
        
        for (ArrayList<Long> a4tuple:list4tuples){
            ArrayList<ArrayList<Long>> temp=pTupleZuqTuples(a4tuple,3);
            result.add(temp);
        }
        return result;
    }
    
    
    //turns a p-tuple into a list of q-tuples containg it's elements
    public static ArrayList<ArrayList<Long>> pTupleZuqTuples(ArrayList<Long> pTuple, long q){
        long max=pTuple.size();
        //vorkommende indizes gehen von 1 bis p, indizearray ist q lang
        ArrayList<ArrayList<Long>> result=new ArrayList<ArrayList<Long>>();
        
        
        long[] indizes=new long[(int)q];
        for(long i=0;i<q;i++){
            indizes[(int)i]=i;
        }
        //startindizearray ist {0,1,2...,q-1}
        
        ArrayList<Long> temp=new ArrayList<Long>();
        for(long i:indizes){
            temp.add(pTuple.get((int)i));
        }
        result.add(temp);
        
        
        //erhöhe array um 1 im rahmen der randbedingungen, solange wie möglich, und füge jeweils zu sixtuples hinzu
        while(increasing(indizes,max-1)){
            temp=new ArrayList<Long>();
            for(long i:indizes){
                temp.add(pTuple.get((int)i));
            }
            result.add(temp);
        }
        
        return result;
            
    }
    
    
    /*-----------------------------------------------------------------------------------------------------------
    -------Ab hier findet Anzahl an gleichen Elementen-----------
    -------------------------------------------------------------------------------------------------------------*/
            
    public static long equalnum(ArrayList<Long> a, ArrayList<Long> b){
        int indexa=0;
        int indexb=0;
        long count=0;
        
        while((indexa<a.size())&&(indexb<b.size())){
            if(a.get(indexa)==b.get(indexb)){count++;indexa++;indexb++;}
            else{
                if(a.get(indexa)<b.get(indexb)){indexa++;}
                else{
                    if(a.get(indexa)>b.get(indexb)){indexb++;}
                }
            }
        }
        
        return count;
    }
    
        
    public static long equalnum(long[] a, ArrayList<Long> b){
        int indexa=0;
        int indexb=0;
        long count=0;
        
        while((indexa<a.length)&(indexb<b.size())){
            if(a[indexa]==b.get(indexb)){count++;indexa++;indexb++;}
            else{
                if(a[indexa]<b.get(indexb)){indexa++;}
                else{
                    if(a[indexa]>b.get(indexb)){indexb++;
                    }
                }
            }
        }
        return count;
    }
    
      
    
    /*-----------------------------------------------------------------------------------------------------------
    -------Ab hier aktuelle Version der Funktion zum Bilden der Tuples gegebener Länge und Zahlenbereichs-----------
    -------------------------------------------------------------------------------------------------------------*/
    
    //Bildet Liste mit allen möglichen Tupeln einer gegebenen länge aus einem gegebenen Zahlenbereich
    public static ArrayList<ArrayList<Long>> Tuples(long min, long max, long laenge){

        

        long mini=min;
        long maxi=max;

        
        ArrayList<ArrayList<Long>> sixtuples=new ArrayList<ArrayList<Long>> ();
        
        //setze array=mini={1,2,3,4,5,6} zu Beginn   
        long[] array=new long[(int)laenge];
        for(long i=0;i<array.length;i++){
            array[(int)i]=mini+i;
        }
        adding(sixtuples,array);
        
        //erhöhe array um 1 im rahmen der randbedingungen, solange wie möglich, und füge jeweils zu sixtuples hinzu
        while(increasing(array,max)){
            adding(sixtuples,array);
        }
        
        return sixtuples;
            
    }
    
    //Trotz des Namens unabhängig von Länge
    //fügt eine neue Reihe in sixtuples mit den Zahlen aus array hinzu
    public static void adding(ArrayList<ArrayList<Long>> sixtuples, long[] array){
        ArrayList<Long> line=new ArrayList<Long>();
        for(long a:array){
            line.add(a);
        }
        sixtuples.add(line);
    }
    
    
    
    //unabhängig von Länge
    //erhöht array um 1, unter beachtung der Randbedingungen
    public static boolean increasing(long[] array,long max){
        //beispiel: array={0,1,2}, array.length=3, index=3, max=6
        int index=array.length-1;
        //6-3+1 +index=4+index ={4,5,6}
        while((index>=0)&&(array[index]==(max-array.length+1+index))){
            index--;
        }
        if(index<0){return false;}
        
        array[index]++;
        
        for (int i=1;index+i<array.length;i++){
            array[index+i]=array[index]+i;
        }
        
        return true;
    }
    
    //unabhängig von Länge
    //erzeugt deep copy eines long arrays und gibt sie zurück
    public static long[] copyarray(long[] array){
        long[] copy=new long[array.length];
        for(int i=0;i<array.length;i++){
            copy[i]=array[i];
        }
        return copy;
    }
    
 
 
}



Gehen tuts mir, aktuell, drum dass ich Lotto 4aus27 spiele, (möglichst wenig) Tippreihen mit je 6 Zahlen spielen will dergestalt dass ich aber in jedem Fall 3 Richtige habe, egal welche 4 Zahlen gezogen werden.

Bei all meinem Kram fasse ich bspw. ein Lottofeld mit 6 zahlen strukturtechnisch als Arraylist<Long> , eben mit .size()=6 auf.

und wenn ich bspw. alle möglichen lottozahlen, die gezogen werden können, haben will, dann brauche ich eine äussere Arraylist mit 27*26*25*24/(4*3*2*1)=17550 Elementen.
Wobei eben jedes "Element" wieder eine Kombination aus 4 zahlen ist, aka ein ArrayList<Long>.

Daher ist das Gebilde insgesamt ein ArrayList<ArrayList<Long>>.

in meinem Test10 Programm bauer ich anfangs eben jene Liste an 4zahlen-kombinationen.

dann wandle ich jede 4zahlen kombi um in die Menge ihrer 3-elementigen Untermengen.
bspw. wird aus (1,2,3,4) eben ((1,2,3)(1,2,4)(1,3,4)(2,3,4)).
programmertechnisch wird jede Arraylist<Long> in eine Arraylist<Arraylist<Long>> umgewandelt.

insgesamt haben wir dann eine liste aus 3tupel-listen, ein Arraylist<Arraylist<Arraylist<Long>>>.

im nächsten schritt gehe ich hin und schmeiße 3 der 4 tripel aus jeder reihe raus.
sodass "nur" eine lsite aus tripeln verbleibt.

Die nehme ich nun wieder und füge sie nach einem ganz geheimen vorgehen in eine, möglichst kurze, liste aus 6tupeln ein.
hierbei mache ich mir zunutze dass man ja bis zu 20 tripel in ein 6tupel packen kann
(schließlich lassen sich mit den zahlen 1,2,3,4,5,6 bspw. 20 verschiedene tripel bauen. ich versuche das selbe in die andere richtung, um also so viele tripel wie möglich in ein 6tupel zu packen und so nicht unnötig weitere 6tupel anfangen zu müssen).

das ist so grob was das test10 programm macht. natürlich mit 20 untermethoden, die arrays kopieren, array lists kopieren, irgendwelche vergleiche machen welches tripel man am besten behält, etc.

das test9 programm hingegen dient sozusagen der "optimierung" einer gegebenen 5tupel lsite, programmietechnisch einer 4fach geschachtelten arraylist wie oben.

konkret gebe ich so eine 6tupel arraylist als input rein, die wird mit der liste aller denkbaren gewinnzahlen (ebenfalls vorgegeben)vergleichen.
und geguckt welches 6tupel man konkret einfach weglassen könnte sodass unabhängig von den gezogenen gewinnzahlen immer noch mind. 3 richtige gezogen werden.

das finde ich durch stupides ausprobieren raus:
bilde input liste ohne das erste 6tupel. nimm die gewinnzahlenliste und gucke für jede der möglichen gewinnzahlen, wenn die gezogen werden würde, was die höchste zahl an übereinstimmenden ziffern mit der verkürzten inputlsite ist.

dabei mit im kopf behaltend was die geringste übereinstimmjungszahl war, die mit irgendeiner der Gewinnzhalen vorkam.
diese zahl muss >=3 sein sonst ist unser kriterium nicht mehr erfüllt und die in diesem durch index=0'te zeile aus dem input array können wir nicht wegfallen lassen.

dann wird geguckt ob wir die 1te zeile aus der input liste weglassen können, etc.

natürlich, wenn wir mal eine zeile ausgemacht haben, die wir wegfallen lassen können, dann brechen wir ab bzw. "returnen".

dann wird unsere variable, die die inputliste referenziert, zugewiesen zu einer kopie der inputliste, die eben jene j'te zeile nicht mehr enthält. die eben um eine zeile verkürzt wurde.

dieser vorgang nenne ich jetzt mal einen "optimierungsschritt".

weil unser optimierungprozess bzw. dessen methode noch so gebaut ist dass er uns per boolean rückgabewert direkt mitteilt ob er eine zeile zum wegkicken fand und dementsprechend die inputlsite um 1 verkürzt hat.
können wir durch eine simple while shcleife das endlos laufen lassen bis irgendwann nix mehr opimiert werden konnte und wir fertig sind.

So zumindest die theorie.

Das erzeugen der initialen 6tupel liste in test10 scheint wohl zu funktionieren.

allerdings wenn ich das dann durhc den "optimierer" in test9 jage, dann findet er nix zum optimieren.
obwohl ich von der mathematisch her ziemlich genau weiß dass sich die eingangs 500 nochwas elemente große liste auf um die 77 reohen zusammenschrumpfen lassen muss.
eigentlich.

insofern sind da wohl irgendwo noch fehler drin, wnen auch keine die den compiler stören.
 
F

fhoffmann

Top Contributor
Ich wüsste nur nicht wie ich es besser machen könnte ohne die Grundstruktur zu verändern oder ganz andere Datentypen zu verwenden.

Zum Einen habe ich die Klasse Test9:
Java:
public class Test9{
    static int k=6; //anzahl zahlen pro getipptem feld
    static int n=49; //menge an verfügbaren zahlen  
    static int max=27;
"k", "n" und in gewissem Sinne sogar "max" sind keine verständlichen Variablennamen. Das zeigt sich schon daran, dass du sie im Code kommentieren musst.

Und aus dem Klassennamen Test9 kann ich auch nicht ableiten, welche Aufgabe diese Klasse hat (oder wie sie sich von der Klasse Test8 unterscheidet).
 
B

berndoa

Bekanntes Mitglied
Java:
public class Test9{
    static int k=6; //anzahl zahlen pro getipptem feld
    static int n=49; //menge an verfügbaren zahlen 
    static int max=27;
"k", "n" und in gewissem Sinne sogar "max" sind keine verständlichen Variablennamen. Das zeigt sich schon daran, dass du sie im Code kommentieren musst.

Und aus dem Klassennamen Test9 kann ich auch nicht ableiten, welche Aufgabe diese Klasse hat (oder wie sie sich von der Klasse Test8 unterscheidet).
öh, IDE?

ich geb direkt in der Konsole (cmd) javac Test9.java zum kompilieren ein und java Test9 zum Starten.
Ansosnten schreibe ich den Code mit Notepad++ als Editor
 
B

berndoa

Bekanntes Mitglied
Ja, das ist wohl wahr, die Variabelnnamen könnten kluger gewählt sein.
Ich meinte eher so generell, mich ärgert es auch dass es so tausend Methoden sind und so kleinschrittig Alles gemacht ist. Aber ich wüsste auch nicht wie man es übersichtlicher und platzsparender programmieren könnte. Ausser jetzt zu ner anderen Datenstruktur oder so zu wechseln
 
temi

temi

Top Contributor
Ich wüsste nur nicht wie ich es besser machen könnte ohne die Grundstruktur zu verändern oder ganz andere Datentypen zu verwenden.
Das war in diesem Fall der Tipp: Ändere die Grundstruktur und mach es ordentlich. Ist es nur privat, dann hast du ja die Zeit. Oder hast du einen Kunden, der auf die Fertigstellung wartet? Was um so bedauerlicher für den Kunden wäre, wenn er so ein Produkt erhält.
 
temi

temi

Top Contributor
öh, IDE?

ich geb direkt in der Konsole (cmd) javac Test9.java zum kompilieren ein und java Test9 zum Starten.
Ansosnten schreibe ich den Code mit Notepad++ als Editor
Dann lade dir eine ordentliche IDE herunter, z.B. IntelliJ (Mein Favorit. Es gibt auch Alternativen). Damit kannst du dann recht einfach auch ordentlich arbeiten und dir das Leben deutlich leichter machen.
 
B

berndoa

Bekanntes Mitglied
Das war in diesem Fall der Tipp: Ändere die Grundstruktur und mach es ordentlich. Ist es nur privat, dann hast du ja die Zeit. Oder hast du einen Kunden, der auf die Fertigstellung wartet? Was um so bedauerlicher für den Kunden wäre, wenn er so ein Produkt erhält.
Das ist nur privat für meine Zwecke. Aber wie könnte ich das konkret ändern?
Anderen Datentyp statt Arraylist benutzen? aber welchen?
 
temi

temi

Top Contributor
Das ist nur privat für meine Zwecke. Aber wie könnte ich das konkret ändern?
Anderen Datentyp statt Arraylist benutzen? aber welchen?
Die erforderlichen Typen (= Klassen) musst du dir ggf. selbst schreiben. Zum Beispiel eine Klasse Tuple6.
Java:
public class Tuple6 {

    private final int[] values = new int[6];

    // Konstruktor(en), Methoden, usw.
}

Dann kannst du für deine Zahlen eine List<Tuple6> verwenden oder ein entsprechendes Array Tuple6[]

Warum verwendest du überhaupt long/Long? Für die Zahlen von 1-49 ist das doch etwas übertrieben, da würde notfalls ein Byte reichen. Mit einer entsprechenden Zugriffslogik (in einer dafür bestimmten Klasse) kannst du die 6 Bytes in einem einzelnen long-Wert unterbringen oder, besser noch, in einem byte[] values = new byte[6]. Bin mir grad nicht sicher, wieviel Byte ein byte in Java belegt, aber ich glaube in Arrays wird es schon gepackt. Die Antwort auf diese Frage kann sicher jemand hier geben.

Noch besser wäre aber der Ansatz nur die Werte aufzubewahren, die du später auch noch einmal benötigst, wie es @fhoffmann weiter oben schon mal vorgeschlagen hat. Keine Ahnung, ob das bei dir möglich ist. Ich hab mir nicht alles haarklein durchgelesen, was du vorhast.
 
Zuletzt bearbeitet:
B

berndoa

Bekanntes Mitglied
Die erforderlichen Typen (= Klassen) musst du dir ggf. selbst schreiben. Zum Beispiel eine Klasse Tuple6.
Java:
public class Tuple6 {

    private final int[] values = new int[6];

    // Konstruktor(en), Methoden, usw.
}

Dann kannst du für deine Zahlen eine List<Tuple6> verwenden oder ein entsprechendes Array Tuple6[]

Warum verwendest du überhaupt long/Long? Für die Zahlen von 1-49 ist das doch etwas übertrieben, da würde notfalls ein Byte reichen. Mit einer entsprechenden Zugriffslogik (in einer dafür bestimmten Klasse) kannst du die 6 Bytes in einem einzelnen long-Wert unterbringen oder, besser noch, in einem byte[] values = new byte[6]. Bin mir grad nicht sicher, wieviel Byte ein byte in Java belegt, aber ich glaube in Arrays wird es schon gepackt. Die Antwort auf diese Frage kann sicher jemand hier geben.

Noch besser wäre aber der Ansatz nur die Werte aufzubewahren, die du später auch noch einmal benötigst, wie es @fhoffmann weiter oben schon mal vorgeschlagen hat. Keine Ahnung, ob das bei dir möglich ist. Ich hab mir nicht alles haarklein durchgelesen, was du vorhast.
Hm , hatte eigentlich auf arraylist statt arrays gesetzt weil ich jabspw. auch eine liste von 6tupels generiere und dabei ein anfangs leeres 6tupel nahceinander mit zahlen fülle.
Insofern könnte da zwischenzeitlich ein unvollständiges 6tupel mit nur 3 elementen drin oder so vorkommen.
bei einem festen array der länge 6 wüsste ich nicht wie ich die noch unbesetzten Stellen irgendwie belegen sollte oder so.

Weil ja bspw int, wenn noch nicht mit wert belegt, schon vordefiniert ist mit 0. was dann zu problemen kommen kann.
Weil ich dann bspw. nicht weiß ob jene stelle noch uninitialisiert ist oder ob ich sie shcon mit dem wert 0 belegt habe
 
temi

temi

Top Contributor
Hm , hatte eigentlich auf arraylist statt arrays gesetzt weil ich jabspw. auch eine liste von 6tupels generiere und dabei ein anfangs leeres 6tupel nahceinander mit zahlen fülle.
Insofern könnte da zwischenzeitlich ein unvollständiges 6tupel mit nur 3 elementen drin oder so vorkommen.
bei einem festen array der länge 6 wüsste ich nicht wie ich die noch unbesetzten Stellen irgendwie belegen sollte oder so.

Weil ja bspw int, wenn noch nicht mit wert belegt, schon vordefiniert ist mit 0. was dann zu problemen kommen kann.
Weil ich dann bspw. nicht weiß ob jene stelle noch uninitialisiert ist oder ob ich sie shcon mit dem wert 0 belegt habe
Ja, das musst du wissen, was du brauchst, bzw. eine Lösung dafür finden. Wobei, deine Werte gehen von 1 - 49, dann muss 0 ja automatisch uninitialisiert sein, weil es keine gültige, gezogene Zahl sein kann.
 
B

berndoa

Bekanntes Mitglied
longs hatte ich auch eigentlich nur benutzt weil bspw. die lsite mit allen möglichen 6teupeln (zahkbereich 1-49) schon stark an der integergrenze kratzt oder gar darüber ist.

Wobei ich mir nicht so klar bin was eigentlich passieren würde wenn ich ein int array hätte, deren elemente zwar im zulässigen bereich sind, aber die array länge an sich oberhalb des max integers liegt.

oder würde ich ein solches array gar nicht erstellen können?
dann dürfte ein entsorechendes ArrayList<Integer> dann aber auch nicht funktionieren weil das ja intern auch ein int array benutzt.

so oder so könnte ich, selbst wenn ich ein solcher array erstellen könnte, dessen elemente nicht wirklich aufrufen.
weil bspw. array[9999999999] würde wohl nicht gehen weil er als parameter ein int erwartet aber diese zahl gar nicht mehr im int bereich ist. oder so. nur meine vermutung
 
Zuletzt bearbeitet:
B

berndoa

Bekanntes Mitglied
kann man eigentlich mehrere kalssen pro java programm haben?

oder bräuchte ich ein programm 6Tupel.java, ein Programm 6TupelListe.java und so, halt für jede erstellte klasse ein gleichbenanntes eigenes programm?
 
kneitzel

kneitzel

Top Contributor
Öhm, soll ich mal anfangen Klassen zu zählen, die wir so in diversen Projekten haben?

Also generell kann ein Programm sehr viele Klassen haben. Da sind erst einmal keine Grenzen gesetzt. (Die kommen maximal durch notwendigen Speicher ...)

Oder geht es Dir darum, dass Du jede Klasse testen willst und Du dafür überall "Programme" schreibst, die das machen? Da wäre dann das Thema Unit Tests für Dich interessant.

Vielleicht kannst Du etwas ausführen, was genau Du da gerade vor Augen hast.
 
J

Joreyk

Bekanntes Mitglied
Ein Projekt, das mich in den letzten Monaten (zum Teil) beschäftigt hat, habe ich einmal geprüft und da habe ich ohne Tests eine schöne dreistellige Zahl.
Mein Größtest Projekt ist im Moment mein Karten Spiel...das umfasst insgesamt 26 Klassen.. und 4 davon sind Test Klassen also...jaaaaaaaa moin
 
B

berndoa

Bekanntes Mitglied
Ich meinte nur, wenn ich mehrere Klassen in einem Protramm habe, dann kann ich ja nicht mehr deren Main Programm ausführen, oder?

Oder wie würde ich bspw. von einem anderen Programm aus ein Objekt einer der klassen machen?

nur mal so als frei erfundenes Beispiel:


Java:
A.java mit Inhalt:

public class A{
    public static void main(String[] args){
    }

    public A(){}
       
}

public class B{

    public static void main(String[] args){
    }

    public B(){}
}


dann noch ein anderes Programm C.java mit Inhalt:

Public class C{

    public static void main(String[] args){
        //neues Objekt der klasse A erzeugen
        //main methode der Klasse B ausführen
    }

    public A(){}

}

Oder auch von der konsole aus, normalerweise haut man da nach dem kompilieren klassenname.java rein,
dann wird die datei klassenname.java genommen, in der sich die klasse klassenname befinden muss und deren main methode ausgeführt.

wie will man, von der konsole aus , bitteschön die mainmethode der Klasse B ausführen?
java A wird, falls esüberhaupt das tut, nur die klasse A angucken und deren Main methode aufrufen.
wie komme ich an die Klasse B und deren mainmethode?

weil die klasse B befindet sich ja in der datei A.java, wo ja name von datei und klasse nicht gleich sind was doch eigentlich nicht sein darf, oder?
 
J

Joreyk

Bekanntes Mitglied
Ich meinte nur, wenn ich mehrere Klassen in einem Protramm habe, dann kann ich ja nicht mehr deren Main Programm ausführen, oder?

Oder wie würde ich bspw. von einem anderen Programm aus ein Objekt einer der klassen machen?

nur mal so als frei erfundenes Beispiel:


Java:
A.java mit Inhalt:

public class A{
    public static void main(String[] args){
    }

    public A(){}
     
}

public class B{

    public static void main(String[] args){
    }

    public B(){}
}


dann noch ein anderes Programm C.java mit Inhalt:

Public class C{

    public static void main(String[] args){
        //neues Objekt der klasse A erzeugen
        //main methode der Klasse B ausführen
    }

    public A(){}

}

Oder auch von der konsole aus, normalerweise haut man da nach dem kompilieren klassenname.java rein,
dann wird die datei klassenname.java genommen, in der sich die klasse klassenname befinden muss und deren main methode ausgeführt.

wie will man, von der konsole aus , bitteschön die mainmethode der Klasse B ausführen?
java A wird, falls esüberhaupt das tut, nur die klasse A angucken und deren Main methode aufrufen.
wie komme ich an die Klasse B und deren mainmethode?

weil die klasse B befindet sich ja in der datei A.java, wo ja name von datei und klasse nicht gleich sind was doch eigentlich nicht sein darf, oder?
öffne mal IRGEND EINE ide..und versuch mal herauszufinden wie das geht mit merhere klassen

und versuch mal rauszufinden was die Main so als bedeutung hat in einem Programm

eclipse...intellij...irgendwas was java kann
 
B

berndoa

Bekanntes Mitglied
mein kommentar oben bezog sich auf die grezen von int.

und wenn ich bspw. ein int array habe, dessen länge eine zahl größer dem max int ist, dann kann ich doch gar nicht sowas wie array[99999999] aufrufen, oder? weil eben 999999999 > max int ist, also locker ein long oder sowas sein muss. und aber in der [ ein int erwartet wird als index.

gleiches problem bei arraylist, da die ja intern ein int[] haben.

darum war ich auf long listen umgestiegen wiel größerer zahlenbereich
 
B

berndoa

Bekanntes Mitglied
ides? wozu braucht man sowas, ist das nicht im prinzip editor+kommandozeile in einem, also nur ein aufgehübschtes userinterface damit man nicht mit dem ollen cmd herumhantieren muss?

kapiert habe ich das nie warum bei den zeilen im cmd
javac name.java
java name

in der datei name.java in deren klasse name die main methode aufgerufen wird.


aber andererseits man, von anderen klassen aus, ein objekt der klasse name erzeugen kann. wobei heir bei nur der kosntruktor zum zug kommt und die main methode gar nicht.


diese untershciedliche "behandlungsweise" ob beim "ausführen" einer klasse im cmd oder beim objekterstellen einer klasse, hat michs chon immer verwirrt weil macht kein sinn.

das eine benutzt nur den konstruktor und ignoriert die main methode, das andere guckt nur auf die main methode und juckt sich gar nicht für den konstruktor.
Weird...
 
kneitzel

kneitzel

Top Contributor
Also generell muss eine Klasse keine main Methode haben. Ein Programm braucht mindestens eine Klasse mit main Methode, weil das von Sun damals so festgelegt wurde: Ein Programm wird über eine solche Methode gestartet. Das kann man als willkürliche Festlegung betrachten.

Es macht etwas Sinn, denn für eine statische Methode benötigt man keine Instanz, daher kann die Methode, nach Laden der Klasse, direkt aufgerufen werden.

Prinzipiell ist natürlich denkbar, dass das Programm noch weitere main Methoden (z.B. aus anderen Klassen) aufruft. Das ist aber eher unüblich aber technisch kein Problem.

Somit hat man auf der einen Seite einfach nur eine statische Methode, die aufgerufen wird und die willkürliche Festlegung, dass ein Java Programm über eine main Methode gestartet wird.

Das andere, das Du angesprochen hast, ist der Konstruktor. Von einer Klasse kann man Instanzen erzeugen. Da gibt es dann die Möglichkeit, über einen Konstruktor eine Initialisierung durchzuführen. (Und die Entscheidung der Java Entwickler, dass ein Default Konstruktor erzeugt wird, wenn keiner im Code vorhanden ist. Dadurch wird immer über einen Konstruktor eine Initialisierung durchgeführt).

Das ist eine ganz andere Sache und unabhängig von der Festlegung, wie ein Programm gestartet werden muss. Und es muss auch keine Instanz erzeugt werden, z.B. ein einfaches HelloWorld Programm. Da sieht man erst einmal keinen Konstruktor, der ausgeführt wird (Ist aber nicht ganz korrekt. Es werden viele Instanzen erzeugt, aber die sind alle außerhalb des Programmcodes)
 
B

berndoa

Bekanntes Mitglied
dann sind statische methoden und so nicht so der standard?

ich klatsche irgendwie immer public static in die signatur meiner methoden, einfach weil die main methode es auch so macht und ich ddahcte dass es wohl daher richtig ist.
Habe auch genauso attribute bspw. als static int counter; deklariert, einfach weil der shcon mal gemeckert hatte wenn ich in ner methode das nutzen wollte und es nicht static war.
 
kneitzel

kneitzel

Top Contributor
Nein statische Elemente sollte man größtenteils vermeiden. Ausnahme ist die main Methode und Konstanten, die in der Regel public static final ... deklariert werden.

Hintergrund ist, dass Java Objektorientiert ist. Wir wollen also mit Objekten arbeiten, die miteinander agieren. Dazu ist es aber notwendig, dass wir von den Klassen (das sind die Baupläne von Objekten) eben die Objekte erzeugen.
 
temi

temi

Top Contributor
Mein ganz ernst gemeinter Tipp wäre es, dass du dir einen guten Java-Kurs besorgst und den durcharbeitest. Dann hast du alle Grundlagen, um dein Projekt ordentlich durchzuziehen. Dir jetzt in diesem Thema die Grundlagen der objektorientierten Programmierung beibringen zu wollen, halte ich für unrealistisch.

longs hatte ich auch eigentlich nur benutzt weil bspw. die lsite mit allen möglichen 6teupeln (zahkbereich 1-49) schon stark an der integergrenze kratzt

Du hast eine falsche Vorstellung davon, was eine List<Long> ist. Die größte Integerzahl wäre 2.147.483.647, da kann von Grenze keine Rede sein, denn 49 ist eine deutlich kleinere Zahl. Das <Long> ist der Datentyp, der in der Liste gespeichert wird. Du kannst also sehr viele Longwerte in der Liste ablegen. Ein long kann Zahlen von minus 2 hoch 63 bis 2 hoch 63-1 darstellen. Das hat aber nichts mit der Anzahl der Werte zu tun, die in der Liste gespeichert werden können!

Für die Darstellung der Zahlen von 1 bis 49 reichen eigentlich schon 6 Bit, der kleinste Ganzzahlentyp in Java ist das Byte (8 Bit). Damit kann man Zahlen von -128 ... 127 darstellen, die größte damit darstellbare Zahl ist immer noch mehr als doppel so groß, wie deine größte Zahl 49. Eine List<Byte> wäre also für dich vollkommen ausreichend - eine Liste, die viele viele Bytes aufnehmen kann.
 
Zuletzt bearbeitet:
B

berndoa

Bekanntes Mitglied
Also für mich ist 49^6 (denn so viele tupel mit zahlen aus dem bereich 1-49 gibt es, wenn man die reihenfolge nicht missachtet) kommt mir doch shcon ziemlich nahe an die 2 milliiarden dran, wenn ich mich nciht täusche.

irgendwo las ich dass ne ArrayList<Long> intern ein Long[] hat. wenn das voll ist und man ne weitere zahl addet , wird das array in eine neues array der anderthalben länge kopiert und dort die bisherigen werte reinkopiert. sowie halt noch der neue wert hinzugefügt.

Aber bleiben wir beim beispiel:
49^6=13.841.287.201 da können die lächerlichen 2 milliarden vom positiven intbereich nciht dran ran.

jetzt die Masterfrage:
angenommen ich versuche ein int[Integer.MAX_VALUE+2] zu deklarieren. Keine Ahnung ob das geht.
aber nehmen wirs mal an.

wenn ich nun versuche auf den Integer.MAX_VALUE+1 ten Wert zuzugreifen, habe ich meine berechtigten zweifel ob das geht.

denn ich weiß aus erfahrung dass mich der compiler shcon dumm angemacht hat wenn ich irgendwo
array[index] aufgerufen habe und index vom typ long war, aber java da index vom typ int erwartet hat.
ich musste also array[(int)index} machen sonst wurde es nicht akzeptiert.

Ergo muss da zwischen den 2 klammern ein int stehen.

was ist Integer.MAX_VALUE+1 nochmal?
kein int. oder Integer.MIN_VALUE+1 weil es beim erhöhen um 1 nach ganz unten geloopt hat. wer weiß.

Jedenfalls nicht das, was ich wollte.

was also machen?
Dann muss ja Integer.MAX_VALUE+1 dann aus dem nächstgrößeren zahlenbereich sein, bzzw. müssten wir aus dem bereich wählen damit auch die beabsichtigte indexstelle genommen wird. Also ein long oder sowas.

tja... aber war da nicht was dass der compiler in den eckigen klammern ein f'ing int und kein long haben will?

Was nun, Herr Gelehrter?

Wie rufe ich bitte die Integer.MAX_VALUE+1 te indexstelle eines int arrays auf, wenn Integer.MAX_VALUE+1 per definitionem nicht aus dem int bereich stammt aber als index auch nix anderes als int akzeptiert wird?

aus dem grund habe ich mit long arrays und long arraylists gearbeitet.

Wobei ich mich da nun natürlich rückblickend frage ob nicht selbst bei einem long array der index sich nur im int bereich bewegen darf.
und der mir daher trotzdem zu ganz ungewünschten indexstellen gesprungen ist deswegen :-/


Wo gibts denn einen guten Javakurs, oh großer Weiser am Himmel, der uns Unwissende zu belehren weiß?
 
J

Joreyk

Bekanntes Mitglied
Wo gibts denn einen guten Javakurs, oh großer Weiser am Himmel, der uns Unwissende zu belehren weiß?

also ich weis ich geh hier gefühlt einigen aufn Sack aber das ist ok weil ich keinen Beleidige ..glaub ich zumindest

das von dir ist doch schon verletztend


wenn du
49^6=13.841.287.201

datensätze in EIN Array packen willst und das den speicher ÜBERSCHREITET dann kann man sich als java anfänger mal fragen


"ja soll das überhaupt gehen oder hat sich da irgend ein genie das diese Sprache entwickelt hat was schlaues dabei gedacht"



wenn du dein Problem nicht in häppchen unterteilen kannst dann hast du noch nicht verstanden wie man das problem löst

ich bin jetzt mal ein wgroßer weiser am himmel und sag vllt gibts da andere datenstrukturen die besser passen ...oder ganz krass es gibt sogar kombinationen davon
 
kneitzel

kneitzel

Top Contributor
Ja, so ein Array wäre schon was feines ...
13.841.287.201 long Werte ... long hat 8 Byte ... über 100GB Speicher für nur ein Array?

Nunja, wie viel (Haupt)Speicher hast du denn, dass du so große Arrays sinnvoll bearbeiten willst?

Das nur als ein weiterer Punkt ...

Aber du hast jetzt so ein Array und damit machst du jetzt etwas: wie viele Datensätze verarbeitest du pro Sekunde?
1000?
13 Millionen Sekunden und du bist durch. Ok, einmal durchlaufen kann schneller gehen ... vielleicht machst du ja nichts so komplexes... aber die Problematik erkennst du hoffentlich ... und man muss nur an Algorithmen denken, die nicht O(n) oder besser sind ...

Das nur, um mal ein besseres Gefühl zu bekommen für die Materie....

so man dies aber wirklich braucht:
Mach ein 2D Array. Zugriff wäre dann halt über ein Long, das du in zwei int aufteilst. (long hat 8 Bytes, daher zwei int a 4 Bytes)
Schon hast du ein Array mit Long als Adressierung...
 
B

berndoa

Bekanntes Mitglied
also ich weis ich geh hier gefühlt einigen aufn Sack aber das ist ok weil ich keinen Beleidige ..glaub ich zumindest

das von dir ist doch schon verletztend


wenn du
49^6=13.841.287.201

datensätze in EIN Array packen willst und das den speicher ÜBERSCHREITET dann kann man sich als java anfänger mal fragen


"ja soll das überhaupt gehen oder hat sich da irgend ein genie das diese Sprache entwickelt hat was schlaues dabei gedacht"



wenn du dein Problem nicht in häppchen unterteilen kannst dann hast du noch nicht verstanden wie man das problem löst

ich bin jetzt mal ein wgroßer weiser am himmel und sag vllt gibts da andere datenstrukturen die besser passen ...oder ganz krass es gibt sogar kombinationen davon
Oh, das tut mir jetzt wirklich Leid, denn dich meint eich gar nicht damit.

Ich meinte eher wen anders, der so schön schrieb
"Mein ganz ernst gemeinter Tipp wäre es, dass du dir einen guten Java-Kurs besorgst und den durcharbeitest. Dann hast du alle Grundlagen, um dein Projekt ordentlich durchzuziehen. Dir jetzt in diesem Thema die Grundlagen der objektorientierten Programmierung beibringen zu wollen, halte ich für unrealistisch."

Beim Lesen bekam ich irgendwie ein "DU bist dumm wie scheiße und weißt nicht mal was objekte und Kalssen sind und wie man sie benutzt" Gefühl. Das misfiel hier, daher bezog ich mich bei meinem Kommentar auch darauf.

Insofern meinte ich nciht dich, tut mir Leid wenn du dich fälschlich angesprochen fühltest.


Naja, mir ist bisher noch kein wirklich guter Weg eingefallen, wie ich eine Art Liste mit allen möglichen Kombinationen aus 6 Lottozahlen erzeugen kann, sodass ich eben später für Vergleiche und Co. auf jedes der 6-zahlen-bündel zugreifen kann.

Weil in meinem programm kommen öfters mal so stellen vor, wo ich eine 6zahlenkombi A habe und die mit jedem 6erbündel aus der liste abgeglichen wird dahingehend wie viele zahlen sie gmeeinsam haben:
also sowas wie

for(6erkombi a:6tupelliste){
//bestimme anzahl gleicher zahlen von a und b
}

das ganze programm prüft halt nach brute force methodik einfach mal zig tausende elemente mit anderen zumindest hunderten elemente kreuz und quer ab.

Vermutlich könnte man die grundsache auch anders lösen, aber dzau müsste ich das ganze mit den lotto garantie systemen wohl besser verstehen oder so.
 
M

Meniskusschaden

Top Contributor
Wobei ich mich da nun natürlich rückblickend frage ob nicht selbst bei einem long array der index sich nur im int bereich bewegen darf.
Der Index darf sich nur im nicht-negativen int-Bereich bewegen, was aber natürlich nicht garantiert, dass genug Speicher für Integer.MAX_VALUE Elemente verfügbar ist.
Der Array-Typ legt den Datentypen der zu speichernden Elemente fest und hat nichts mit dem Index-Typ zu tun.
Siehe JLS
 
mihe7

mihe7

Top Contributor
Beim Lesen bekam ich irgendwie ein "DU bist dumm wie scheiße und weißt nicht mal was objekte und Kalssen sind und wie man sie benutzt" Gefühl. Das misfiel hier, daher bezog ich mich bei meinem Kommentar auch darauf.
Das hat doch nichts mit Dummheit zu tun, jeder fängt mal an. Hier im Forum wollen die Leute grundsätzlich helfen und ich lese lang genug mit, dass ich mich sagen traue, dass der Hinweis von @temi auch als Hilfe zu verstehen war, weil das Forum einfach keinen Kurs (oder wie auch immer man sich die Grundlagen aneignet) ersetzen kann.

Also für mich ist 49^6 (denn so viele tupel mit zahlen aus dem bereich 1-49 gibt es, wenn man die reihenfolge nicht missachtet) kommt mir doch shcon ziemlich nahe an die 2 milliiarden dran, wenn ich mich nciht täusche.
irgendwo las ich dass ne ArrayList<Long> intern ein Long[] hat. wenn das voll ist und man ne weitere zahl addet , wird das array in eine neues array der anderthalben länge kopiert und dort die bisherigen werte reinkopiert. sowie halt noch der neue wert hinzugefügt.
Das Problem ist, dass der Typparameter Long im Fall der ArrayList bzw. der Datentyp Long/long beim Array angibt, von welchem Typ die einzelnen Elemente sind. Das hat nichts mit der möglichen Größe des Arrays/der Liste zu tun.

Wenn Du also eine Tippreihe mit 6 Zahlen hast, reichen dafür 6 Bytes aus. Die kannst Du jetzt z. B. als byte-Array der Größe 6 darstellen (byte[] tipp = new byte[6]), genauso gut kannst Du die 6 Bytes in ein long packen (long tipp).

Jetzt gibt es ein grundsätzliches Problem: selbst, wenn man nur die Nutzdaten sieht, würdest Du 49^6 Bytes benötigen um alle Kombinationen im Speicher zu halten. Das wären 13,8 GB. Also musst Du Dir was überlegen.

Eine erste Überlegung wäre, nur echte Lottoreihen zu verwenden, dann sinkt die Zahl sofort auf 13,x Mio.

Eine weitere Überlegung wäre: brauchst Du die alle zur gleichen Zeit im Speicher? Wozu? Kannst Du die Zahlen vielleicht on the fly erzeugen? Fragen über Fragen :)
 
B

Barista

Top Contributor
Für die Werte von 1 bis 49 (48) benötigst Du jeweils 6 Bit (0 bis 63) ohne Vorzeichen.

Für 6 * 49 benötigst Du 6 * 6 Bit, 36 Bit.

Leider hat Java int nur 32 Bit.

Also benutzt Du Java long mit 64 Bit.

Leider bleiben 28 Bit ungenutzt.

Eventuell hilft Dir diese kleine Lib, die ich zufällig ganz gut kenne:

Bit packed array in Java

Die Unit-Tests solltest Du nicht ausführen, die laufen ein paar Wochen.

Ich überlege mal, ob ich die Korrektheit beweisen kann, vollständige Induktion und so, Du verstehst (wenn nicht, ist egal).
 
temi

temi

Top Contributor
Oh, das tut mir jetzt wirklich Leid, denn dich meint eich gar nicht damit.

Ich meinte eher wen anders, der so schön schrieb
"Mein ganz ernst gemeinter Tipp wäre es, dass du dir einen guten Java-Kurs besorgst und den durcharbeitest. Dann hast du alle Grundlagen, um dein Projekt ordentlich durchzuziehen. Dir jetzt in diesem Thema die Grundlagen der objektorientierten Programmierung beibringen zu wollen, halte ich für unrealistisch."

Beim Lesen bekam ich irgendwie ein "DU bist dumm wie scheiße und weißt nicht mal was objekte und Kalssen sind und wie man sie benutzt" Gefühl. Das misfiel hier, daher bezog ich mich bei meinem Kommentar auch darauf.
Finde ich ja nett von dir, dass du mich beleidigen wolltest. 😥 Muss mal in mich gehen. Bin ich jetzt beleidigt? Hm. Nee, tut mir leid. Hat nicht geklappt.

Der Tipp war vollkommen ernst gemeint, darum steht das auch da.
"Mein ganz ernst gemeinter Tipp
Die Fragen, die du in den Beiträgen vorher gestellt hast, zeigen, dass dir noch einige Grundlagen fehlen. Wie du daraus drauf kommst, dass ich dich für dumm halte, ist mir etwas schleierhaft. Ich kann dir aber versichern, dass ich dir das auch geschrieben hätte, wenn ich das Gefühl gehabt hätte, dass Programmieren nichts für dich ist.

Zu deiner Annahme mit List<> und Long. Ein Blick in die Dokumentation zu List<> zeigt, z.B. bei get(), dass hier für den Index nur ein Integer vorgesehen ist. Auch Arrays werden in Java über einen Integer-Index angesprochen:
The variables contained in an array have no names; instead they are referenced by array access expressions that use non-negative integer index values.

Insofern musst du dir auf jeden Fall etwas anderes einfallen lassen und da hilft es eben ungemein, dass man weiß, dass es in Java auch mehr als eine Klasse geben kann ;)

Wo gibts denn einen guten Javakurs, oh großer Weiser am Himmel, der uns Unwissende zu belehren weiß?
Ich arbeite am liebsten mit Büchern und habe mir für Java als erstes "Java ist auch eine Insel" gekauft. Allerdings ist das Buch, meiner Meinung nach, eher eine Art Kompendium als ein Kurs und damit nicht unbedingt für blutige Anfänger geeignet. Das für mich hilfreichste Buch war "Entwurfsmuster von Kopf bis Fuß". Falls "Java von Kopf bis Fuß" ähnlich gut ist (ich kenne es nicht), dann wäre es mein Tipp und danach direkt das Buch zu den Entwurfsmustern.
 
Zuletzt bearbeitet:
temi

temi

Top Contributor
Ach, noch was: Unter Beachtung der Reihenfolge der Zahlen gibt es 10.068.347.520 Kombinationen. Da aber die Reihenfolge beim Lotto keine Rolle spielt, entfallen davon einige und es bleiben nur noch 13.983.816. Das ist doch mal ein Ansatz, mit dem man was anfangen kann.
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
S Objekte von zwei klassen in zwei verschiedene Textdateien schreiben Java Basics - Anfänger-Themen 5
D Wie Objekte im JFrame frei bewegen lassen? Java Basics - Anfänger-Themen 3
Spandeli8 Erzeugte Objekte gegenüber Bildern hervorheben in Java Processing Java Basics - Anfänger-Themen 1
J Zwei Objekte vergleichen Java Basics - Anfänger-Themen 8
L Werte von Objekte addieren Java Basics - Anfänger-Themen 14
U Objekte in LinkedList löschen und editieren Java Basics - Anfänger-Themen 14
W Objekte über Scanner Input; ToString Probleme... Java Basics - Anfänger-Themen 4
J Problem mit einer Methode, die beliebig viele Objekte in Array speichern soll Java Basics - Anfänger-Themen 6
G Methoden Informationen aus zwei Objekte bekommen? Java Basics - Anfänger-Themen 6
P Globale Objekte Java Basics - Anfänger-Themen 2
C Nachträglich neue grafische Objekte hinzufügen Java Basics - Anfänger-Themen 7
D Interaktion zweier Objekte Java Basics - Anfänger-Themen 5
M Objekte in Array speichern und ausgeben Java Basics - Anfänger-Themen 17
S Objekte indiziert erstellen Java Basics - Anfänger-Themen 27
M Warum dürfen Objekte einer Klasse auf statische Variablen dieser Klasse referenzieren? Java Basics - Anfänger-Themen 10
M Objekte mittels equals vergleichen Java Basics - Anfänger-Themen 14
C Fernseher-Aufgabe (Methoden, Klassen und Objekte) Java Basics - Anfänger-Themen 63
N Typebound Objekte einer Arraylist hinzufügen Java Basics - Anfänger-Themen 7
A (Objekte Java Basics - Anfänger-Themen 6
Y Klassen Klassen und Objekte Java Basics - Anfänger-Themen 3
Y Klassen Klassen und Objekte mit set und get Java Basics - Anfänger-Themen 0
U Objekte in einer LinkedList sortieren Java Basics - Anfänger-Themen 5
N Methode um Objekte einer Liste hinzuzufügen Java Basics - Anfänger-Themen 1
G Java Objekte auf Duplikate testen Java Basics - Anfänger-Themen 4
B Neue Liste erstellen, wenn Objekte bestimmte Referenz hat / Gruppierung von Einträgen Java Basics - Anfänger-Themen 12
M Implementieren einer Datenstruktur, welche nur 5 Objekte speichert Java Basics - Anfänger-Themen 3
M Objekte miteinander vergleichen Java Basics - Anfänger-Themen 18
C Verschiedene Objekte in einer Liste speichern Java Basics - Anfänger-Themen 6
J Java GUI- Objekte Position per Quelltext bestimmen Java Basics - Anfänger-Themen 4
G Objekte in Methoden? Java Basics - Anfänger-Themen 13
H Auf Objekte bzw Variabeln aus einer anderen Methode zugreifen Java Basics - Anfänger-Themen 7
S Frage Klasse und Objekte Java Basics - Anfänger-Themen 2
K Boolean in einer Methode um 2 Objekte zu vergleichen Java Basics - Anfänger-Themen 12
I Objekte Hilfe Java Basics - Anfänger-Themen 8
G Klassen und Objekte Java Basics - Anfänger-Themen 2
W Verschachtelte Objekte wieder auspacken Java Basics - Anfänger-Themen 3
R Attribute mehrerer Objekte ausgeben Java Basics - Anfänger-Themen 3
C Objekte und Konstruktoren Java Basics - Anfänger-Themen 2
F Erstellen zweier Objekte mit dem selben Inhalt Java Basics - Anfänger-Themen 1
O ObjectOutputStream Anzahl Objekte festhalten Java Basics - Anfänger-Themen 17
R Objekte aus Array als String + kommasepariert speichern Java Basics - Anfänger-Themen 12
X Objekte einer ArrayList richtig ausgeben? Java Basics - Anfänger-Themen 8
J Best Practice Dateiinhalte validieren und auf Objekte mappen Java Basics - Anfänger-Themen 3
B Automatisch Objekte erzeugen mit verschiedenen Namen Java Basics - Anfänger-Themen 4
der_Schokomuffin Hilfe gesucht beim Thema Objekte übergeben! Java Basics - Anfänger-Themen 2
S Konstruktor, Objekte Java Basics - Anfänger-Themen 4
PaperHat Objekte in Array vergleichen Java Basics - Anfänger-Themen 9
B HTML Code / Seite auslesen und JAVA Objekte erstellen Java Basics - Anfänger-Themen 12
PaperHat Programmieraufgabe - Objekte in Objekten Java Basics - Anfänger-Themen 2
E Methode mit Parametern um Objekte zu übergeben Java Basics - Anfänger-Themen 4
V Collections Objekte einer ArrayList in der main() ausgeben Java Basics - Anfänger-Themen 9
T Klassen Klassenübergreifende Objekte erstellen lassen Java Basics - Anfänger-Themen 5
A Objekte verknüpfen Java Basics - Anfänger-Themen 2
M Objekte mit einer Schleife mehrmals erzeugen Java Basics - Anfänger-Themen 17
B Klassen Alle Unter-Objekte durchlaufen in der Hauptklasse Java Basics - Anfänger-Themen 10
B Objekte zählen/ Vererbung/ Kopplung/ Interface/ Abstract Class Java Basics - Anfänger-Themen 5
S Zählen der Zeiger auf Objekte Java Basics - Anfänger-Themen 35
J Methoden Equals Methode für Integer und Objekte überschreiben? Java Basics - Anfänger-Themen 9
B Erste Schritte Objekte von JFrame der Fenstergröße anpassen Java Basics - Anfänger-Themen 3
M Klassen und Objekte Java Basics - Anfänger-Themen 2
J Objekte und Abstrakte Klassen Java Basics - Anfänger-Themen 2
J Array Objekte einer Klasse zuordnen Java Basics - Anfänger-Themen 15
H Interface Objekte speichern und laden (serialisieren/deserialisieren) Java Basics - Anfänger-Themen 1
Orkanson Objekte in ein Array einfügen Java Basics - Anfänger-Themen 5
X Objekte in ArrayList einfügen Java Basics - Anfänger-Themen 10
L Vorherige Objekte zählen und ausgeben Java Basics - Anfänger-Themen 11
Orkanson Objekte und Klassen Java Basics - Anfänger-Themen 8
R Objekte zur Laufzeit in Schleife erzeugen und in ArrayList ablegen Java Basics - Anfänger-Themen 4
D Objekte-Fragen Java Basics - Anfänger-Themen 1
T Objekte in der Methode Java Basics - Anfänger-Themen 8
F Alle Objekte einer Klasse nach Eigenschaft durchsuchen Java Basics - Anfänger-Themen 8
R Interface Eigene Objekte in Listen sortieren mit Interface Comparable Java Basics - Anfänger-Themen 5
E Eine Instanzvariable und zwei Objekte Java Basics - Anfänger-Themen 14
N Objekte in ArrayList finden Java Basics - Anfänger-Themen 10
K Comparable - Objekte aus Array vergleichen und größtes auswählen Java Basics - Anfänger-Themen 1
R getrennte Objekte aus Klasse erstellen : warum Inhalt dann gleich ? Java Basics - Anfänger-Themen 2
T Objekte in Listen vererben Java Basics - Anfänger-Themen 3
E Methoden Objekte in Methode aufrufen ohne getter und setter? Java Basics - Anfänger-Themen 1
A Variablen In anderer Klasse auf Objekte von JFrame zugreifen Java Basics - Anfänger-Themen 1
R Objekte Vergleichen und Sortieren Java Basics - Anfänger-Themen 3
BobbGott Klassen 2 "Objekte" in einer Methode - wie? Java Basics - Anfänger-Themen 7
S Objekte mit gleichem Namen in unterschiedlichen Klassen Java Basics - Anfänger-Themen 3
S Objekte "gegebenfalls" erzeugen Java Basics - Anfänger-Themen 5
F Klassen Zugriff auf verschachtelte Objekte Java Basics - Anfänger-Themen 11
H Objekt überschreibt Variablen vorheriger Objekte Java Basics - Anfänger-Themen 2
snipesss Objekte Java Basics - Anfänger-Themen 14
tuc Erste Schritte verschiedene objekte in einem feld speichern Java Basics - Anfänger-Themen 4
J Objekte in einer Liste Java Basics - Anfänger-Themen 3
D Mehrere Objekte in ein Objekt zusammenfassen Java Basics - Anfänger-Themen 16
W OOP Zwei Objekte beziehen sich aufeinander (Zirkelbezug)? Java Basics - Anfänger-Themen 4
D Objekte mit verschiedenen Attributen erstellen Java Basics - Anfänger-Themen 3
A OOP Zugriff auf Objekte von außen Java Basics - Anfänger-Themen 8
T Objekte mit Verhalten Java Basics - Anfänger-Themen 14
Z OOP Objekte einer Klasse weiteren Klassen zur Verfügung stellen Java Basics - Anfänger-Themen 17
T Objekte erstellen Java Basics - Anfänger-Themen 2
D Methoden Wie können Klassen auf Klassenfremde Objekte zugreifen? Java Basics - Anfänger-Themen 7
G Datentypen verschiedene Objekte in eine ArrayList, Generics Java Basics - Anfänger-Themen 2
D Statische Objekte mit variablem Parameter Java Basics - Anfänger-Themen 1
K Mehrere Objekte anlegen Java Basics - Anfänger-Themen 23
S Objekte klonen und Deep Copy Java Basics - Anfänger-Themen 30

Ähnliche Java Themen


Oben