lab.2 .

lab.2 .

REQUIRES

Spesso si identificano osservando l’output d’esempio pk rivela informazioni ulteriori
 
NOTE
  • il metodo prenotalancia delle ECCEZIONI
  • ha fatto una stampa in cui scrive (i+13) altrimenti stampa non lo stampa come stringa nn so pk
  • l’ordine in cui gestisco le eccezioni è importante, il catch dell’eccezione padre deve stare sotto rispetto al catch dell’eccezione figlia che ha la sua estensione, pk altrimenti il padre gestisce pure il figlio
  • Se stai usando un singolo oggetto di tipo ArrayList (e non un array di ArrayList), non sarebbe necessario specificare l'indice [0]. Quando usi solo una singola lista, puoi semplicemente chiamare direttamente il metodo add() sull'oggetto della lista.

Perché usare List invece di ArrayList?

È comune usare il tipo List per dichiarare la variabile (come nel primo esempio) anche quando si usa un ArrayList come implementazione. Questo approccio segue il principio "programmare per interfacce", che rende il codice più flessibile. Se in futuro dovessi cambiare implementazione da ArrayList a LinkedList, ad esempio, non dovresti cambiare il tipo di variabile ovunque nel codice.
In sintesi:
  • List è l'interfaccia generica che permette di usare diverse implementazioni.
  • ArrayList è una delle implementazioni concrete più comuni di quella interfaccia, basata su un array dinamico.

Esempio di uso:

  1. Uso di List<Integer> (interfaccia):
      2. // Dichiarazione tramite l'interfaccia List, con un'implementazione ArrayList
List<Integer> lista = new ArrayList<>();
lista.add(10);
lista.add(20);
System.out.println(lista.get(0));  // Stampa: 10
  1. Uso di ArrayList<Integer> (implementazione concreta):
      2. // Dichiarazione e uso diretto di ArrayList
ArrayList<Integer> listaArray = new ArrayList<>();
listaArray.add(30);
listaArray.add(40);
System.out.println(listaArray.get(1));  // Stampa: 40
 
 
💡
È utilizzata per rappresentare una sequenza ordinata di elementi, dove l'ordine di inserimento viene mantenuto e gli elementi possono essere duplicati.
La differenza principale tra List<Integer> e ArrayList<Integer> in Java sta nel fatto che List è un'interfaccia e ArrayList è una classe che implementa quella interfaccia. Vediamo cosa significa in pratica:

1. List<Integer>:

💡
  • List è un'interfaccia, non una classe concreta. Definisce una serie di metodi che tutte le classi concrete (come ArrayList, LinkedList, ecc.) possono implementare.
  • Non puoi creare un'istanza di List direttamente (perché è un'interfaccia), ma puoi usare vari tipi di liste che la implementano, come ArrayList, LinkedList, o Vector.

2. ArrayList<Integer>:

  • ArrayList è una classe concreta che implementa l'interfaccia List. Viene usata più comunemente per creare una lista basata su un array dinamico.
  • Fornisce un'implementazione specifica dei metodi definiti in List e gestisce una lista in cui gli elementi vengono memorizzati in un array che si ridimensiona automaticamente quando necessario.

Principali differenze:

Caratteristica
List<Integer>
ArrayList<Integer>
Tipo
Interfaccia
Classe concreta
Istanziabilità
Non può essere istanziata
Può essere istanziata
Flessibilità
Può essere implementata da varie classi come ArrayList, LinkedList, ecc.
Specifica un'implementazione concreta
Implementazione
Non contiene un'implementazione concreta
Usa un array dinamico come implementazione interna

Differenza tra Array di ArrayList e un singolo ArrayList:

  1. Array di ArrayList (come nel tuo esempio precedente):
    Se hai un array di ArrayList (ArrayList<String>[] numL), devi specificare l'indice dell'elemento dell'array su cui vuoi operare (ad esempio, numL[0].add(...)).
      2. Esempio:
      ArrayList<String>[] numL = (ArrayList<String>[]) new ArrayList[10];
numL[0].add("Elemento");  // Specifica l'indice dell'array
  1. Singolo oggetto ArrayList:
    Se stai usando un singolo ArrayList (ad esempio, ArrayList<String> numL), non devi specificare un indice perché c'è solo un oggetto lista, non un array di liste.
      2. Esempio:
      ArrayList<String> numL = new ArrayList<>();
numL.add("Elemento");  // Non c'è bisogno di [0], poiché numL è una singola lista

Se hai un singolo ArrayList<String>:

Se non hai bisogno di un array di liste, ma solo di una singola lista, puoi dichiarare e usare il ArrayList così:

Codice corretto con un singolo ArrayList:

ArrayList<String> numL = new ArrayList<>();

for (int i = 0; i < num.length(); i++) {
    if (i < num.length() - 1 && num.charAt(i + 1) > num.charAt(i)) {
        numL.add(num.substring(i, i + 2));  // Aggiungi la sottostringa
        i++;  // Salta il prossimo carattere
    } else {
        numL.add(Character.toString(num.charAt(i)));  // Aggiungi il singolo carattere come stringa
    }
}

return numL;

Esempio completo con un singolo ArrayList:

import java.util.ArrayList;

public class Main {
    public static ArrayList<String> processString(String num) {
        ArrayList<String> numL = new ArrayList<>();

        for (int i = 0; i < num.length(); i++) {
            if (i < num.length() - 1 && num.charAt(i + 1) > num.charAt(i)) {
                numL.add(num.substring(i, i + 2));  // Aggiungi la sottostringa
                i++;  // Salta il prossimo carattere
            } else {
                numL.add(Character.toString(num.charAt(i)));  // Aggiungi il singolo carattere
            }
        }

        return numL;
    }

    public static void main(String[] args) {
        String num = "123456";
        ArrayList<String> result = processString(num);

        // Stampa del risultato
        for (String s : result) {
            System.out.println(s);
        }
    }
}

Output:

Con la stringa "123456", l'output sarà:
12
34
56

Conclusione:

  • Se hai un array di ArrayList, devi specificare l'indice dell'elemento dell'array (numL[0]).
  • Se hai un singolo ArrayList, non hai bisogno di specificare alcun indice e puoi semplicemente usare numL.add().
 
 
notion image
notion image