Definire un array di funzioni - Trucco Java #0002

Giugno 28, 2008 - No Responses

Ricordo che in linguaggio C si poteva richiamare una funzione invocandola attraverso un puntatore “che puntava” proprio a quella funzione.

In java esistono solo puntatori, è completamente fatto da puntatori che taluni arrivano a dire che questi non esistono affatto in Java.

Vogliamo definire un array di funzioni..

..ecco come fare ( http://www.rgagnon.com/javadetails/java-0005.html )

public class testf {
  public static void main(String args[]){
    Command[] commands = new Command[3];
    commands[0] = new aCommand();
    commands[1] = new bCommand();
    commands[2] = new cCommand();
    commands[0].exec();
    commands[1].exec();
    commands[2].exec();
    }
  }

  class aCommand implements Command {
    public void exec() {
      System.out.println("a");
      }
    }
  class bCommand implements Command {
    public void exec() {
      System.out.println("b");
      }
    }
  class cCommand implements Command {
    public void exec() {
      System.out.println("c");
      }
    }

  interface Command {
   void exec();
   }

L’output del programma sarà:

a
b
c

Emettere un suono beep da console - Trucco Java #0001

Giugno 27, 2008 - No Responses

Beep beep Volete che la vostra applicazione Java emetta un beep acustico/un suono ?
Ecco come si fa:

public class TestBeep {
public static void main(String args[]) {
// ASCII bell
System.out.print("07");
System.out.flush();
}
}

Compilando ed eseguendo questo semplice codice ascolterete il classico Beep acustico.
Invece, utilizzando quest’altro codice

import java.awt.*;

public class Beep {
  public static void main(String args[]) {
     Toolkit.getDefaultToolkit().beep();
  }
}

Ascolterete stavolta il segnale acustico predefinito del vostro sistema operativo in uso
(Io, per esempio, che sto lavorando con Windows Xp
ascolto il suono del “Windows XP Ding.wav”)

( http://www.rgagnon.com/javadetails/java-0001.html )

====================================

( http://www.rgagnon.com/javadetails/java-0499.html )

Un’altra soluzione, per emettere uno o più toni sonori dalla console, è la seguente

import javax.sound.sampled.*;

//jdk1.3
public class Tone {
     public static float SAMPLE_RATE = 8000f;
     public static void sound(int hz, int msecs)
      throws LineUnavailableException {
         byte[] buf = new byte[1];
         AudioFormat af = new AudioFormat(SAMPLE_RATE,8,1,true,false);
         SourceDataLine sdl = AudioSystem.getSourceDataLine(af);
         sdl.open(af);
         sdl.start();
         for (int i=0; i < msecs*8; i++) {
             double angle = i / (SAMPLE_RATE / hz) * 2.0 * Math.PI;
             buf[0] = (byte)(Math.sin(angle) * 110.0);
             sdl.write(buf,0,1);
         }
         sdl.drain();
         sdl.stop();
         sdl.close();
     }

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

             Tone.sound(1000,100);
             Tone.sound(100,1000);
             Tone.sound(5000,100);
         } catch (LineUnavailableException lue) {
             System.out.println(lue);
         }
     }
}

Il punto della situazione

Giugno 11, 2008 - No Responses

Sono impegnato con gli esami, quindi il progetto è fermo.

Ecco qui come dovrebbe essere l’algoritmo (per sommi capi) della mia applicazione.

(il disegno è stato realizzato sul sito best4c.com,
oppure potete andare anche su drawanywhere.com..
..in entrambi i casi dovete registrarvi, free account, per poter poi salvare in immagine il grafico da Voi appena creato)

Esempio di prova per una IndexTreeMap

Maggio 23, 2008 - No Responses

Riporto qui un esempio di utilizzo della struttura dati IndexedTreeMap (potete vedere la versione originale a questa pagina)

Rispetto alla versione originale io ho preferito modificare l’ ArrayList list in ArrayList list per poterlo poi ordinare tramite l’istruzione java.util.Collections.sort( list );
in tal modo mi assicuro un esatta correlazione quando, tramite il metodo get() andrò a recuperare le coppie Chiave-Valore dalla TreeMap vera e propria.

Ecco l’esempio:

public class PROVAmyIndexedTreeMap
{
public static void main (String[] args)
{
myIndexedTreeMap tmi = new myIndexedTreeMap ();

tmi.put (”ciao”, “hello”);
tmi.put (”casa”, “home”);

System.out.println (tmi.get (0)); // stampa home
System.out.println (tmi.get (1)); // stampa hello

System.out.println();

System.out.println (tmi.get (”ciao”)); // stampa hello
System.out.println (tmi.getKI (”home”)); // stampa -1
System.out.println (tmi.getKI (”casa”)); // 0
System.out.println (tmi.get( tmi.getKI (”casa”) )); // home
System.out.println (tmi.getList()); // [casa, ciao]
}
}

Ed ecco il codice della classe myIndexedTreeMap

//package com.tmi;

import java.util.TreeMap;
import java.util.ArrayList;
import java.util.Collections;

public class myIndexedTreeMap
{
private ArrayList list;
private TreeMap map;

// COSTRUTTORE
public myIndexedTreeMap ()
{
list = new ArrayList ();
map = new TreeMap ();
}

public V put (K key, V value)
{
V old = map.get (key);

if (!map.containsKey (key))
{
list.add ((String) key);
Collections.sort (list);

map.put (key, value);
}

return old;
}

public ArrayList getList()
{
return list;
}

public V get (Object key)
{
return map.get (key);
}

public V get (int index)
{
return map.get (list.get (index));
}

public Object getKI (int indice)
{
return list.get (indice);
}

public int getKI (String data_univoca)
{
return list.indexOf (data_univoca);
}

public int size()
{
return map.size();
}

public boolean isEmpty()
{
return ( map.size() == 0 ) ? true : false;
}

public int getIndex_by_key (String data_univoca) // FUNZIONA SE LO CHIAMO getIndexByKey, MA LO CAMBIO
{ // PER MANTENERE OMOGENEITA’ CON IL NOME DELL’ALTRO METODO
return list.indexOf (data_univoca);
}

public Object getKey_by_index (Integer index) // NON FUNZIONA SE LO CHIAMO “getKeyByIndex”
{
return list.get (index);
}

/* AGGIUNTA DA ME IL 7 Marzo 2008 ALLE 15:46
public java.util.Collection values()
{
return map.values();
}*/

/* AGGIUNTA DA ME IL 21 Aprile 2008 ALLE 10:55 *//* TOLTA ALLE 18:13 DI lunedi 12 maggio 2008 */
//public int check()
//{
// return keyDoppioni.size();
//}

/* AGGIUNTA DA ME IL 21 Aprile 2008 ALLE 11:529 *//* TOLTA ALLE 16:30 DI lunedi 12 maggio 2008 */
//public V vs (String $avversaria)
//{
// int locationIndex = avversaria.indexOf($avversaria);
// return map.get ( arraylistORD.get (locationIndex) );
//}
//public ArrayList avv ()
//{
// return avversaria;
//}
}

Compilare digitando sul prompt dei comandi la seguente dicitura
javac PROMAmyIndexedTreeMap.java
ed eseguire il codide
digitando
java PROMAmyIndexedTreeMap

Aspetto di leggere i vostri pareri sull’utilità di questa struttura dati..
.. e se avete consigli su una struttura dati migliore… non esitate a farmelo sapere :D
Ciao

Programmare non è semplice organizzarsi non è facile

Maggio 20, 2008 - No Responses

A lunga distanza dal mio ultimo post.. ritorno a farmi vivo. Programmare richiede un piano preciso, ovvero mi sto accorgendo che NON è tanto più importante sapere come si programma (conoscere cicli, strutture, ecc.. ecc…), ma conta molto di più sapere cosa ci serve, di cosa abbiamo bisogno.. insomma quali procedure dobbiamo seguire per portare a termine i nostri calcoli di elaborazione.

Io, per esempio, mi sono bloccato perchè ad un certo punto mi sono accorto di non avere nessuna conoscenza su quale sia la maniera più sensata per confrontare dei dati (in questo caso dei risultati calcistici) registrati da una certa squadra, in un certo anno, per una certa competizione (ecc.. ecc…)

Al momento sto migliorando alcune metodi delle strutture centrali (della mia apllicazione) atte ad accogliere questi dati: inizialmente concentravo tutte le partite giocate da una stessa squadra in una unica “Tree Map Indicizzata” (detta anche “tmi”), ma ciò avrebbe voluto dire dover scorrere migliaia di dati solo per recuperarne un minuto sotto-insieme nel caso volessi ri-cercare le partite disputate in una sola stagione. Ho pertanto fatto in modo che queste partite, al momento della lettura dal database (nel mio caso un foglio di documento *.Xml), vengano collocate in una struttura gerarchica basata sulla distribuzione temporale: partendo dalla considerazione che è una squadra non gioca più di una partita in un giorno dell’anno ho fatto si di creare

  1. una tmi ‘Stagione’ che raccoglierà tutte le partite giocate da <<questa>> squadra nella stagione del biennio, per esempio, ‘1982-1983′.
  2. si scende di un livello e troviamo una nuova tmi che accoglierà i singoli anni che costituiscono il biennio citato poco fa, cioè troviamo una tmi per l’anno ‘1982′ ed un’altra tmi per l’anno ‘1983′.
  3. per ciascuna tmi dei suddetti anni vi è una tmi per ogni mese giocato: la tmi ‘1982′ conterrà 4 diverse tmi ‘mese’ ovvero ‘09′, ‘10′, ‘11′ e ‘12′ (settembre, ottobre,  novembre e dicembre) mentre la tmi dell’anno ‘1983′ (l’anno in cui terminano le competizioni calcistiche - serie A, serie B, … Coppa Italia, Coppa dei Campioni, … iniziate proprio nel settembre dell’anno precedente, il ‘1982′) conterrà i restanti mesi di gioco, da ‘01′ (Gennaio) a ‘05′ (Maggio).

ed infine, punto 4., ognuna di queste tmi ‘mese’ conterrà la coppia univoca <Giorno, Partita>. Notiamo come per questa coppia ne esistano due versioni simili contenute ciascuna nella tmi ’squadra’ di entrambe queste formazioni che si sono incontate in questo match. La Partita() contenuta nella tmi della squadra locale avrà dati propri, speculari ed in comune con la Partita() contenuta nella tmi della squadra avversaria. I dati propri possono essere il nome dell’allenatore, i dati speculari potrebbero essere il numero dei goal fatti e delle reti subite (per la squadra avversaria si invertono tali valori, ovvero il numero dei goal fatti dalla squadra locale, squadraHOME, è uguale al numero delle reti subite dalla squadraaway, ospite), invece alcuni dati in comune potrebbero essere il nome dell’arbitro, il nome dello stadio in cui si è giocato, i nomi dei marcatori, degli ammoniti o degli espulsi… insomma, nel momento in cui scrivo ciò, mi chiedo se non sia meglio gestire tutti questi dati mantenendoli comuni alle due squadre?? Ciò mi potrebbe aiutare, per esempio, a trovare tutte le partite vinte con & contro un dato allenatore… Ci rifletterò.

Per adesso completo solo l’ottimizzazione delle classe Tmi(), come vedete l’intera organizzazione dei dati -per la loro futura elaborazione- si basa su questa struttura, ma come già detto all’inizio di questo post CONTA MOLTO DI PIU’ SAPERE COSA FARCI CON I DATI (come vanno elaborati al fine di ottenerne il miglior risultato utile ai nostri scopi) PIUTTOSTO CHE SAPERE COME ORGANIZZARLI/ACQUISIRLI AL MEGLIO NELLA MEMORIA RAM DEL NOSTRO CALCOLTAORE.

Ciao ragazzi, e se passate da qui, fatemi sapere che ve ne pare: ogni consiglio e/o critica è ben accetta :)

Compilare java da linea di comando utilizzando l’opzione -classpath

Marzo 11, 2008 - No Responses

manholdingquestionmarksmallcropped.jpgUna piccola guida, per chi come me, si è chiesto come riuscire a compilare dei sorgenti che richiedono delle particolari librerie (*.jar).

[compilazione tramite prompt su Windows]

Per completare la compilazione avete necessità di includere queste librerie nel classpath e TUTTI vi diranno, o vi hanno già detto, di andare a modificare la variabile d’ambiente %CLASSPATH% aggiungendo la nuova directory ove avete scaricato la libreria .Jar in questione..

..ma IO No!! Non voglio modificare questa variabile, la mia è nulla e nulla deve rimanere (per vedere il valore di tale variabile digitare sulla shell di win$ozz il comando echo %classpath%). Ci sarà pure un modo per indicare al compilatore dove racattare la libreria e includerla.. ma certo che c’è!!

Esempio: prendiamo questa libreria “Flanagan.jar” che ci offre numerose funzionalità matematiche e statistiche.
Salviamola da qualche parte, sul desktop, e poi scarichiamo anche i due sorgenti di prova: RegressionExampleOne.java e RegressionExampleTwo.java.
Salviamoli nella stessa direcory dove avevamo precedentemente salvato l’intera libreria.
Bene,
a questo punto possiamo procedere così:

  1. (aprite la linea di comando e digitate) javac -classpath ./flanagan.jar; RegressionExampleOne.java
  2. (e poi digitate ancora) java -cp ./flanagan.jar; RegressionExampleOne

Occhio a non dimenticare di mettere il punto e virgola !!

Come per magia vi appare un bel plot grafico ;)

Avreste potuto procedere anche in un altro modo, estraendo l’archivio .jar, posizionando i due sorgenti di prova all’interno e poi compilando ed eseguendo normalmente Java senza aggiungere null’altro..
..ma questo, diciamolo, non è un metodo molto elegante :)

Se le cose nn vi dovessero funzionare siete invitati a scrivermi, Vi aiuterò a risolvere il vostro problema, ma per favore non bestemmiatemi contro :mrgreen:

P:S: in ambiente Linux la procedura da seguire dovrebbe essere la stessa se non che dovete sostituire lo slash “/” con il back-slash “\”

Il punto della situazione

Marzo 10, 2008 - No Responses

Ho trovato una fonte dalla quale recuperare numerosissimi dati sulle partite dei campionati passati,rsssf.
Al momento sto iniziando a creare un’applicazione che recuperi tutte queste informazioni e le inserisca in un database (operazione un po’ ardua vista la non felice formattazione delle pagine).
Spesso mi trovo sul punto di mollare tutto e mettermi a proseguire questa operazione a mano…

Sul lato applicazione “vera e propria”, sto affrontando il caso dello studio della ripetitività degli esiti PER, al momento, UNA SOLA SQUADRA.
A tal propisto consiglio la lettura di questo articolo sulla generazione di dati ciclici (”Trend“)

A presto
:)

Passata la tempesta

Febbraio 26, 2008 - No Responses

Stamattina sono andato a fare esame, di linguaggi: veniva chiesto di creare in Java un’applicazione Server-Client da implementare tramite una Coda (ovvero ove la prima richiesta inoltra sarà anche la prima ad essere elaborata).

Comunque… passata la tempesta.. ritorno a lavoricchiare sull’applicazione.

Mi rendo conto, solo adesso, che il “sotto-titoletto” di questo blog (sviluppiamo insieme un’applicazione per studiare l’andamento di eventi sportivi ed economici –&gt ;) è un po’ troppo presuntuoso..

..sto pensando di cambiarlo. Vedrò ;)

c

 i

  a

   o

Ringrazio

Febbraio 22, 2008 - No Responses

Vorrei ringraziare tutti coloro che hanno partecipato, fino ad ora, alla discussione intitolata “Ottenere da un’applet alcune variabili ma NON l’output grafico” avvenuta sul forum it.comp.java.

Il forum e le pagine di questo blog mostreranno ogni possibile soluzione che vorrete contribuire ai fini della nostra discussione.

(Concludo alla stessa maniera del forum)
Vi ringrazio immensamente.
Attendo la vostra risposta
Grazie
:)

Convertire un’applet in un’applicazione

Febbraio 20, 2008 - No Responses

La situazione al momento è questa:
data una stringa di caratteri alfa-numerici..
..riesco ad estrarre tutte le sue sottosequenze consecutive.
Esempio: data la stringa “abc”
riesco ad estrarre le seguenti sottosequenze: “a”, “b”, “ab”, “bc”, “c”.

Ora, per contare quante volte ciascuna di queste sottosequenze si ripete all’interno della stringa originale, devo intervenire tramite un algoritmo di String Matching.

Di questi algoritmi, le versioni più efficienti sono lo Zhu-Takaoka e il Tuned-Boyer-Moore (la scelta dell’uno o dell’altro dipende dalla lunghezza del pattern).

Per questi due algoritmi ho trovato in rete solo due implementazioni scritte in Java, due applet, e quindi mi sono detto che per utilizzare a mia volta il loro codice avrei dovuto riscriverle a mo’ di applicazione in stile prompt…
…oppure, dopo una rapida ricerca onLine, sono giunto a questo chiarissimo articolo che spiega - appunto :) - come convertire un’applet in un’applicazione, ma che purtroppo non è quello che serve a me.
Infatti seguendo le procedure chiaramente spiegate si evince come il risultato finale sia solo quello di richiamare l’esecuzione della classe Applet da riga di comando e non più accedendo prima al file Html che, normalmente, la incorpora.

Quello che serve a me, invece, è solo invocare i metodi della classe Applet senza ottenere l’output grafico della stessa (e in particolare miro ad ottenere solo le informazioni finali su quante volte quell’algoritmo ha contato il pattern all’interno del testo).
Ricapitolando:

  1. devo fornire al codice dell’applet due stringhe, il pattern e il testo originale
  2. devo escludere le funzionalità grafiche dell’applet
  3. devo recuperare le informazioni numeriche quali il conto delle riscontranze trovate e la posizione dei carrateri ove queste sono state contate

Lavoro duro, per uno scopo duro
:)