Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Objekte, bspw. konkret Arraylists,manuell aus Speicher löschen?
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.
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.
wenn dann kein Objekt mehr auf superGroses Array mehr deutet wirds vom gc geschreddert... der arbeitet halt nicht immer sofort aber "versucht sein bestes"
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
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.
//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();
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();
/*------------------------------------------------------------------------------------------------------------------------------------
--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;
/*-----------------------------------------------------------------------------------------------------------
-------Ab hier aktuelle Version der Funktion zum Bilden der sixtuples und hierzu nötiger Funktionen-----------
-------------------------------------------------------------------------------------------------------------*/
public static ArrayList<ArrayList<Long>> sixtuples(){
//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=array;
}
return copy;
}
/*----------------------------------------------------------------------------
---------Alte Version der Funktion zum Bilden der sixtuples-------------------
------------------------------------------------------------------------------*/
/*
public static ArrayList<ArrayList<Long>> sixtuples(){
ArrayList<ArrayList<Long>> sixtuples=new ArrayList<ArrayList<Long>>();
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.
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).
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).
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
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
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.
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.
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.
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.
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
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.
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
Ö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.
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.
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.
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?
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?
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
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...
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)
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.
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.
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.
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ß?
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
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...
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.
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
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
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.
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
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.
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.
