MokaByte Numero 24  -  Novembre 98

JGL
Java Generic Library
di 
Daniela Ruggeri
Analisi della libreria di collezioni generica della ObjectSpace.

 


 
 
 

Lo scorso 1° Settembre a Dallas, negli Stati Uniti, la ObjectSpace ha annunciato la sottoscrizione di un accordo di licenza con la SUN Microsystem per quanto riguarda l'uso della libreria JGL (Java Generic Library, la libreria di collezioni generica della ObjectSpace), all'interno della tecnologia JavaBlend™ di SUN (prodotto che rende facile la costruzione di applicazioni commerciali che permettono di gestire strutture di dati e tabelle di database come oggetti java, permettendo agli sviluppatori di manipolare tali dati senza conoscere il linguaggio SQL o capire lo schema del database). Questo accordo riconosce in pratica la JGL come lo standard industriale di fatto per quanto riguarda le librerie di collezioni generiche per la piattaforma Java. La JGL inoltre risulta essere uno dei più usati package Java con una base di installato di più di 100.000 utenti senza contare l'inserimento nei maggiori ambienti di sviluppo per Java (Microsoft J++, IBM VisualAge for Java, Interprise JBuilder, Sybase PowerJ e Symantec Visual Cafe).


 
 

Introduzione
 

Il pacchetto JDK contiene molte utilità per collezione di dati e algoritmi. Esso è stato disegnato per fornire un minimo di supporto per le funzionalità usate dalla maggior parte degli sviluppatori java.

Il pacchetto contiene più di 50 algoritmi che riguardano la gestione di arrays nativi di tipi primitivi e di oggetti, e la gestione di collezioni JDK

Essi sono algoritmi generici che possono essere adattati usando funzioni oggetto e predicati per risolvere la maggior parte di problemi di processing che possono essere incontrati

Il pacchetto JGL uscì per la prima volta con la versione 1. free in giugno 1996. L’attuale versione è la 3.1.e fornisce utilità che riguardano

In questo articolo non ci occuperemo di questo argomento in quanto è necessaria una trattazione separata su queste API attualmente sono alla versione 2.0 Beta 2. Diremo solamente che queste API sono composte dei seguenti packages:
 
package com.objectspace.event

package com.objectspace.socket

package com.objectspace.timer

package com.objectspace.util

package com.objectspace.voyager

package com.objectspace.voyager.agent

package com.objectspace.voyager.db

package com.objectspace.voyager.directory

package com.objectspace.voyager.event

package com.objectspace.voyager.holder

package com.objectspace.voyager.loader

package com.objectspace.voyager.message

package com.objectspace.voyager.security

package com.objectspace.voyager.socket

package com.objectspace.voyager.space

package com.objectspace.voyager.system

package com.objectspace.voyager.tcp

package com.objectspace.voyager.thread

package com.objectspace.voyager.transport
  I package JGL che trattano gli oggetti JGL sono: _package com.objectspace.jgl.voyager

_package com.objectspace.jgl.voyager.algorithms
 
 

 Per maggiori informazioni consultare l’indirizzo http://www.objectspace.com/voyager . I package che compongono le JGL in pratica sono:
 
 
 
 
 
 
 

 
Package
Descrizione
com.objectspace.jgl Contiene interfacce classi che gestiscono collezioni di dati e iteratiori.
com.objectspace.jgl.adapters
 Contiene adattatori per la gestione di array di tipi nativi. Per ogni tipo nativo esiste la corrisponedere classe che lo gestisce.
com.objectspace.jgl.algorithms Contiene tutti gli algoritmi JGL.
com.objectspace.jgl.functions Contiene tutte le funzioni oggetto.
com.objectspace.jgl.predicates Contiene tuttele classi predicato.
com.objectspace.jgl.util Contiene classi di utilità e speciali iteratori.
com.objectspace.jgl.voyager Contiene una versione delle classi di collezioni che possono essere usate con ObjectSpace Voyager in modalità distribuita.
com.objectspace.jgl.voyager.algorithms Contiene algoritmi distribuiti da usare con ObjectSpace Voyager.

 

Nei prossimi paragrafi descriveremo più in dettaglio le fare famiglie di oggetti JGL e per ognuno di essi verrà descritto un semplice esempio.
Gli esempi prevedono liste di dati da trattare, e un bottone per l'inserimento di nuovi dati e uno per la rimozione dei dati dalla lista. In questo modo il lettore avra' modo di effettuare vari tipi di prove. Attenzione pero' ad utilizzare il bottone Rimuovi se sul vostro browser non e' stata installata la patch che prevede l'utilizzo del metodo remove della classe List; in tal caso non potrete rimuovere elementi dalla lista, ma potrete ugualmente testare il prodotto.
 

Contenitori

JGL include 11 tipi di strutture di dati per ogni esigenza di programmazione . Esso include anche diversi array adapters that che permettono di applicare algoritmi a quegli array contenenti tipi primitivi e Vettori JDK.

Esempio di contenitore: Insieme.java. Sorgenti utilizzati:

Questo esempio mostra come si può lavorare con insieme di dati, usando la classe HashSet class, realizzando l’unione e l’intersezione di 2 insiemi di dati. Una classe HashSet (appartentente al package com.objectspace.jgl) è un contenitore di dati ottimizzato per ricerche veloci. Di seguito è mostrata l'esecuzione dell'applet Quello che occorre fare è, dopo che si è deciso il contenuto delle 2 liste, premere il tasto Esegui Nel programma vengono insizilizzate oltre che le variabili lInsieme1 e lInsieme2 di classe List, le seguenti variabili
 
  HashSet set1 = new HashSet();

  HashSet set2 = new HashSet();

  HashSet set3 = new HashSet();

  HashSet set4 = new HashSet();

Il codice che viene eseguito di conseguenza è riportato qui di seguito:
 
   if (event.target == bEsegui && event.id == Event.ACTION_EVENT) { 
//        Azzera insieme 1 e insieme 2 
          set1.clear(); 
          set2.clear();

//        Riempi con il contenuto della lista 1 
        for (int i = 0 ; i < lInsieme1.countItems() ; i++) 
            set1.add(lInsieme1.getItem(i));

//        Riempi con il contenuto della lista 2 
        for (int i = 0 ; i < lInsieme2.countItems() ; i++) 
            set2.add(lInsieme2.getItem(i));

//        Costruisci unione tra i due insiemi 
        set3 = set1.union( set2 ); 
//        Costruisci intersezione tra i due insiemi 
        set4 = set1.intersection( set2 );

//        stampa il risultato 
        taRisultato.setText("Primo Insieme = " + set1 + "\n"); 
        taRisultato.setText(taRisultato.getText() + "Secondo  Insieme = " + set2 + "\n"); 
        taRisultato.setText(taRisultato.getText() + "Unione del primo insieme con il secondo = " + set3 + "\n"); 
        taRisultato.setText(taRisultato.getText() + "Intersezione del primo insieme con il secondo = " + set4 + "\n"); 
        return true; 
    }

Come potete vedere unendo il contenuto dei contenitori set1 e set2 tramite il metodo union otteniamo il contenitore set3, mentre tramite il metodo intersection otteniamo il contenitore set4. Di seguito sono riportate le descrizioni le classi di riferimento:

Classi e Interfacce di riferimento:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.adapters.ArrayAdapter La classe astratta implementata da tutti gli array adapters.
com.objectspace.jgl.Container L’interfaccia implementata da tutti i contenitori JGL.
com.objectspace.jgl.Sequence L’interfaccia implementata da tutti i contenitori JGL che trattano seccessioni di elementi.
com.objectspace.jgl.Set L’interfaccia implementata da tutti i set JGL.

Successioni – una successione è un contenitore a una dimensione che permette accessi ai dati indicizzato e fornisce automaticamente una facile allocazione dei nuovi elelmenti.
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.Array Una dimensione, elementi disposti contiguamente in memoria, veloci inserimenti solo alla fine.
com.objectspace.jgl.Deque Una dimensione, elementi disposti non contiguamente in memoria, veloci inserimenti alle estremità della lista
com.objectspace.jgl.Dlist Ogni elemento possiede un puntatore al precedente e uno al successivo. Veloci inserimenti ovunque.
com.objectspace.jgl.Slist Ogni elemento possiede un puntatore al successivo. Veloci inserimenti alle estremità della lista. 

 

Mappe – una Mappa è una struttura di dati che permette di associare una chiave a uno o più vlori per ricercare poi velocementequei valori usando la chiave.
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.HashMap 1-a-1, 1-a-molti valori, memorizzati usando codici hash.
com.objectspace.jgl.OrderedMap 1-a-1, 1-a-molti valori, memorizzati usando in ordine.

Insiemi – un Insieme è una struttura di dati che permette di aggiungere oggetti dentro di esso e poi velocemente verificare la presenza di uno di essi.
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.HashSet Veloce ricerca dell’oggetto, memorizza gli oggetti usando codici hash.
com.objectspace.jgl.OrderedSet Veloce ricerca dell’oggetto, memorizza gli oggetti in ordine.

Code e Stacks– sono contenitori i cui principali metodi sono per l’accesso ai dati sono push() e pop().
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.PriorityQueue Preleva elementi in un determinato ordine.
com.objectspace.jgl.Queue Struttura dati che utilizzo la strategia FIFO, in modo che il primo elemento aggiunto è il primo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.PriorityQueue Preleva elementi in un determinato ordine.
com.objectspace.jgl.Queue Struttura dati che utilizzo la strategia FIFO, in modo che il primo elemento aggiunto è il primo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.Queue Struttura dati che utilizzo la strategia FIFO, in modo che il primo elemento aggiunto è il primo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.Queue Struttura dati che utilizzo la strategia FIFO, in modo che il primo elemento aggiunto è il primo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.
com.objectspace.jgl.Stack Struttura dati che utilizzo la strategia FILO, in modo che il primo elemento aggiunto è l’ultimo che viene prelevato.

 

Array Adapters – Sono contenitori di 2 tipi

Classe o Interfaccia
Descrizione
com.objectspace.jgl.adapters.BooleanArray 
com.objectspace.jgl.adapters.BooleanBuffer		 Contenitori che gestiscono collezioni di boolean e in ricerca restituiscono classi tipo Boolean.
com.objectspace.jgl.adapters.ByteArray 
com.objectspace.jgl.adapters.ByteBuffer		 Contenitori che gestiscono collezioni di byte e in ricerca restituiscono classi tipo Byte.
com.objectspace.jgl.adapters.CharArray 
com.objectspace.jgl.adapters.CharBuffer		 Contenitori che gestiscono collezioni di char e in ricerca restituiscono classi tipo Char.
com.objectspace.jgl.adapters.DoubleArray 
com.objectspace.jgl.adapters.DoubleBuffer		 Contenitori che gestiscono collezioni di double e in ricerca restituiscono classi tipo Double.
com.objectspace.jgl.adapters.FloatArray 
com.objectspace.jgl.adapters.FloatBuffer		 Contenitori che gestiscono collezioni di float e in ricerca restituiscono classi tipo Float.
com.objectspace.jgl.adapters.IntArray 
com.objectspace.jgl.adapters.IntBuffer		 Contenitori che gestiscono collezioni di int e in ricerca restituiscono classi tipo Integer.
com.objectspace.jgl.adapters.LongArray 
com.objectspace.jgl.adapters.LongBuffer		 Contenitori che gestiscono collezioni di long e in ricerca restituiscono classi tipo Long.
com.objectspace.jgl.adapters.ObjectArray Contenitore che gestisce collezioni di Object e in ricerca restituiscono classi tipo Object.
com.objectspace.jgl.adapters.ShortArray 
com.objectspace.jgl.adapters.ShortBuffer		 Contenitori che gestiscono collezioni di short e in ricerca restituiscono classi tipo Short.
com.objectspace.jgl.adapters.VectorArray Contenitore che gestisce Vector JDK

 
 

Algoritmi
Una delle maggiori forze di JGL è la gestione di oltre 50 algoritmi riusabili che vanno dalla gestione di semplici operazioni di filtro a complessi e veloci sort. Invece di nascondere algoritmi entro contenitori, gli algoritmi JGL sono incapsulati entro le proprie classi e possono agire su un gran varietà di strutture di dati inclusi i contenitori JGL, i contenitori JDK containers, e nativi arrays Java. Tutti gli algoritmi relativi ad una determinata categoria sono incapsulati come metodi public static nella stessa classe. Per esempio tutti gli algoritmi di sort sono metodi della classe Sorting.
Queste classi vengono gestite dal package com.objectspace.jgl.algorithms
Esempio di algorimo: Algoritmo.java
Sorgenti utilizzati:

Questo esempio mostra come è possibile ordinare in maniera molto semplice il contenuto del contenitore Array,  usando la classe algoritmo Sorting.
 

 

Quello che occorre fare è, dopo che si è deciso il contenuto della lista, premere il tasto Esegui

Nel   programma vengono inizializzate oltre che la variabili lInsieme1 di classe List, le seguenti variabili

  Array array = new Array();
Il codice che viene eseguito di conseguenza è riportato qui di seguito:
if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          array.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            array.add(new Integer(Integer.parseInt(lInsieme1.getItem(i))));

//        stampa il risultato

        taRisultato.setText("Array non ordinata = " + array + "\n");

        Sorting.sort( array );

        taRisultato.setText(taRisultato.getText() + "Array ordinata = " + array + "\n");

        return true;

}

Come potete vedere tutilizzando il metodo sort della classe algortimo Sorting si ottiene l'ordinamento degli elementi del contenitore array.

Di seguito sono riportate le descrizioni le classi di riferimento per gli Algoritmi:

 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.algorithms.Applying Questa classe ha una coppia di algoritmi per applicare la stessa Funzione Oggetto ad ogni elemento di un contenitore: 
  • forEach() applica una funzione unaria.
  • inject() calculates un iniziale risultato chiamando una funzione binaria con il primo parametro impostato ad un iniziale valore e il secondo parametro uguale al primo elemento del contenitore. Dopo di che la formula viene ripetuta applicandola iterativamente dove questa volta abbiamo come primo parametro il risultato del precedente calcolo e come secondo l’elemento attuale.
com.objectspace.jgl.algorithms.Comparing Effettua vari tipi di test sul confronto di 2 Contenitori
com.objectspace.jgl.algorithms.Copying Questa classe contiene una gran varietà di algoritmi di copia per aggiungere il contenuto di un contenitore ad un altro contenitore. 

Per effettuare questa operazioni viene utlizzato il metod add().
com.objectspace.jgl.algorithms.Counting Questa classe possiede diversi algoritmi che contano gli elementi di un contenitore uguali ad un determinato valore o che soddisfano un determinato predicato unario.
com.objectspace.jgl.algorithms.Filling Riempie tutto o in parte un contenitore con uno specifico valore.
com.objectspace.jgl.algorithms.Filtering Ha diversi algoritmi che gestiscono filtri a collezioni di dati. 

Per esempio i metodi select() e reject() ritonano una successione che rispettivamente soddisfa o non soddisfa determinati predicati
com.objectspace.jgl.algorithms.Finding Ha diversi algoritmi che localizzano elementi in un contenitore uguali ad un determinato valore o che soddisfano un determinato predicato unario. 

Per esempio, detect() ritorna il primo oggetto che soddisfa un determinato predicato unario, e some() ritorna true se esiste al minimo un elemento che soddisfa un determinato predicato unario.
com.objectspace.jgl.algorithms.Heap Interviene su collezioni aggiungendo, togleindo elementi e ordinandoli in modo da soddisefare determinati predicati.
com.objectspace.jgl.algorithms.MinMax Trova il minimo e il massimo di una successione.
com.objectspace.jgl.algorithms.Permuting Effettua permutazioni di una successione.
com.objectspace.jgl.algorithms.Printing Stampa successioni e contenitori
com.objectspace.jgl.algorithms.Removing Rimuove un oggetto o un elemento da un contenitore che soddisfa un determinato predicato unario.
com.objectspace.jgl.algorithms.Replacing Aggiorna un oggetto o un elemento da un contenitore che soddisfa un determinato predicato unario.
com.objectspace.jgl.algorithms.Reversing Inverte gli elementi di una successione.
com.objectspace.jgl.algorithms.Rotating Ruota gli elemneti di una successione.
com.objectspace.jgl.algorithms.SetOperations Effettua l’unione, l’intersezione la differenza e l’inclusione di due collezioni di dati.
com.objectspace.jgl.algorithms.Shuffling Mescola gli elementi di una successione in maniera casuale.
com.objectspace.jgl.algorithms.Sorting Questa classe effettua veloci ed efficienti ordinamenti di ogni successione di dati. 

Per default ogni elemento è ordinato secondo il codice hash. 

Per cambiare il default associare algoritmo di sort un predicato binario. In questo modo un object A sarà posto alla sinistra dell’object B se il predicato ritornerà true , se gli oggetti A e B sono i parametri del predicato.
com.objectspace.jgl.algorithms.Swapping Sposta elementi o successioni nell’ambito dello stesso contenitore o fra due contenitori.
com.objectspace.jgl.algorithms.Transforming Questa classe contiene una coppia di algoritmi per trasformare un contenitore in un'altra versione dello stesso. La trasformazione è determinata da una funzione unaria. 

Esistono ache algoritmi con una funzione binaria che partendo da due contenitori generano il risultato in un terzo.

 
 

Funzioni Oggetto
JGL contiene più di 30 funzioni oggetto.
Quando una funzione oggetto processa un parametro è chiamata unaria mentre se ne processa due è chiamata binaria. Vi sono due principali tipi di funzioni oggetto:

  1. I Predicati che ritornano sempre un booleano. Usato soprattutto per sort. Vengono gestiti del package com.objectspace.jgl.predicates.
  2. Funzioni generali che eseguono arbitrarie operazioni e ritornano un Object. Vengono gestite del package com.objectspace.jgl.functions.


Esempio di predicato: Predicato.java
Sorgenti utilizzati:

Questo esempio mostra come è possibile ordinare in maniera molto semplice il contenuto del contenitore Array,  usando la classe algoritmo Sorting  algoritmo con il metodo sort questa volta non solo applicato al contenitore Array ma anche al predicato binario GreaterNumber
Quello che occorre fare è, dopo che si è deciso il contenuto della lista, premere il tasto Esegui
Nel   programma vengono inizializzate oltre che la variabili lInsieme1 di classe List, le seguenti variabili
  Array array = new Array();
Il codice che viene eseguito di conseguenza è riportato qui di seguito:
   if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          array.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            array.add(new Integer(Integer.parseInt(lInsieme1.getItem(i))));

//        stampa il risultato

        taRisultato.setText("Array non ordinata = " + array + "\n");

//        Crea il predicato del piu' grande numero

        BinaryPredicate predicate = new GreaterNumber();

//        Ordina discendente a partire dal più grande numero grande numero

        Sorting.sort( array, predicate ); // Sort in descending order.

        taRisultato.setText(taRisultato.getText() + "Array ordinata dal piu' grande numero = " + array + "\n");

        return true;

    }

Come potete vedere utilizzando il metodo sort della classe algortimo Sorting si ottiene l'ordinamento degli elementi del contenitore array applicando la condizione iterativa stabilita da GreaterNumber e cioè che l'elemento che segue deve essere superiore di quello precedente.
Di seguito sono riportate le descrizioni le classi di riferimento per funzioni e predicati:
 

Interfacce di riferimento:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.BinaryFunction Viene implementata da tutte le funzioni oggetto binarie. 
com.objectspace.jgl.BinaryPredicate Viene implementata da tutte le predicati oggetto binari. 
com.objectspace.jgl.UnaryFunction Viene implementata da tutte le funzioni oggetto unarie. 
com.objectspace.jgl.UnaryPredicate Viene implementata da tutte le predicati oggetto unari.

Classi che implementano l’interfaccia BinaryFunction (Funzioni Oggetto binarie):

 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.functions.BinaryCompose P( Q( x ), R( x ) ) 

Ritorna il risultato dell’esecuzione della funzione binaria P sulle funzioni unarie Q ed R.
com.objectspace.jgl.functions.BinaryPredicateFunction P( x, y ) 

Ritorna true se risulta verificata la condizione rappresentata dal predicato binario P applicato sugli oggetti x ed y.
com.objectspace.jgl.functions.ConstantFunction V 

Ritorna sempre lo stesso valore memorizzato al momento della creazione dell’istanza della funzione.
com.objectspace.jgl.functions.DividesNumber x / y Divisione fra 2 elementi
com.objectspace.jgl.functions.MinusNumber x – y Sottrazione tra 2 elementi
com.objectspace.jgl.functions.ModulusNumber x % y Modulo di x per y
com.objectspace.jgl.functions.PlusNumber x + y Somma fra 2 elementi
com.objectspace.jgl.functions.PlusString x.toString() + y.toString() Cincatenzaione di stringhe
com.objectspace.jgl.functions.SwappedBinaryFunction P( y, x ) 

Ritorna il risultato dell’esecuzione della funzione binaria P sugli oggetti x e y invertiti di posto.
com.objectspace.jgl.functions.TimesNumber x * y Moltiplicazione di 2 elementi

Classi che implementano l’interfaccia BinaryPredicate (Predicati o condizioni binarie):
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.predicates.BinaryAnd P( x, y ) && Q( x, y ) 

Ritorna true se il risultato di tutti i predicati binari (P, Q, ecc.) è true.
com.objectspace.jgl.predicates.BinaryComposePredicate P( Q( x ), R( x ) ) 

Ritorna true a secondo dell’esecuzione della funzione binaria P sulle funzioni unarie Q ed R.
com.objectspace.jgl.predicates.BinaryNot !P( x, y ) 

Ritorna true se il risultato dell’esecuzione di un predicato binario è false
com.objectspace.jgl.predicates.BinaryOr
P( x, y ) || Q( x, y )
Ritorna true se il risultato di almeno un predicato binario (P, Q, ecc.) è true.
com.objectspace.jgl.predicates.BinaryTern P( x, y ) ? Q( x, y ) : R( x, y ) 

Ritorna il risultato del predicato binario Q se il risultato del predicato binario P è true, altrimenti Ritorna il risultato del predicato binario R
com.objectspace.jgl.predicates.ConstantPredicate V 

Ritorna sempre lo stesso valore true o falsememorizzato al momento della creazione dell’istanza del predicato.
com.objectspace.jgl.predicates.EqualNumber x == y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se i due operandi sono uguali.
com.objectspace.jgl.predicates.EqualString x.toString().equals( y.toString() ) 

E’ un predicato binario ritorna true se i due operandi trasformati in stringhe sono uguali.
com.objectspace.jgl.predicates.EqualTo x.equals( y ) 

E’ un predicato binario che ritorna true se i due operandi sono uguali usando il metodo standard equals().
com.objectspace.jgl.predicates.GreaterEqualNumber x >= y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se il primo operando è maggiore o uguale del secondo.
com.objectspace.jgl.predicates.GreaterEqualString x.toString().compareTo( y.toString() ) >= 0 

E’ un predicato binario ritorna true se il primo operando come stringa è maggiore o uguale del secondo come stringa.
com.objectspace.jgl.predicates.GreaterNumber x > y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se il primo operando è maggiore del secondo.
com.objectspace.jgl.predicates.GreaterString x.toString().compareTo( y.toString() ) > 0 

E’ un predicato binario ritorna true se il primo operando come stringa è maggiore del secondo come stringa.
com.objectspace.jgl.predicates.HashComparator x.hashCode() < y.hashCode() 

E’ un predicato binario che ritorna true se il codice hash del primo operando è minore del codice hash del secondo operando. 

E’ usato specialmente per ordinare numeri appartenenti a diverse sottoclassi di Number confrontabili solo attraverso il loro codice hash.
com.objectspace.jgl.predicates.IdenticalTo x == y 

E’ un predicato binario che ritorna true se il primo operando è esattamente lo stesso del secondo usando l’operatore standard Java ==. 

(identità di oggetti)
com.objectspace.jgl.predicates.LessEqualNumber x <= y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se il primo operando è minore o uguale del secondo.
com.objectspace.jgl.predicates.LessEqualString x.toString().compareTo( y.toString() ) <= 0 

E’ un predicato binario ritorna true se il primo operando come stringa è minore o uguale del secondo come stringa.
com.objectspace.jgl.predicates.LessNumber x < y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se il primo operando è minore del secondo.
com.objectspace.jgl.predicates.LessString x.toString().compareTo( y.toString() ) < 0 

E’ un predicato binario ritorna true se il primo operando come stringa è minore del secondo come stringa.
com.objectspace.jgl.predicates.LogicalAnd x && y 

Ritorna il risultato in AND delle due istanze x e y di Boolean.
com.objectspace.jgl.predicates.LogicalOr x || y 

Ritorna il risultato in OR delle due istanze x e y di Boolean.
com.objectspace.jgl.predicates.NotEqualNumber x != y 

E’ un predicato binario in cui ambedue gli operandi x ed y sono instanze della classe Number e ritorna true se il primo operando è diverso dal secondo.
com.objectspace.jgl.predicates.NotEqualString !x.toString().equals( y.toString() ) 

E’ un predicato binario ritorna true se il primo operando come stringa è diverso dal secondo come stringa.
com.objectspace.jgl.predicates.NotEqualTo !x.equals( y ) 

E’ un predicato binario che ritorna true se i due operandi non sono uguali usando il metodo standard equals().
com.objectspace.jgl.predicates.NotIdenticalTo x != y 

E’ un predicato binario che ritorna true se il primo operando non è lo stesso del secondo usando l’operatore standard Java ==.
com.objectspace.jgl.predicates.SwappedBinaryPredicate P( y, x ) 

Se gli operandi sono gli oggetti x e y e P è un predicato binario, l’applicazione di questa classe dà come risultato quello che si otterrebbe applicando il predicato P agli operandi x e y in ordine inverso.

Classi che implementano l’interfaccia UnaryFunction (Funzioni Oggetto unarie):
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.functions.BindFirst
 P( V, x ) 

Funzione Unaria che permette l’applicazione di una funzione binaria V a un oggetto predefenito x come primo operando, e ad un operando che verrà passato al momento dell’applicazione del metodo execute() come secondo operando. 

 
com.objectspace.jgl.functions.BindSecond P( x, V ) 

Funzione Unaria che permette l’applicazione di una funzione binaria V un operando che verrà passato al momento dell’applicazione del metodo execute() come primo operando e ad a un oggetto predefenito x come secondo operando.
com.objectspace.jgl.functions.ConstantFunction V 

Ritorna sempre lo stesso valore memorizzato al momento della creazione dell’istanza della funzione.
com.objectspace.jgl.functions.Hash x.hashCode() 

Ritona il codice hash del suo operando.
com.objectspace.jgl.functions.IdentityFunction X 

Riorna il suo operando.
com.objectspace.jgl.functions.LengthString x.toString().length 

Ritorna la lunghezza del suo operando come stringa
com.objectspace.jgl.functions.NegateNumber -x 

Ritorna il valore del suo operando assunto come istanza della classe Number invertito di segno.
com.objectspace.jgl.functions.Print stream.println( x ) 

Stampa il suo operando x usando il metodo println applicato all’istanza stream della classe PrintStream
com.objectspace.jgl.functions.SelectFirst x.first 

Ritorna il primo oggetto dell’istanza x della classe com.objectspace.jgl.Pair (oggetto contenente una coppia di oggetti)
com.objectspace.jgl.functions.SelectSecond x.second 

Ritorna il secondo oggetto dell’istanza x della classe com.objectspace.jgl.Pair (oggetto contenente una coppia di oggetti)
com.objectspace.jgl.functions.ToString x.toString() 

Ritorna il suo operando trasformato in stringa
com.objectspace.jgl.functions.UnaryCompose P( Q( x ) ) 

Ritorna il risultato dell’esecuzione della funzione unaria P sulla funzioni unaria Q.
com.objectspace.jgl.functions.UnaryPredicateFunction P( x ) 

Ritorna true se risulta verificata la condizione rappresentata dal predicato unario P applicato sull’oggetto x.

Classi che implementano l’interfaccia UnaryPredicate (Predicati o condizioni unarie):
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.predicates.BindFirstPredicate P( V, x ) 

Predicato Unario che permette l’applicazione di una Predicato binario V a un oggetto predefenito x come primo operando, e ad un operando che verrà passato al momento dell’applicazione del metodo execute() come secondo operando.
com.objectspace.jgl.predicates.BindSecondPredicate P( x, V ) 

Predicato Unario che permette l’applicazione di una funzione binaria V un operando che verrà passato al momento dell’applicazione del metodo execute() come primo operando e ad a un oggetto predefenito x come secondo operando.
com.objectspace.jgl.predicates.ConstantPredicate V 
Ritorna sempre lo stesso valore memorizzato al momento della creazione dell’istanza del predicato.
com.objectspace.jgl.predicates.InstanceOf x instanceof C 
Applica la chiave instanceof all’oggetto x e la classe Class
com.objectspace.jgl.predicates.LogicalNot !x 

Ritorna true se x che deve essere un’istanza della classe Boolean è false.
com.objectspace.jgl.predicates.NegativeNumber x < 0 

E’ un predicato binario in cui l’operando x è un’instanze della classe Number e ritorna true se l’operando è negativo.
com.objectspace.jgl.predicates.PositiveNumber x > 0 

E’ un predicato binario in cui l’operando x è un’instanze della classe Number e ritorna true se l’operando è positivo.
com.objectspace.jgl.predicates.UnaryAnd P( x ) && Q( x ) 

Ritorna true se il risultato di tutti i predicati unari (P, Q, ecc.) è true.
com.objectspace.jgl.predicates.UnaryComposePredicate P( Q( x ) ) 

Ritorna true a secondo dell’esecuzione della funzione unaria P sulla funzione unaria Q.
com.objectspace.jgl.predicates.UnaryNot !P( x ) 

Ritorna true se il risultato dell’esecuzione di un predicato unario è false
com.objectspace.jgl.predicates.UnaryOr P( x ) || Q( x ) 

Ritorna true se il risultato di almeno un predicato unario (P, Q, ecc.) è true
com.objectspace.jgl.predicates.UnaryTern P( x ) ? Q( x ) : R( x ) 

Ritorna il risultato del predicato unario Q se il risultato del predicato unario P è true, altrimenti ritorna il risultato del predicato unario R

 
 

Iteratori
La maggior parte di programmatori hanno familiarità con il concetto di iterator, cioè un oggetto che può essere usato per processare sequenze di elementi siano essi in un contenitore JGL container, o un contenitore JDK, o in un’array nativa java, o in un Java stream, o altre tipi di sequenze. La classe Enumeration del JDK è un tipo di iteratore che è creato invocando il metodo elements() su un contenitore JDK. Quando viene creato un oggetto Enumeration per la prima volta esso si posiziona sul primo elemento del contenitore. Finché hasMoreElements() ritorna true, esso può usare il metodo nextElement() per ottenere il prossimo elemento.e la classe Enumeration avanza al prossimo elemento.

Ma un Enumeration presente già nelle API standard è una forma limitata di iteratore perché è solo in lettura e perché permette l’avanzamento nel contenitore di solo 1 elemento per volta.. JGL include una più potente gerarchia di interfaccia che abbraccia ed estende Enumeration come mostrati nel seguente diagramma:
 


 

Esempio di predicato: Iteratore.java

Sorgenti utilizzati:

Questo esempio mostra come è possibile trasformare i dati del contenitore DList  da minuscolo a maiscolo usando 2 istanze di classe iterator ForwardIterator per scorrere gli elementi della lista. Quello che occorre fare è, dopo che si è deciso il contenuto della lista, premere il tasto Esegui. Nel   programma vengono inizializzate oltre che la variabili lInsieme1 di classe List, le seguenti variabili
  DList list = new DList();
Il codice che viene eseguito di conseguenza è riportato qui di seguito:
//        Codice eseguito nel metodo handleEvent

if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          list.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            list.add(lInsieme1.getItem(i));

//        stampa il risultato

        taRisultato.setText("Lista prima = " + list + "\n");

//        Trasforma tutto in maiuscolo

        maiuscolo(list);

        taRisultato.setText(taRisultato.getText() + "Lista dopo = " + list + "\n");

        return true;

 }

//        Metodo maiuscolo

 static void maiuscolo(com.objectspace.jgl.Container container )

    {

    // ottiene un iterator posizionato sul primo elemento del contenitore

    ForwardIterator iterator = container.start();
 
 

    // ottiene un iterator posizionato sull'ultimo elemento del contenitore

    ForwardIterator end = container.finish();
 
 

    // Loop su ogni elemento.

    while ( !iterator.equals( end ) )

      {

      String current = (String) iterator.get();

      // Agiorna il corrente elemento con uno equaivalente ma tutto

      // maiuscolo.

      iterator.put( current.toUpperCase() );

      iterator.advance(); // Avanza di un elemento.

      }

    }

Come potete vedere utilizzando nel  metodo maiuscolo, vengono istanziati iterator e end della classe Iterator, il primo che punta all'inizio del contenitore list, e il secondo alla fine. Poi si fa avanzare iterator fino a quando non diventa uguale a end e per ognuno si rende maisuolo l'elemento. Di seguito sono riportate le descrizioni le classi di riferimento per Iteratori:

Interfacce di riferimento:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.InputIterator Permette di leggere in una lista un elemento alla volta nella direzione avanti.
com.objectspace.jgl.OutputIterator Permette di scrivere in una lista un elemento alla volta nella direzione avanti.
com.objectspace.jgl.ForwardIterator Combina le caratteristiche delle interfacce InputIterator e OutputIterator.
com.objectspace.jgl.BidirectionalIterator
Come l’interfaccia ForwardIterator con in più la possibilità di scorrere gli elementi anche indietro.
com.objectspace.jgl.RandomAccessIterator Come l’interfaccia BidirectionalIterator con in più la possibilità di effettuare dei salti casuali.

Classi che implementano l’interfaccia InputIterator:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.InsertIterator Permette di inserire oggetti in uno specifico contenitore.
com.objectspace.jgl.ObjectOutputStreamIterator Permette di scivere oggetti in un java.io.ObjectOutputStream.
com.objectspace.jgl.OutputStreamIterator
Permette di scrivere oggetti in un java.io.OutputStream.

Classi che implementano l’interfaccia ForwardIterator:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.HashMapIterator Scorre una lista in avanti secondo l’ordine stabilito da un HashMap.
com.objectspace.jgl.HashSetIterator Scorre una lista in avanti secondo l’ordine stabilito da un HashSet.
com.objectspace.jgl.SlistIterator Scorre una lista in avanti secondo l’ordine stabilito da un SList.

Classi che implementano l’interfaccia BidirectionalIterator:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.DListIterator Scorre una lista in entrambe le direzioni secondo l’ordine stabilito da un DList.
com.objectspace.jgl.OrderedMapIterator Scorre una lista in entrambe le direzioni secondo l’ordine stabilito da un OrderedMap.
com.objectspace.jgl.OrderedSetIterator Scorre una lista in entrambe le direzioni secondo l’ordine stabilito da un OrderedSet.
com.objectspace.jgl.ReverseIterator Scorre all’indietro il contenuto di una struttura di dati che supporta lo scorrimento bidirezionale. 

.

Classi che implementano l’interfaccia RandomAccessIterator:
 
Classe o Interfaccia
Descrizione
com.objectspace.jgl.ArrayIterator Scorre avanti, indietro e a salti casuali il contenuto di un Array.
com.objectspace.jgl.BooleanIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi boolean.
com.objectspace.jgl.ByteIterator
Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi byte.
com.objectspace.jgl.CharIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi char.
com.objectspace.jgl.DequeIterator Scorre avanti, indietro e a salti casuali il contenuto di un Deque.
com.objectspace.jgl.DoubleIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi double.
com.objectspace.jgl.FloatIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi float.
com.objectspace.jgl.IntIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi int.
com.objectspace.jgl.LongIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi long.
com.objectspace.jgl.ShortIterator Scorre avanti, indietro e a salti casuali il contenuto di un array di tipi primitivi short.
com.objectspace.jgl.VectorIterator Scorre avanti, indietro e a salti casuali il contenuto di un java.util.Vector.

 
 

Sorgenti
 

Comune.java
import java.awt.*;
 
 

public class Comune

{

    static int numeroEsercizio=1;

    static int numeroInsieme = 1;

    static List lInsieme11 = new List();

    static List lInsieme12 = new List();

    static List lInsieme21 = new List();

    static List lInsieme31 = new List();

    static List lInsieme41 = new List();

}

fNuovoElemento.java
import java.awt.*;

import java.awt.event.*;
 
 

public class fNuovoElemento extends Frame

{

  TextField taValore = new TextField();

  Button bConferma = new Button();
 
 
 
 

  public fNuovoElemento()

  {

    this.resize(251, 164);

    this.setTitle("Digitare Nuovo Valore");

    taValore.setBackground(Color.white);

    taValore.setFont(new Font("TimesRoman", 0, 14));

    taValore.reshape(19, 51, 213, 27);

    bConferma.setFont(new Font("TimesRoman", 1, 12));

    bConferma.reshape(81, 105, 89, 26);

    bConferma.setLabel("Conferma");

    this.setLayout(null);

    this.add(taValore);

    this.add(bConferma);

    taValore.requestFocus();

  }
 
 

   public boolean handleEvent(Event event) {

        if (event.id == Event.WINDOW_DESTROY) {

            hide();

            return true;

         }
 
 

         if (event.target == bConferma && event.id == Event.ACTION_EVENT) {

              if (!taValore.getText().trim().equals(""))

                    if (Comune.numeroEsercizio == 1)

//                      Primo Esercizio (contenitori)

                          if (Comune.numeroInsieme == 1)

                                Comune.lInsieme11.addItem(taValore.getText().trim());

                          else

                                Comune.lInsieme12.addItem(taValore.getText().trim());

                    else if (Comune.numeroEsercizio == 2)

//                       Secondo Esercizio (algoritmi)

                          try {

                            int i = Integer.parseInt(taValore.getText().trim());

                            Comune.lInsieme21.addItem(taValore.getText().trim());

                          } catch  (NumberFormatException e) {}

                    else if (Comune.numeroEsercizio == 3)

//                        Terzo Esercizio (Predicati)

                          try {

                            int i = Integer.parseInt(taValore.getText().trim());

                            Comune.lInsieme31.addItem(taValore.getText().trim());

                          } catch  (NumberFormatException e) {}

                    else if (Comune.numeroEsercizio == 4)

//                        Quarto Esercizio (Iteratori)

                          Comune.lInsieme41.addItem(taValore.getText().trim());

               hide();

               return true;

            }

            return super.handleEvent(event);

       }
 
 

}

Insieme.java
import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import com.objectspace.jgl.*;
 
 

//import com.sun.java.swing.UIManager;

public class Insieme extends Applet

{

  boolean isStandalone = false;

  static List lInsieme1 = Comune.lInsieme11;

  static List lInsieme2 = Comune.lInsieme12;

  Button bEsegui = new Button();

  Label label1 = new Label();

  Label label2 = new Label();

  Button bRimuovi2 = new Button();

  Button bAggiungi2 = new Button();

  Button bAggiungi1 = new Button();

  Button bRimuovi1 = new Button();

  TextArea taRisultato = new TextArea();

  HashSet set1 = new HashSet();

  HashSet set2 = new HashSet();

  HashSet set3 = new HashSet();

  HashSet set4 = new HashSet();

  Label label3 = new Label();
 
 

  public void init()

  {

    Comune.numeroEsercizio = 1;

    this.setFont(new Font("TimesRoman", 0, 14));

    this.setForeground(Color.yellow);

    this.setBackground(new Color(180, 0, 0));

    this.resize(506, 393);

    lInsieme1.setFont(new Font("TimesRoman", 0, 14));

    lInsieme1.setForeground(Color.black);

    lInsieme1.setBackground(Color.white);

    lInsieme1.reshape(22, 36, 143, 143);

    lInsieme2.setForeground(Color.black);

    lInsieme2.setBackground(Color.white);

    lInsieme2.setFont(new Font("TimesRoman", 0, 14));

    lInsieme2.reshape(258, 38, 143, 142);

    bEsegui.setForeground(Color.black);

    bEsegui.setFont(new Font("TimesRoman", 1, 14));

    bEsegui.reshape(194, 340, 116, 33);

    bEsegui.setLabel("Esegui");

    label2.setFont(new Font("TimesRoman", 2, 14));

    label2.reshape(265, 5, 141, 23);

    label2.setText("Lista Secondo Insieme");

    bRimuovi2.setLabel("Rimuovi");

    bAggiungi2.setFont(new Font("TimesRoman", 0, 12));

    bAggiungi2.setForeground(Color.black);

    bAggiungi2.reshape(417, 82, 71, 24);

    bAggiungi2.setLabel("Aggiungi");

    bAggiungi1.setFont(new Font("TimesRoman", 0, 12));

    bAggiungi1.setForeground(Color.black);

    bAggiungi1.reshape(176, 82, 71, 24);

    bAggiungi1.setLabel("Aggiungi");

    bRimuovi1.setLabel("Rimuovi");

    taRisultato.setBackground(Color.white);

    taRisultato.setForeground(Color.black);

    taRisultato.reshape(11, 214, 484, 114);

    label3.setText("Risutato del test su un contenitore");

    label3.reshape(12, 186, 412, 23);

    label3.setFont(new Font("TimesRoman", 2, 14));

    label3.setForeground(Color.yellow);

    bRimuovi1.reshape(176, 118, 71, 24);

    bRimuovi1.setForeground(Color.black);

    bRimuovi1.setFont(new Font("TimesRoman", 0, 12));

    bRimuovi2.reshape(417, 117, 71, 24);

    bRimuovi2.setForeground(Color.black);

    bRimuovi2.setFont(new Font("TimesRoman", 0, 12));

    label1.setFont(new Font("TimesRoman", 2, 14));

    label1.reshape(24, 3, 141, 23);

    label1.setText("Lista Primo Insieme");

    this.setLayout(null);
 
 

    lInsieme1.addItem("red");

    lInsieme1.addItem("blue");

    lInsieme1.addItem("green");

    lInsieme1.select(0);

    lInsieme2.addItem("yellow");

    lInsieme2.addItem("blue");

    lInsieme2.select(0);
 
 

    this.add(lInsieme1);

    this.add(bAggiungi1);

    this.add(bRimuovi1);

    this.add(bRimuovi2);

    this.add(bAggiungi2);

    this.add(lInsieme2);

    this.add(bEsegui);

    this.add(label2);

    this.add(label1);

    this.add(taRisultato);

    this.add(label3);

  }
 
 

public boolean handleEvent(Event event) {
 
 

        if (event.target == bRimuovi1 && event.id == Event.ACTION_EVENT) {

            if (lInsieme1.countItems() > 0) {

              lInsieme1.remove(lInsieme1.getSelectedIndex());

              if (lInsieme1.countItems() > 0) lInsieme1.select(0);

            }

            return true;

        }
 
 

        if (event.target == bAggiungi1 && event.id == Event.ACTION_EVENT) {

            Comune.numeroInsieme = 1;

            fNuovoElemento fne = new fNuovoElemento();

            fne.show();

            return true;

        }
 
 

        if (event.target == bAggiungi2 && event.id == Event.ACTION_EVENT) {

            Comune.numeroInsieme = 2;

            fNuovoElemento fne = new fNuovoElemento();

            fne.show();

            return true;

        }
 
 

        if (event.target == bRimuovi2 && event.id == Event.ACTION_EVENT) {

            if (lInsieme2.countItems() > 0) {

              lInsieme2.remove(lInsieme2.getSelectedIndex());

              if (lInsieme2.countItems() > 0) lInsieme2.select(0);

            }

            return true;

        }
 
 

          if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

//            Azzera insieme 1 e insieme 2

              set1.clear();

              set2.clear();
 
 

//            Riempi con il contenuto della lista 1

              for (int i = 0 ; i < lInsieme1.countItems() ; i++)

                set1.add(lInsieme1.getItem(i));
 
 

//            Riempi con il contenuto della lista 2

              for (int i = 0 ; i < lInsieme2.countItems() ; i++)

                set2.add(lInsieme2.getItem(i));
 
 

//            Costruisci unione tra i due insiemi

              set3 = set1.union( set2 );

//            Costruisci intersezione tra i due insiemi

              set4 = set1.intersection( set2 );
 
 

//            stampa il risultato

              taRisultato.setText("Primo Insieme = " + set1 + "\n");

              taRisultato.setText(taRisultato.getText() + "Secondo  Insieme = " + set2 + "\n");

              taRisultato.setText(taRisultato.getText() + "Unione del primo insieme con il secondo = " + set3 + "\n");

              taRisultato.setText(taRisultato.getText() + "Intersezione del primo insieme con il secondo = " + set4 + "\n");

              return true;

          }
 
 

    return super.handleEvent(event);

  }

}

Algoritmo.java
import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import com.objectspace.jgl.*;

import com.objectspace.jgl.algorithms.*;
 
 
 
 

public class Algoritmo extends Applet

{

//  static List lInsieme1 = new List();

  static List lInsieme1 = Comune.lInsieme21;
 
 

  static int numeroInsieme = Comune.numeroInsieme;

  Button bEsegui = new Button();

  Label label1 = new Label();

  Button bAggiungi1 = new Button();

  Button bRimuovi1 = new Button();

  TextArea taRisultato = new TextArea();

  Array array = new Array();

  Label label2 = new Label();

  public void init()

  {

    Comune.numeroEsercizio = 2;

    this.setFont(new Font("TimesRoman", 0, 14));

    this.setForeground(Color.yellow);

    this.setBackground(Color.blue);

    this.resize(506, 393);

    lInsieme1.setFont(new Font("TimesRoman", 0, 14));

    lInsieme1.setForeground(Color.black);

    lInsieme1.setBackground(Color.white);

    lInsieme1.reshape(130, 31, 143, 143);

    bEsegui.setForeground(Color.black);

    bEsegui.setFont(new Font("TimesRoman", 1, 14));

    bEsegui.reshape(194, 340, 116, 33);

    bEsegui.setLabel("Esegui");

    bAggiungi1.setFont(new Font("TimesRoman", 0, 12));

    bAggiungi1.setForeground(Color.black);

    bAggiungi1.reshape(284, 77, 71, 24);

    bAggiungi1.setLabel("Aggiungi");

    bRimuovi1.setLabel("Rimuovi");

    taRisultato.setBackground(Color.white);

    taRisultato.setForeground(Color.black);

    taRisultato.reshape(11, 212, 484, 116);

    bRimuovi1.reshape(284, 113, 71, 24);

    bRimuovi1.setForeground(Color.black);

    bRimuovi1.setFont(new Font("TimesRoman", 0, 12));

    label1.setFont(new Font("TimesRoman", 2, 14));

    label1.reshape(126, 5, 165, 23);

    label1.setText("Lista Numeri da ordinare");

    label2.setText("Risutato del test su un algoritmo");

    label2.reshape(9, 184, 412, 23);

    label2.setFont(new Font("TimesRoman", 2, 14));

    label2.setForeground(Color.yellow);

    this.setLayout(null);
 
 

    lInsieme1.addItem("2");

    lInsieme1.addItem("-1");

    lInsieme1.addItem("3");

    lInsieme1.addItem("-2");

    lInsieme1.select(0);
 
 

    this.add(lInsieme1);

    this.add(bAggiungi1);

    this.add(bRimuovi1);

    this.add(bEsegui);

    this.add(label1);

    this.add(taRisultato);

    this.add(label2);

  }
 
 
 
 

  public boolean handleEvent(Event event) {
 
 

    if (event.target == bRimuovi1 && event.id == Event.ACTION_EVENT) {

        if (lInsieme1.countItems() > 0) {

          lInsieme1.remove(lInsieme1.getSelectedIndex());

          if (lInsieme1.countItems() > 0) lInsieme1.select(0);

        }

        return true;

    }
 
 

    if (event.target == bAggiungi1 && event.id == Event.ACTION_EVENT) {

        numeroInsieme = 1;

        fNuovoElemento fne = new fNuovoElemento();

        fne.show();

        return true;

    }
 
 
 
 

    if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          array.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            array.add(new Integer(Integer.parseInt(lInsieme1.getItem(i))));

//        stampa il risultato

        taRisultato.setText("Array non ordinata = " + array + "\n");

        Sorting.sort( array );

        taRisultato.setText(taRisultato.getText() + "Array ordinata = " + array + "\n");

        return true;

    }
 
 

    return super.handleEvent(event);

  }

}

Predicato.java
<

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import com.objectspace.jgl.*;

import com.objectspace.jgl.algorithms.*;

import com.objectspace.jgl.predicates.*;
 
 
 
 

public class Predicato extends Applet

{

//  static List lInsieme1 = new List();

  static List lInsieme1 = Comune.lInsieme31;
 
 

  static int numeroInsieme = Comune.numeroInsieme;

  Button bEsegui = new Button();

  Label label1 = new Label();

  Button bAggiungi1 = new Button();

  Button bRimuovi1 = new Button();

  TextArea taRisultato = new TextArea();

  Array array = new Array();

  Label label2 = new Label();

  public void init()

  {

    Comune.numeroEsercizio = 3;

    this.setFont(new Font("TimesRoman", 0, 14));

    this.setForeground(Color.yellow);

    this.setBackground(Color.orange);

    this.resize(506, 393);

    lInsieme1.setFont(new Font("TimesRoman", 0, 14));

    lInsieme1.setForeground(Color.black);

    lInsieme1.setBackground(Color.white);

    lInsieme1.reshape(130, 31, 143, 143);

    bEsegui.setForeground(Color.black);

    bEsegui.setFont(new Font("TimesRoman", 1, 14));

    bEsegui.reshape(194, 340, 116, 33);

    bEsegui.setLabel("Esegui");

    bAggiungi1.setFont(new Font("TimesRoman", 0, 12));

    bAggiungi1.setForeground(Color.black);

    bAggiungi1.reshape(284, 77, 71, 24);

    bAggiungi1.setLabel("Aggiungi");

    bRimuovi1.setLabel("Rimuovi");

    taRisultato.setBackground(Color.white);

    taRisultato.setForeground(Color.black);

    taRisultato.reshape(11, 206, 484, 122);

    label2.setText("Risutato del test su un predicato");

    label2.reshape(13, 181, 412, 23);

    label2.setFont(new Font("TimesRoman", 2, 14));

    label2.setForeground(Color.blue);

    bRimuovi1.reshape(284, 113, 71, 24);

    bRimuovi1.setForeground(Color.black);

    bRimuovi1.setFont(new Font("TimesRoman", 0, 12));

    label1.setForeground(Color.blue);

    label1.setFont(new Font("TimesRoman", 2, 14));

    label1.reshape(126, 5, 165, 23);

    label1.setText("Lista Numeri da ordinare");

    this.setLayout(null);
 
 

    lInsieme1.addItem("2");

    lInsieme1.addItem("-1");

    lInsieme1.addItem("3");

    lInsieme1.addItem("4");

    lInsieme1.select(0);
 
 

    this.add(lInsieme1);

    this.add(bAggiungi1);

    this.add(bRimuovi1);

    this.add(bEsegui);

    this.add(label1);

    this.add(taRisultato);

    this.add(label2);

  }
 
 
 
 

  public boolean handleEvent(Event event) {
 
 

    if (event.target == bRimuovi1 && event.id == Event.ACTION_EVENT) {

        if (lInsieme1.countItems() > 0) {

            lInsieme1.remove(lInsieme1.getSelectedIndex());

            if (lInsieme1.countItems() > 0) lInsieme1.select(0);

        }

        return true;

    }
 
 

    if (event.target == bAggiungi1 && event.id == Event.ACTION_EVENT) {

        numeroInsieme = 1;

        fNuovoElemento fne = new fNuovoElemento();

        fne.show();

        return true;

    }
 
 
 
 

    if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          array.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            array.add(new Integer(Integer.parseInt(lInsieme1.getItem(i))));

//        stampa il risultato

        taRisultato.setText("Array non ordinata = " + array + "\n");

//        Crea il predicato del piu' grande numero

        BinaryPredicate predicate = new GreaterNumber();

//        Ordina discendente a partire dal più grande numero grande numero

        Sorting.sort( array, predicate ); // Sort in descending order.

        taRisultato.setText(taRisultato.getText() + "Array ordinata dal piu' grande numero = " + array + "\n");

        return true;

    }
 
 

    return super.handleEvent(event);

  }

}
Iteratore.java
 

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import com.objectspace.jgl.*;

import com.objectspace.jgl.algorithms.*;

import com.objectspace.jgl.predicates.*;
 
 
 
 

public class Iteratore extends Applet

{

//  static List lInsieme1 = new List();

  static List lInsieme1 = Comune.lInsieme41;
 
 

  static int numeroInsieme = Comune.numeroInsieme;

  Button bEsegui = new Button();

  Label label1 = new Label();

  Button bAggiungi1 = new Button();

  Button bRimuovi1 = new Button();

  TextArea taRisultato = new TextArea();

  DList list = new DList();

  Label label2 = new Label();

  public void init()

  {

    Comune.numeroEsercizio = 4;

    this.setFont(new Font("TimesRoman", 0, 14));

    this.setForeground(Color.yellow);

    this.setBackground(Color.pink);

    this.resize(506, 393);

    lInsieme1.setFont(new Font("TimesRoman", 0, 14));

    lInsieme1.setForeground(Color.black);

    lInsieme1.setBackground(Color.white);

    lInsieme1.reshape(130, 31, 143, 143);

    bEsegui.setForeground(Color.black);

    bEsegui.setFont(new Font("TimesRoman", 1, 14));

    bEsegui.reshape(194, 340, 116, 33);

    bEsegui.setLabel("Esegui");

    bAggiungi1.setFont(new Font("TimesRoman", 0, 12));

    bAggiungi1.setForeground(Color.black);

    bAggiungi1.reshape(284, 77, 71, 24);

    bAggiungi1.setLabel("Aggiungi");

    bRimuovi1.setLabel("Rimuovi");

    taRisultato.setBackground(Color.white);

    taRisultato.setForeground(Color.black);

    taRisultato.reshape(11, 203, 484, 125);

    bRimuovi1.reshape(284, 113, 71, 24);

    bRimuovi1.setForeground(Color.black);

    bRimuovi1.setFont(new Font("TimesRoman", 0, 12));

    label1.setForeground(Color.blue);

    label1.setFont(new Font("TimesRoman", 2, 14));

    label1.reshape(126, 5, 165, 23);

    label1.setText("Lista Stringhe da rendere maiuscole");

    label2.setForeground(Color.blue);

    label2.setFont(new Font("TimesRoman", 2, 14));

    label2.reshape(14, 177, 412, 23);

    label2.setText("Risutato del test sulla classe Iterator ");

    this.setLayout(null);
 
 

    lInsieme1.addItem("cane");

    lInsieme1.addItem("gatto");

    lInsieme1.addItem("cavallo");

    lInsieme1.addItem("ermellino");

    lInsieme1.select(0);
 
 

    this.add(lInsieme1);

    this.add(bAggiungi1);

    this.add(bRimuovi1);

    this.add(bEsegui);

    this.add(label1);

    this.add(taRisultato);

    this.add(label2);

  }
 
 
 
 

  public boolean handleEvent(Event event) {

    if (event.target == bRimuovi1 && event.id == Event.ACTION_EVENT) {

        if (lInsieme1.countItems() > 0) {

          lInsieme1.remove(lInsieme1.getSelectedIndex());

          if (lInsieme1.countItems() > 0) lInsieme1.select(0);

        }

        return true;

    }
 
 

    if (event.target == bAggiungi1 && event.id == Event.ACTION_EVENT) {

         fNuovoElemento fne = new fNuovoElemento();

        fne.show();

        return true;

    }
 
 
 
 

    if (event.target == bEsegui && event.id == Event.ACTION_EVENT) {

          list.clear();

//        Riempi con il contenuto della lista 1

          for (int i = 0 ; i < lInsieme1.countItems() ; i++)

            list.add(lInsieme1.getItem(i));

//        stampa il risultato

        taRisultato.setText("Lista prima = " + list + "\n");

//        Trasforma tutto in maiuscolo

        maiuscolo(list);

        taRisultato.setText(taRisultato.getText() + "Lista dopo = " + list + "\n");

        return true;

    }
 
 

    return super.handleEvent(event);

  }
 
 

  static void maiuscolo(com.objectspace.jgl.Container container )

    {

    // ottiene un iterator posizionato sul primo elemento del contenitore

    ForwardIterator iterator = container.start();
 
 

    // ottiene un iterator posizionato sull'ultimo elemento del contenitore

    ForwardIterator end = container.finish();
 
 

    // Loop su ogni elemento.

    while ( !iterator.equals( end ) )

      {

      String current = (String) iterator.get();

      // Agiorna il corrente elemento con uno equaivalente ma tutto

      // maiuscolo.

      iterator.put( current.toUpperCase() );

      iterator.advance(); // Avanza di un elemento.

      }

    }
 
 

}

Conclusione
 

Spero con questo articolo di aver dato un'idea di quanto sia potente e utile un pacchetto come le Java Generic Library.
La trattazione si è limitata ad una descrizione minima, ma come avete potuto vedere, in realtà ci sono relamente centinaia di posiibilità. Si tratta solo di volta in volta valutare quello che serve ed utilizzarlo.
 
 


MokaByte Web  1998 - www.mokabyte.it 
MokaByte ricerca nuovi collaboratori. 
Chi volesse mettersi in contatto con noi può farlo scrivendo a mokainfo@mokabyte.it