Linguaggi di programmazione - domande aperte e chiuse ordinate

PANIERE DOMANDE APERTE SVOLTO CORRETTO

a cosa serve la bufferizzazione di uno stream?

a disaccoppiare le azioni di effettiva lettura/scrittura del sistema operativo dalla macchina virtuale Java

che differenza c'è tra un linguaggio di programmazione interpretato e uno compilato?

un linguaggio compilato viene prima tradotto in linguaggio macchina

che differenza c'è tra una classe ed un oggetto?

La classe è quella cosa che definisce il comportamento generale degli oggetti che vi appartengono.Con

comportamento indichiamo le azioni (metodi) che un oggetto di quella classe può fare, e lo stato interno

(le variabili). Gli oggetti sono delle "cose" che hanno il comportamento della classe.ovviamente 2 oggetti

distinti possono avere comportamenti diversi inbase al proprio stato interno (cioè alle variabili).

Una classe è la descrizione astratta di un tipo di dato; un oggetto è la realizzazione (istanza) di una classe

che differenze ci sono tra una pila e una coda?

Somiglianze> entrambi i tipi di dato astratto possono essere realizzati con la stessa struttura dati

una pila è una collezione di oggetti in cui agli oggetti si accede a LIFO (Last In First Out). Una coda è un

insieme di oggetti in cui gli oggetti sono accessibili nel FIFO (First In First Out) sequenza. In una pila, un

oggetto è spinto in cima alla raccolta durante l'operazione di inserimento. In una coda, un nuovo oggetto

viene inserito alla fine.

che differenze tra tipo di dato astratto e struttura dati? si faccia riferimento al linguaggio Java

Una struttura dati (data structure) è un modo sistematico di organizzare i dati in un contenitore e di

controllarne le modalità d’accesso. In Java si definisce una struttura dati con una classe.

Un tipo di dati astratto (ADT, Abstract Data Type) è una rappresentazione astratta di una struttura dati, un

modello che specifica: il tipo di dati memorizzati

- le operazioni che si possono eseguire sui dati, insieme

- al tipo di informazioni necessarie per eseguire tali operazioni

che somiglianze ci sono tra una pila e una coda?

entrambi i tipi di dato astratto possono essere realizzati con la stessa struttura dati

che tipo di linguaggio di programmazione è Java?

È un linguaggio semi compilato o semi-interpretato, 12

In informatica Java è un linguaggio di programmazione ad alto livello, orientato agli oggetti e a

tipizzazione statica, che si appoggia sull'omonima piattaforma software, specificamente progettato per

essere il più possibile indipendente dalla piattaforma hardware di esecuzione (tramite compilazione in

bytecode prima e interpretazione poi da parte di una JVM),

il codice compilato che viene eseguito su una piattaforma non deve essere ricompilato per essere

eseguito su una piattaforma diversa. Infatti il prodotto della compilazione è in un formato chiamato

bytecode che può essere eseguito da una qualunque implementazione di un processore virtuale detto

Java Virtual Machine.

I programmi scritti in linguaggio Java, dopo una fase iniziale di compilazione con ottenimento del

cosiddetto bytecode, sono destinati all'esecuzione sulla piattaforma Java attraverso una fase di

interpretazione (per questo motivo il linguaggio Java è detto anche semi-interpretato) ad opera di una

Java Virtual Machine e in esecuzione hanno accesso alle API della libreria standard. Questi due passi

forniscono un livello di astrazione che permette alle applicazioni di essere interamente indipendenti dal

sistema hardware su cui esse saranno eseguite.

Ma quali sono i vantaggi per passare da un linguaggio intermedio (i bytcodes) ad un linguaggio

interpretato ?Questi i principali vantaggi:

l’interprete per il linguaggio dei bytecodes è molto più efficiente di un interprete per un linguaggio ad alto

livello come il linguaggio Java. Infatti, il linguaggio dei bytecodes si approssima molto al linguaggio

macchina di una CPU reale di quanto non lo siano i linguaggi di alto livello.

grazie all’indipendenza del linguaggio intermedio (i bytecodes) che fa da raccordo tra il linguaggio Java e

le differenti piattaforme hardware. Per esempio, il linguaggio Java può anche essere modificato oppure

esteso senza aver bisogno di trasformare il linguaggio dei bytecodes e le relative JVM (questo è avvenuto

sopratutto durante le varie revisioni del linguaggio .

Il linguaggio intermedio dei bytecodes e le varie JVM sono soltanto una parte dell’insieme che fa si che il

linguaggio Java si uno fra i linguaggi di programmazione più portabili. Mentre l’altra parte comprende la

piattaforma Java.

chi gestisce l'oggetto eccezione (exception object) in Java?

In Java l’exception object viene gestito dal run-time system

come avviene l'inserzione di un elemento in una lista?

StringBuilder insert(int offset, boolean b)

StringBuilder insert(int offset, char c)

StringBuilder insert(int offset, double d)

StringBuilder insert(int offset, float f)

StringBuilder insert(int offset, int i)

StringBuilder insert(int offset, long lng)

StringBuilder insert(int offset, String s)

Inserisce il secondo argomento nella posizione specificata dal primo argomento

Una lista è una struttura dati che permette di memorizzare dati in maniera sequenziale, e permette di

accedere e cancellare dati in posizioni arbitrarie (cioè non solo il primo o l'ultimo inserito, come nel caso

di pile e code).

Una lista concatenata è una sequenza lineare di nodi, ciascuno dei quali memorizza un valore e contiene

un riferimento (puntatore) al nodo successivo nella sequenza. In questo modo è possibile aggiungere e

cancellare nodi in qualunque posizione semplicemente aggiustando il sistema di puntatori senza operare

sui nodi non interessati dalla aggiunta o dalla cancellazione.

La seguente classe implementa un nodo di una lista concatenata.

/**

* Classe usata per descrivere il singolo nodo di una lista concatenata

*/

public class ListNode<E> {

public E element ;

public ListNode<E> next ; 13

/**

* Costruttore nodo per liste unidirezionali

*/

public ListNode (E element, ListNode<E> next) {

this.element = element ;

this.next = next ;

}

}

Vediamo alcuni frammenti di codice che manipolano le liste. Si assumono le dichiarazioni

ListNode<E> l1;

E A; // l'informazione da inserire

Inserzione in testa, l1, (che può essere null), è la lista:

l1 = new ListNode<E>(A, l1);

Inserzione in coda, l1, (che non può essere null), è l'ultimo elemento della lista:

l1.next = new ListNode<E>(A, null);

Inserzione all'interno, l1, (che non può essere null), è l'elemento della lista precedente a quello in cui deve

comparire il nuovo:

l1.next = new ListNode<E>(A, l1.next);

Rimozione in testa, l1, (che non può essere null), è la lista:

l1 = l1.next;

Rimozione all'interno, l1, (che non può essere null), è l'elemento della lista precedente a quello da

rimuovere (che deve esistere):

l1.next = l1.next.next;

Rimozione in coda, l1, (che non può essere null), è il penultimo elemento della lista:

l1.next = null;

come avviene la ricerca di un elemento in una lista?

La ricerca di un elemento k nella lista L procede scandendo la lista, ovviamente partendo dalla testa. Nel

caso in cui la sequenza di elementi non è ordinata, è necessario utilizzare la cosiddetta ricerca

lineare o sequenziale. Poiché non è possibile stabilie a priori in quale parte dell’array potrebbe trovarsi

l’elemento da ricercare, è necessario analizzare gli elementi dell’array in sequenza e confrontartli con

l’elemento (chiave) da ricercare per determinare se fa parte della sequenza. Se si vuole trovare solo la

prima occorrenza della chiave, è possibile terminare la ricerca non appena la chiave viene trovata, senza

dover scorrere interamente la sequenza. Esempio di copdice:

1. public static int ricercaLineareOccorrenze(int[] arr, int chiave) {

2. int occorrenze = 0; 14

3. for (int i=0; i<arr.length; i++)

4. if (arr[i]==chiave)

5. occorrenze++;

6. return occorrenze; }

ArrayList è una delle strutture dati integrate in Java. È una matrice dinamica (in cui non è necessario dichiarare la dimensione della

struttura dati prima) per la memorizzazione di elementi (oggetti).

AbstractList List ArrayList

Estende la classe e implementa l'interfaccia . Un può contenere elementi duplicati dove

ArrayList

mantiene l'ordine di inserimento. Va notato che la classe non è sincronizzata, quindi è necessario prestare attenzione

ArrayList ArrayList

quando si maneggia la concorrenza con . consente l'accesso casuale perché l'array funziona alla base

ArrayList

dell'indice. La manipolazione è lenta in causa dello spostamento che si verifica spesso quando un elemento viene rimosso

dall'elenco di array.

ArrayList

Un può essere creato come segue:

List<T> myArrayList = new ArrayList<>();

T ArrayList

Dove ( Generics ) è il tipo che verrà archiviato all'interno di .

ArrayList

Il tipo di può essere qualsiasi oggetto. Il tipo non può essere un tipo primitivo (usa invece le loro classi wrapper ).

ArrayList add()

Per aggiungere un elemento a , utilizzare il metodo :

myArrayList.add(element);

O per aggiungere elementi a un determinato indice:

myArrayList.add(index, element); //index of the element should be an int (starting from 0)

ArrayList remove()

Per rimuovere un oggetto da , utilizzare il metodo :

myArrayList.remove(element);

O per rimuovere un elemento da un certo indice:

myArrayList.remove(index); //index of the element should be an int

come avviene la rimozione di un elemento in una lista? 15

//eliminazione elemento in testa

public static NodoLista outTesta(NodoLista p) {

p = p.next;

return p;

}

//eliminazione elemento prima di un dato elemento

public static NodoLista elimina(NodoLista p, String cercata){

if (p == null) return p;

if (p.info.equals(cercata)) {

p = p.next; //eliminazione elemento cercato

return p; //in prima posizione

}

NodoLista pp = p;

while (pp.next != null) {

if (pp.next.info.equals(cercata)) {

pp.next = pp.next.next; //eliminazione elemento cercato

break; //in posizione interna

}

pp = pp.next;

}

return p;

}

//eliminazione elemento prima di un dato elemento

//con nodo generatore

public static NodoLista elimina(NodoLista p, String cercata){

NodoLista pp = new NodoLista(); // creazione nodo generatore

pp.next = p;

p = pp;

while (pp.next != null) { //ora ogni nodo ha un predecessore

if (pp.next.info.equals(cercata)) {

pp.next = pp.next.next; // eliminazione elemento cercato

break;