---
# System prepended metadata

title: Esercizi di Java

---

<style>
    details {
        border: 1px solid rgba(0, 0, 0, 0.1);
        padding: 1em;
        margin: 1em 0;
        border-radius: 0.5em;
    }
    
    details.curiosity {
        background: rgba(255, 255, 0, 0.035);
    }
    
    details[open] {
        padding-bottom: 0;
    }
    
    details[open] > summary {
        padding-bottom: 1em;
        margin-bottom: 1em;
        border-bottom: 1px solid rgba(0, 0, 0, 0.1);
    }
</style>

# Esercizi di Java

Collezione di piccoli esercizi in Java che non richiedono l'uso delle classi.

## 1. Problemi da batterista

In Italia è comune usare i **metri** (come stabilito nel Sistema Internazionale) per calcolare le distanze e non solo, in America invece è molto comune il pollice.

`1 pollice` equivale a `2.54cm`, potrai capire che da batterista, spesso mi può venire difficile concepire quanto grandi siano i piatti della batteria dato che la maggior parte dei produttori è americana.

Mi piacerebbe che mi sviluppassi un software che, data una dimensione espressa in pollici, mi restituisca il valore in centimetri.

Esempio:

```
Input: 1
Output: 2.54

Input: 12
Output: 30.54
```

## 2. Forse gioco troppo

Uno dei giochi che ho giocato di più su Steam è Rust.
Stando alle statistiche, ci ho giocato circa 914 ore, fatto sta che esprimendo il tempo di gioco ad ore, non mi riesco a rendere conto quanti giorni ho dedicato a giocare anziché a lavorare: puoi calcolare 914 ore quanti giorni sono?

## 3. Questa dieta non funziona... Ho preso altre 237 righe!

Certe volte mi chiedo: "ma dopo tutto il codice che ho scritto, a quante righe di codice sono arrivato a scrivere?"

Pensando che riesco a scrivere 237 righe di codice in un'ora, in una giornata lavorativa da quarantena (attacco alle 10:00 e finisco all'01:30), quante righe ho scritto a "fine" giornata?

Ed in una settimana? Ed in mese? Ed in in anno?

Scrivi un programma che mi calcoli la risposta a queste domande.

## Suggerimenti e consigli utili

<details>
<summary><b>Acquisire da tastiera</b></summary>

In Java, acquisire da tastiera non è una barzelletta: Java è un linguaggio **verboso** (ovvero che per chiederti _"vuoi un po' di caffè?"_, ti dice _"tu, persona con cui sto parlando vuoi un piccola quantità di quella bevanda energizzante marrone con un sapore un po' tostato comunemente chiamata caffè? In maniera totalmente preventiva, mi dici già quanto zucchero vuoi esprimendo la tua scelta in zollette? (... parte descrizione dello zucchero)"_).

Quindi, da un linguaggio del genere cosa c'è da aspettarsi per una delle funzioni più utilizzate dai programmatori?

:rainbow::sparkles: **_Verbosità!_** :sparkles::rainbow:

Per poter acquisire da tastiera, si possono utilizzare tre metodi:

<details>
<summary>1. <code>System.console().readLine()</code> (<em>sconsigliato</em>)</summary>

Il metodo più semplice, ma che Eclipse non supporta totalmente. Restituisce sempre una stringa, quindi per ottenere un dato numerico è necessario effettuare il **parsing**.

```java
class Programma {
    public static void main(String[] args) {
        String frase;
        
        frase = System.console().readLine();
    }
}
```

</details>

<details>
<summary>2. <code>Scanner</code> (<em>consigliato per questi esercizi</em>)</summary>
Metodo abbastanza semplice e che permette l'acquisizione di dati direttamente nel tipo desiderato.

```java
class Programma {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
    
        String frase;
        int numeroIntero;
        float numeroDecimale;
        
        frase = sc.next(); // Restituisce una stringa;
        numeroIntero = sc.nextInt(); // Restituisce un intero;
        numeroDecimale = sc.nextFloat();
    }
}
```

</details>

<details>
<summary>3. <code>BufferedReader</code> e <code>InputStreamReader</code> (<em>utilizzato dal prof.</em>)</summary>

Il metodo più vecchio che prevede l'utilizzo degli stream che lo rendono complesso da gestire, ma è il più veloce fra tutti.

Restituisce una stringa, quindi per ottenere un dato di tipo diverso è necessario il **parsing**.

```java
class Programma {
    public static void main(String[] args) {
        InputStreamReader input = new InputStreamReader(System.in);
        BufferedReader tastiera = new BufferedReader(input);
    
        String frase;
        
        frase = tastiera.readLine();
    }
}
```

</details>

<details class="curiosity">
<summary><b>Curiosità</b>: Perché Java è verboso?</summary>
Java è un linguaggio verboso per due grossi motivi:

1. Per assicurare il supporto _multipiattaforma_ (a più sistemi operativi);
1. Per permettere una gestione più minuziosa ai programmatori;

Ricordiamo che Java è **sviluppato da ingegneri per gli ingegneri**, quindi non c'è molto da sorprendersi.
</details>

</details>