Articoli

Pubblicato il

Insert Sort

L’algoritmo di ordinamento InsertSort (ordinamento diretto) nasce dal concetto che per ordinare un array ordinato è sufficiente costruirne uno nuovo ordinato, inserendo gli elementi al posto giusto da subito. Nella pratica, non è necessario crearne uno nuovo ma dividere quello esistente in due parti, una ordinata e l’altra no.

Esempio:

Vogliamo ordinare l’insieme A = {5, 3, 2, 1, 4}.

Iterazione 1. A = {5 | 2, 3, 1, 4} → A = {2, 5 | 3, 1, 4}

Iterazione 2. A = {2, 5 | 3, 1, 4} → A = {2,3, 5 | 1, 4}

Iterazione 3. A = {2, 3, 5 | 1, 4} → A = {1, 2, 3, 5 | 4}

Iterazione 4. A = {1, 2, 3, 5 | 4} → A = {1, 2, 3,4, 5}

Codificando l’Insert Sort abbiamo:

Leggi tutto “Insert Sort”
Pubblicato il

Bubble Sort

L’algoritmo Bubble Sort  è basato sullo scambio di elementi adiacenti. Ogni coppia di elementi adiacenti viene comparata e invertita di posizione, se il primo è più grande del secondo. Quando questa operazione è stata ripetuta  per tutti gli elementi, si ha che l’elemento  più grande si trova in fondo, a destra, della sequenza considerata.

Dopodiché, si ripete questa procedura sugli elementi rimanenti, togliendo elemento più grande trovato prima.

L’algoritmo, iterando più volte  questi passaggi, fino a quando non ci saranno scambi. Allora l’array ottenuto sarà ordinato.

Leggi tutto “Bubble Sort”
Pubblicato il

Selection Sort

L’algoritmo Selection Sort è quello più semplice, quello che seguirebbe istintivamente qualsiasi persona. Da un gruppo da ordinare seleziona il più piccolo, lo toglie,  e lo inserisce nella giusta posizione in un gruppo ordinato.

In termini un po’ più tecnici, l’algoritmo ripete per n volte una procedura in grado di selezionare alla i-esima iterazione l’elemento più piccolo nell’insieme e di scambiarlo con l’elemento che in quel momento occupa la posizione i. 

Ossia, alla prima iterazione verrà selezionato l’elemento più piccolo dell’intero insieme e sarà scambiato con quello che occupa la prima posizione; alla seconda iterazione sarà selezionato il secondo elemento più piccolo dell’insieme ridotto (cioè costituito dagli elementi {a2,a3,…,an} ) e sarà scambiato con l’elemento che occupa la seconda posizione, e così via fino ad aver collocato nella posizione corretta tutti gli n elementi.

Leggi tutto “Selection Sort”
Pubblicato il

Test Java Online

1. Considerare il seguente frammento di programma Java:
int x = -5;
if (x>0) if (x>10) System.out.println("uno");
   else if (x>-6) System.out.println("due");
   else System.out.println("tre");
Cosa stampa il programma?

Question 1 of 10

2. Quale sarà l'output?
class s1 extends Thread
{ 
    public void run() 
    { 
        for(int i = 0; i < 3; i++) 
        { 
            System.out.println("A"); 
            System.out.println("B"); 
        } 
    } 
} 
class Test120 extends Thread 
{ 
    public void run() 
    { 
        for(int i = 0; i < 3; i++) 
        { 
            System.out.println("C"); 
            System.out.println("D"); 
        } 
    } 
    public static void main(String args[]) 
        { 
        s1 t1 = new s1(); 
        Test120 t2 = new Test120(); 
        t1.start(); 
        t2.start(); 
    } 
}
 

Question 2 of 10

3. Dato un array di 92 elementi, qual è l’indice massimo che si può utilizzare, ossia l’indice che punta all’ultimo elemento dell’array?
A. 96, perché deve essere multiplo di 16
B. 92
C. 91

Question 3 of 10

4. Qual è il risultato dell’istruzione seguente: ArrayList<String> a = new ArrayList<>()?
A. Un errore di compilazione perché non è specificato String sul lato destro del simbolo “=”
B. Un errore a tempo di esecuzione
C. Un oggetto di classe ArrayList che può contenere solo oggetti String

Question 4 of 10

5. Quale sarà l'output del seguente codice:
class Derived 
{ 
  public void getDetails(String temp) 
  { 
    System.out.println("Derived class " + temp); 
  } 
} 

public class Test extends Derived 
{ 
  public int getDetails(String temp) 
  { 
    System.out.println("Test class " + temp); 
    return 0; 
  } 
  public static void main(String[] args) 
  { 
    Test obj = new Test(); 
    obj.getDetails("GFG"); 
  } 
}
 

Question 5 of 10

6. Dato il seguente codice, e dopo averlo eseguito attraverso i comandi:
  • javac Prova.java
  • java Prova “Questa è una prova”
Codice:
public class Test {

    public static void main(String[] args) {
        System.out.println(args [0]);
    }

}
 

 

Qual è l’output atteso?

Question 6 of 10

7. Quale sarà l’output del seguente codice
package com;

abstract class demo
{
    public int a;
    demo()
    {
        a = 10;
    }
 
    abstract public void set(int a);
     
    abstract  public void get();
 
}
 
public class Prova extends demo
{
 
    public void set(int a)
    {
        this.a = a;
    }
 
    final public void get()
    {
        System.out.println("a = " + a);
    }
 
    public static void main(String[] args)
    {
        Prova obj = new demo();
        obj.set(20);
        obj.get();
    }
}
 

Question 7 of 10

8. Una interfaccia può estendere un'altra interfaccia

Question 8 of 10

9. Posso fare l'override di un metodo statico?

Question 9 of 10

10. Quale sarà l'output del seguente codice:
class Test
{
    String str = "a";
 
    void A()
    {
        try
        {
            str +="b";
            B();
        }
        catch (Exception e)
        {
            str += "c";
        }
    }
 
    void B() throws Exception
    {
        try
        {
            str += "d";
            C();
        }
        catch(Exception e)
        {
            throw new Exception();
        }
        finally
        {
            str += "e";
        }
 
        str += "f";
 
    }
     
    void C() throws Exception
    {
        throw new Exception();
    }
 
    void display()
    {
        System.out.println(str);
    }
 
    public static void main(String[] args)
    {
        Test object = new Test();
        object.A();
        object.display();
    }
 
}
 

Question 10 of 10


 

Pubblicato il

Esempio di WebServices con Annotation – Client SOAPUI

Per creare un Web Services esistono vari modi.
In questo esempio useremo l’annotation @WebService. In particolare avremo un web services con due operazioni:

  • public String prova(String msg)
  • public Persona getPerson(String codFisc)

Il primo prende in input una stringa e restituisce un’altra stringa.
Il secondo in input  sempre una stringa ma restituisce un oggetto di tipo Persona.
Per invocarli useremo il tool SOAPUI.

Tools Usati

  • Eclipse Mars 2
  • Wildfly 10
  • SoapUI

Leggi tutto “Esempio di WebServices con Annotation – Client SOAPUI”

Pubblicato il

MDB (Message Driven Bean) in 5 minuti

MDB: Cosa sono

Di solito le comunicazioni fra i componenti di un’applicazione sono sincrone, ossia l’oggetto che effettua la chiamata e l’oggetto che viene invocato devono essere entrambi presenti affinché la comunicazione possa avvenire.
Un message-oriented middleware (MOM) è un software che consente a due componenti di comunicare in maniera asincrona. Java Messaging Service (JMS) fornisce uno standard di accesso ai MOM che costituisce un’alternativa all’utilizzo di API proprietarie; ad eccezione di Microsoft Message Queuing, la maggior parte dei prodotti MOM infatti supporta JMS. Il client notifica una certa operazione al server inviando un messaggio (il client in questo caso è detto producer). Il server inserisce i messaggi in un canale sulla quale stanno in ascolto altri client che prelevano il messaggio ed eseguono le operazioni richieste (i componenti in ascolto vengono detti consumer).
Un modello di messaging definisce il modo in cui il processo di messaging coinvolge mittenti e destinatari. I due modelli più popolari, standardizzati in Java EE, sono il point-to-point e il pubish-subscribe.
Nello schema point to point il mittente (Producer) invia un messaggio verso una particolare destinazione. Il ricevente (Consumer) sta in ascolto e riceve i messaggi su quella destinazione(chiamata coda o queue). L’intento del producer è inviare un messaggio ad uno specifico consumer che sarà l’unico a riceverlo, anche se al momento dell’invio non è disponibile. (ci sarà solo un consumer per quella coda queue). Sarà infatti il JMS Broker (servizio che gestisce lo scambio dei messaggi) a tenerlo in coda finché non sarà prelevato dal consumer.
Nello schema publish-subscribe un singolo produttore invia un messaggio ad una destinazione ( che prende il nome di topic) e tutti i consumatori che sono registrati presso quel topic possono riceverlo. Questo modello lavora si adatta particolarmente bene nel caso in sui si voglia effettuare il broadcasting di informazioni verso diversi sistemi.
Un Message-Driven Bean (MDB) è un componente EJB che consuma messaggi da una queue/topic, inviati da un valido client JMS. Per crearlo è sufficiente usare l’annotation:

@MessageDriven

e implementare l’interfaccia MessageListener.

MDB: Esempio

Leggi tutto “MDB (Message Driven Bean) in 5 minuti”

Pubblicato il

Ejb Session Stateless Esempio

EJB Session Staleless: cosa sono

Gli EJB Session Bean sono delle classi con dei metodi invocabili da remoto (semplificando molto possiamo dire che sono come le servlet, ma le servlet hanno solo due metodi doget e dopost, i session invece possono avere tutti i metodi che vogliamo). Sono composti da una classe e due interfacce. Per poter invocare un EJB Session bisogna avere una delle interfacce. Le interfacce sono dette locali o remote, in basa a dove permettono di richiamare il session. Da remoto vengono utilizzati i protocolli distribuiti come RMI-IIOP (Remote Method Invocation o RMI è una tecnologia che consente l’invocazione remota dei metodi);
Gli EJB Session sono transazionali, ossia permettono di gestire le transazioni.
Esistono due tipi di session bean:

  • stateful:  viene memorizzato lo stato fra una richiesta e l’altra del client, ossia garantisce che tutti i campi   dell’EJB Session saranno salvati per la successiva richiesta dello stesso client.
  • stateless: non viene mantenuto alcun stato e vengono utilizzati per modellare quelle elaborazioni che si completano con una sola richiesta

EJB Session Staleless: esempio

Leggi tutto “Ejb Session Stateless Esempio”

Pubblicato il

Java Syncronized: Come si usa esempio

– Indice Tutorial –

Java Syncronized: Cos’è

Ad ogni oggetto (o anche ad un pezzo di codice) si può associare un semaforo (un lock). Ogni semaforo ha due operazioni: Get e Release. Quando un thread accede ad una zona critica tenta di prendere possesso del semaforo (Get); se non ci riesce verrà messo a dormire e ci ritenterà fino a quando un altro thread rilascerà (Release) tale semaforo.
Questi “semafori” in java vengono introdotti con la parola chiave “syncronized“. Si possono sincronizzare sia classi che metodi.
Quando un thread vuole accedere ad un metodo/blocco synchronized, deve acquisire il lock dell’oggetto (impedendo così l’accesso ad ogni altro thread).  Il lock viene automaticamente rilasciato quando il thread esce dal metodo/blocco synchronized(o se viene interrotto da un’eccezione).
Un thread che non riesce ad acquisire un lock rimane sospeso sulla richiesta della risorsa fino a che il lock non è disponibile. Ad ogni oggetto viene assegnato un solo lock: due thread non possono accedere contemporaneamente a due metodi/blocchi synchronized diversi di uno stesso oggetto.Tuttavia altri thread sono liberi di accedere a metodi/blocchi non synchronized associati allo stesso oggetto.

Java Syncronized: Esempio

Leggi tutto “Java Syncronized: Come si usa esempio”