Artikoloj

Java-ekzercoj por trejna kurso de Java Base

Listo de javaj ekzercoj kun solvo por trejna kurso de Java Base.

La numerado de la ekzerco estas indika pri la nivelo de malfacileco, de la plej simpla ĝis la plej komplika. Se vi havas komentojn, demandojn aŭ sugestojn: skribu al ni ĉe info @bloginnovazione.it

Ekzerco 1
Skribu Java-programon, kiu instigas la uzanton enigi du ŝnurojn kaj montras la uzanton vera se la ŝnuroj estas samaj kaj malvera se ili estas malsamaj.

import java.util.Scanner;

public class CompareTwoStrings {
   public static void main(String[] args) {
        
      Scanner risposta = new Scanner(System.in);
        
      System.out.println("Inserisci la prima stringa");
      String str1 = risposta.nextLine();

      System.out.println("Inserisci la seconda stringa");
      String str2 =risposta.nextLine();

      if(str1.equals(str2))
      {
         System.out.println("La stringa " + str1 + " è uguale a " + str2);
      }
      else
      {
         System.out.println("La stringa " + str1 + " è diversa da " + str2);
      }

      risposta.close();

   }
}

Ekzerco 2
Skribu Java-programon, kiu instigas la uzanton enigi du ĉenojn (str1 kaj str2) kaj kiu montras malsaman frazon al la uzanto kun la sekvaj kondiĉoj:
1) se ili estas samaj skribu “la ŝnuro” + + ”Estas egala al” +
2) se ili estas malsamaj skribu "la ĉeno" + + ”Estas malsama de” +
3) se unu el la du estas inkluzivita en la alia "la ŝnuro" + + ”Estas inkluzivita en la + ĉeno
4) en la okazo, ke unu estas inkluzivita en la alia, diru kiom da okazoj estas, kaj poste skribu
"La okazoj estas:" +

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CompareTwoStrings {

   public static void main(String[] args){
      Scanner input = new Scanner(System.in);

      System.out.println("Digitare prima stringa:");
      String str1 = input.nextLine();

      System.out.println("Digitare seconda stringa:");
      String str2 = input.nextLine();
        
      boolean verifica = str1.equals(str2); // check equals
      boolean verificaContenuto1 = str1.contains(str2); //check inclusion
      boolean verificaContenuto2 = str2.contains(str1);

      if (verifica){
         System.out.println("La stringa " + str1 + " è uguale alla stringa "+ str2 + " (sensibile al maiuscolo).");
      }
      else if (verificaContenuto1){

         Pattern p = Pattern.compile(str2);
         Matcher m = p.matcher(str1);

         int count1 = 0;
         while(m.find()){
            count1 += 1;
         }
               
         System.out.println("La stringa2 " + str2 + " è contenuta nella stringa1 " + str1 + " " + count1 + " volte.");
      }
      else if (verificaContenuto2){
                
         Pattern p = Pattern.compile(str1);
         Matcher m = p.matcher(str2);

         int count2 = 0;
         while(m.find()){
            count2 += 1;
         }
               
         System.out.println("La stringa1 " + str1 + " è contenuta nella stringa2 " + str2 + " " + count2 + " volte.");
      }
        
      else {
         System.out.println("La stringa " + str1 + " è diversa alla stringa " + str2 + ".");
      }

      input.close();

      System.out.println("Fine.");
   }
}

Ekzerco 3
Donita klavarenigo, kontrolu la enhavon, (la unuaj tri kondiĉoj ne estas ekskluzivaj, dum la falsa (nuntempa) de la unuaj tri kondiĉoj implicas la kvaran opcion):
1) se binara nombro konvertiĝas al decimala kaj deksesuma eligo
2) se dekuma nombro konverti al eligo al duuma kaj deksesuma
3) se deksesa nombro konverti al duuma kaj decimala eligo
4) en ĉiuj aliaj kazoj raportu neakcepteblan enigon kaj petu enmeton
tiam por la enigo '101' faru la konvertiĝojn 1, 2 kaj 3
por enigo '123' faru konvertiĝojn 2 kaj 3
por enigo '89A' faru la konvertiĝon 3
por enigo '89G' efektivigu la punkton 4

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CompareTwoStrings {

    public static String bi2int (String bin){
        char[] numbers = binary.toCharArray();
        int result = 0;
        for(int i=numbers.length - 1; i>=0; i--)
        if(numbers[i]=='1'){
            result += Math.pow(2, (numbers.length-i - 1));
        }
        return result;
    }

    public static String bi2esa (String bin){
    }

    public static String int2bi (String integer){
        int integer1 = Integer.parseInt(integer);
        String result = Integer.toBinaryString(integer1);
        return result;
    }

    public static String int2esa (String integer){
    }

    public static String esa2bi (String esa){
    }

    public static String esa2int (String esa){
    }

    public static void main(String[] args){

        Scanner input = new Scanner(System.in);

        System.out.println("Digitare un numero binario, intero o esadecimale:");
        String numero = input.nextLine();

        Pattern pBinario = Pattern.compile("[A-Z]"|"[2-9]", Pattern.CASE_INSENSITIVE);
        Matcher mBinario = pBinario.matcher(numero);
        boolean binario = mBinario.find();

        Pattern pIntero = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher mIntero = pIntero.matcher(numero);
        boolean intero = mIntero.find();

        Pattern pEsadecimale = Pattern.compile("[G-Z]", Pattern.CASE_INSENSITIVE);
        Matcher mEsadecimale = pEsadecimale.matcher(numero);
        boolean esadecimale = mEsadecimale.find();

        if (binario){
            System.out.println(numero + " è binario!");
            System.out.println("In interi corrisponde a " + bi2int(numero) + ",");
            System.out.println("in esadecimali corrisponde a " + bi2esa(numero) + ".");
        }

        if (intero){
            System.out.println(numero + " è intero!");
            System.out.println("In binario corrisponde a " + int2bi(numero) + ",");
            System.out.println("in esadecimali corrisponde a " + int2esa(numero) + ".");
        }

        if (esadecimale){
            System.out.println(numero + " è esadecimale!");
            System.out.println("In binario corrisponde a " + esa2bi(numero) + ",");
            System.out.println("in interi corrisponde a " + esa2int(numero) + ".");
        }

        if (!esadecimale && !intero && !binario){
            System.out.println("Input errato!");
        }

    input.close();
    }
}

Ekzerco 4
Faru programon, kiu konvertas temperaturon de celsiusgradoj al gradoj Kelvin. La programo devas havi du etikedojn, du tekstajn kampojn kaj butonon. Tekstaj kampoj kaj etikedoj devas esti organizitaj en panelo kun ununura kolumna krada aranĝo; alia panelo enhavos la ununuran butonon kaj estos la ĉefa panelo kiu enhavas la du panelojn priskribitajn.

La programo legas la valoron enigitan en la tekstkampo responda al la temperaturo en celsiaj gradoj. Se la enigita teksto estas malplena, neniu operacio devas esti farita; alie la teksto estas konvertita al duobla valoro kaj ĉi tiu valoro estas pliigita je 273.15 por akiri gradojn Kelvin, kiuj tiam estas skribitaj en la respondan tekstkampon.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class ConvertitoreTemperatura extends JFrame implements ActionListener{
   JButton btnConverti;
   JLabel lbTempCelsius, lbTempKelvin;
   JTextField txtTempCelsius, txtTempKelvin;
   JPanel pannello, pann1, pann2;

   public ConvertitoreTemperatura() {
	pannello = new JPanel();
	pann1 = new JPanel(new GridLayout(0,1));
	pann2 = new JPanel();
	txtTempCelsius = new JTextField("",10);
	txtTempKelvin = new JTextField("",10);
	lbTempCelsius = new JLabel("Temperatura in Celsius");
	lbTempKelvin = new JLabel("Temperatura in Kelvin");
	btnConverti = new JButton("Converti Temperatura");
	pann1.add(lbTempCelsius);
	pann1.add(txtTempCelsius);
	pann1.add(lbTempKelvin);
	pann1.add(txtTempKelvin);
	pann2.add(btnConverti);
	pannello.add(pann1);
	pannello.add(pann2);
	setContentPane(pannello);
	btnConverti.addActionListener(this);
	setTitle("Convertitore Temperatura ");
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	pack();
	setSize(400,150);
	setVisible(true);
   }
   public void actionPerformed(ActionEvent e) {
	String str = txtTempCelsius.getText();
	if (!str.contentEquals("")) {
		double d = Double.parseDouble(str);
		d = d + 273.15;
		txtTempKelvin.setText(""+d);
	}
   }
   public static void main(String[] args) {
	ConvertitoreTemperatura frame = new ConvertitoreTemperatura();
   }
}

Ekzerco 5
Skribu Java-programon kiu prenas du klavarajn enigojn kaj eligas la sumon, konsiderante tion:
- se ili estas du entjeroj, la sumo estas raportita kiel eligo
- se ili estas du ĉenoj, la kunkateno estas raportita en la eligo

public class SommaConcatenazione {

   public static void main(String[] args) {

      char simbolo;
      int numero1;
      int numero2;
      String parola1;
      String parola2;
      int risultato;
      String risultatoStringa;

      Scanner scanner = new Scanner(System.in);

      System.out.println("scegli l'operazione: numeri (n), Stringhe (s)");
      simbolo = scanner.nextLine().charAt(0);
			
      switch (simbolo) {

         case 'n':
				
            System.out.println("inserisci un numero");
            numero1 = scanner.nextInt();

            System.out.println("inserisci il secondo numero");
            numero2 = scanner.nextInt();
				
            risultato = numero1 + numero2;
            System.out.println(numero1 + " + " + numero2 + " = " + risultato);
         break;

         case 's':
				
           System.out.println("inserisci una parola");
	   parola1 = scanner.nextLine();

	   System.out.println("inserisci la seconda parola");
           parola2 = scanner.nextLine();
				
           risultatoStringa = parola1 + parola2;
           System.out.println(parola1 + "  " + parola2 + " = " + risultatoStringa);
         break;


         default:
            System.out.println("operazione  non valido");
         break;
      }
      scanner.close();
      System.out.println("FINE");
   }	
		
}

Ekzerco 6
Reskribi la kodon de ekzerco 3 uzante la Ĝava troŝarĝon, definendo du metodoj, kiuj havas la saman nomon kaj kiuj efektivigas: la unua la aritmetika sumo kaj la dua la kunligado de ŝnuroj

import java.util.Scanner;

public class Main{

    public static int somma (int addendo1, int addendo2)
    {
        return addendo1 + addendo2;
    };

    public static String somma(String addendo1, String addendo2)
    {
        return addendo1 + addendo2;
    };


    public static void main(String[] args){
        Scanner risposta = new Scanner(System.in);
        
        System.out.println("Cosa vuoi sommare? 1-numeri....2-stringhe");
        
        
        int input = risposta.nextInt();

        if( input == 1)
        {
            System.out.println("Inserisci il primo numero");
            int num1=risposta.nextInt();

            System.out.println("Inserisci il secondo numero");
            int num2=risposta.nextInt();

            System.out.println("Il risultato è: "+ somma(num1,num2));
        }
        else 
        {
            risposta.nextLine();
            System.out.println("Inserisci la prima stringa");
           String str1 = risposta.nextLine();

            System.out.println("Inserisci la seconda stringa");
           String str2 =risposta.nextLine();

            System.out.println("Il risultato è: "+ somma(str1,str2));
            

        }
        risposta.close();
        

    }


}

Ekzerco 7
Reskribi la kodon de ekzerco 4 uzante Java-troŝarĝon, rekonante la enhavon de ĉenoj per regulaj esprimoj. Se estas almenaŭ unu litero tiam ni kunkatenas, alie ni aldonas

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Esercizio3 {

    public static int somma(int addendo1, int addendo2){
        return addendo1 + addendo2;
    }

    public static String somma(String stringa1, String stringa2){
        return stringa1 + stringa2;
    }

    public static void main(String[] args) {

        Scanner risposta = new Scanner(System.in);
        
        System.out.println("Inserisci il primo valore");
        String str1 = risposta.nextLine();

        System.out.println("Inserisci il secondo valore");
        String str2 =risposta.nextLine();

        Pattern pattern1 = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher matcher1 = pattern1.matcher(str1.toUpperCase());
        boolean matchFound1 = matcher1.find();

        Pattern pattern2 = Pattern.compile("[A-Z]", Pattern.CASE_INSENSITIVE);
        Matcher matcher2 = pattern2.matcher(str2.toUpperCase());
        boolean matchFound2 = matcher2.find();

        if( matchFound1 || matchFound2)
        {
            System.out.println("Il risultato è: "+ somma(str1,str2));
        }
        else
        {
            int num1 = Integer.parseInt(str1);
            int num2 = Integer.parseInt(str2);

            System.out.println("Il risultato è: "+ somma(num1,num2));
        }

        risposta.close();

    }
}

Ekzerco 8
Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

En la unua kazo ni uzos rekursion, kie metodo vokas sin por la solvo, kaj en la dua kazo ni uzos buklon kiel por kaj dum buklo por ricevi la ripeton.

Por krei rekursivan solvon, ni bezonas bazkazon kie la programo finiĝas kaj la rikurso ĉesas. Ni vidas, ke la baza kazo estas faktorialo de 1, kio estas 1, do kiam via funkcio nomas faktorialo (1) vi povas simple redoni 1 sen fari ajnajn kalkulojn. Kaj, se la nombro estas pli granda ol 1, ni daŭre aplikas la faktorial-formulon rekursie nomante la saman faktorialon kun n - 1. Post kiam la enigo fariĝas 1, la metodo ĉesigas la rekursivan vokon kaj resendas 1. De tie metodo stako havas komencis rulumi malsupren kaj finfine la faktorialo de nombro estas kalkulita kaj resendita.

Uzante la ripeton anstataŭe, kaj tiam la for buklo por komputi la faktorialon n! = n(n-1)(n-2) .....1. Vi povas vidi, ke ni komencas per la nombro kaj multiplikas ĝin per la faktorialo, kiu estas pravigita per 1, tiam ni reduktas la nombron je unu unuo ĝis la nombro fariĝas 1, kiu estas nenio krom n(n-1)(n-2) .....1.

import java.util.Scanner;

public class Factorial{

    public static int recursiveFactorial(int n)
    {

        if( n <= 1)
        {
            return 1;
        }
        else
        {
            return n * recursiveFactorial( n - 1 );
        }
        
    } 

    public static int iterativeFactorial(int n){
        int result = 1;

        for (int i = 1; i <= n; i++) {
            result = result * i;
        }
        
        return result;
    }

    public static void main(String[] args){

        Scanner input = new Scanner(System.in); // input
        System.out.println("Insert an integer number: ");
        int numero = input.nextInt();
        if ( numero < 0 ){
            System.out.println("The number must be positive!");
            System.exit(0);
        }


        System.out.println("Recursive Factorial is: " + recursiveFactorial(numero));
        System.out.println("Iterative Factorial is: " + iterativeFactorial(numero));

        input.close();

    }
}

Ekzerco 9
Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

Estas multaj manieroj inversigi ŝnuron en Java. Ni povas uzi la altnivelan Java API por rapide inversigi la enhavon de iu ajn String-objekto. La Java biblioteko provizas la StringBuffer kaj StringBuilder klasoj per la inversa () metodo kiu povas esti uzata por inversigi String en Java. Sed ĉar inverso estas rekursiva, ni povas uzi rekursion.

Jen la algoritmo kaj kodoj por inversigi certan ĉenon en Java sen uzi StringBuffer aŭ aliajn API-metodojn. La suba metodo montras kiel inversigi la ŝnuron, kiun vi povas plu reuzi por kontroli ĉu la donita ŝnuro estas palindromo aŭ ne.

Post validigo de la komenca enigo, la Ŝnuro estas vizitata karaktero post signo, komencante de la fino ĝis la komenco kaj generante inversan Ŝnuron.

import java.util.Scanner;

public class ReverseString {
    
    public static String reverseString(String str){

        if( str.length() == 0 ){
            return str;
        }
        else{
        return str.charAt(str.length()-1)  + reverseString( str.substring(0, str.length() - 1) );
        }
    }

    public static void main(String[] args){
        Scanner input = new Scanner(System.in); // input
        System.out.println("Insert a phrase: ");
        String stringa = input.nextLine();

        System.out.println("String reversed is " + reverseString(stringa));

        input.close();
    }
}

Ekzerco 10
Skribu java-programon kapablan administri la operaciojn de enigo, forigo kaj binara serĉo ene de listo de entjeroj, kun la celo administri ordigitan indekson de nombroj simulante la konduton de tabelindekso de rilata datumbazo.

Por administri la indekson, ni daŭrigu kun kreado de la indeksa klaso kie la metodoj estas legitaj indekso, enigu indekson kaj forigu indekson. Operacioj ĉiam estas antaŭitaj de binara ŝlosilserĉo.

Por havi flekseblecon en la datumstrukturo estas pli bone uzi tabelliston.

import java.util.Scanner;
import java.lang.Math;
import java.util.ArrayList;

//---------------------------------------------------------
// Main Class
//---------------------------------------------------------

public class Index {

//METODO MAIN
   public static void main(String[] args){

      Scanner input = new Scanner(System.in);

        ArrayList<Integer> arrayInserito = new ArrayList<Integer>();

        System.out.println("How many numbers do you want to enter ?");
        int dimensione = input.nextInt();

        int valoreLetto;
        int i= 0;
        
        for (i = 0; i <= (dimensione - 1); i++){
            System.out.println("Input " + (i+1) + "^ Value");
            valoreLetto = input.nextInt();
            arrayInserito.add(valoreLetto);
        }
        VettoreNum primoArray = new VettoreNum(arrayInserito); 

        String decisione = "Y";

        while (decisione.equalsIgnoreCase("Y")){

            System.out.println("What execute ?");
            System.out.println("(0) = INSERT Key");
            System.out.println("(1) = REMOVE Key");
            System.out.println("(2) = END");

            int scelta = input.nextInt();

            if (scelta == 2)
                continue;
                
            else {
                System.out.println("Input key to search:");
                int chiave = input.nextInt();
        
                if (chiave < 0){
                    System.out.println("Error: the key must be positive.");
                    System.exit(0);
                }

                switch (scelta){

                    //Insert
                        case 0:
                        System.out.println("Array: " + primoArray.vettore);
                        System.out.println("The key is in the index : " + primoArray.cercaValore(chiave));
                        System.out.println("Position: " + primoArray.getPosizione());
                        System.out.println("The index after insert:");
                        System.out.println(primoArray.inserisciValore(chiave));
                        break;

                    //Remove
                        case 1:
                        System.out.println("Array: " + primoArray.vettore);
                        System.out.println("The key is in the index: " + primoArray.cercaValore(chiave));
                        if (primoArray.cercaValore(chiave)){
                            System.out.println("Position: " + primoArray.getPosizione());
                            System.out.println("The index after remove:");
                            System.out.println(primoArray.rimuoviValore(chiave));
                        }
                        else 
                            System.out.println("The key is not in the index.");
                        break;

                    //no valid input
                        default:
                        System.out.println("Error: please insert a valid number.");
                    }
            }
        
            System.out.println("Do you want to do another ? (Y or N)");
            decisione = input.next();
        }
        input.close();
        System.out.println("END.");
       
    }
}



//----------------------------------------------------------------
//CLASS VECTORNUM
//----------------------------------------------------------------

class VectorNum {


    public int lunarray;   
    public int posizione;  
    public ArrayList<Integer> vettore;  
    public int sup;
    public int inf;
    public ArrayList<Integer> newArray; 

    public VettoreNum (ArrayList<Integer> vettore){
        this.vettore = vettore;
        this.lunarray = vettore.size();
        this.posizione = -1;
        this.inf = 0;
        this.sup = vettore.size() - 1;
        this.newArray = new ArrayList<Integer>();
    }


    public int getPosizione(){
        return this.posizione;
    }


    public boolean cercaValore (int chiave){

        if((this.sup - this.inf) > 1){
            int m = Math.round((this.sup + this.inf)/2);
            if (chiave < this.vettore.get(m)){
                this.sup = m;
            }
            else {
                this.inf = m;
            }
            cercaValore(chiave);
        }
        if (chiave <= this.vettore.get(this.inf))
            this.posizione = this.inf;
        else if (chiave <= this.vettore.get(this.sup))
            this.posizione = this.sup;
            else 
            this.posizione = this.sup + 1;
        return (this.vettore.get(this.inf) == chiave || this.vettore.get(this.sup) == chiave);
    }
        

    public ArrayList<Integer> inserisciValore (int chiave){

        newArray.clear();
        int i;

        for (i = 0; i < this.lunarray + 1; i++){
            if (i < this.posizione)
                this.newArray.add(this.vettore.get(i));
            else if (i == this.posizione)
                this.newArray.add(chiave);
            else
                this.newArray.add(this.vettore.get(i - 1));
        }
        this.vettore = this.newArray;
        return this.vettore;
    }


    public ArrayList<Integer> rimuoviValore (int chiave){

        vettore.remove(posizione);
        return this.vettore;
    }
}

Ekzerco 11
Skribu java-programon, kiu legas enigdosieron nomitan textinput.txt kaj kontrolas ĝian enhavon
1) se la dosiero ne ekzistas, skribu "la dosiero ne ekzistas"
2) se la dosiero ekzistas kaj estas malplena, skribu "la dosiero textinput.txt estas malplena"
3) se la dosiero ekzistas kaj enhavas nur unu numeron, presi la numeron sur la ekrano
4) se la dosiero ekzistas kaj enhavas du nombrojn sur du linioj, presi la sumon inter la du nombroj
5) se la dosiero ekzistas kaj enhavas pli ol du nombrojn, faru ĝin la produkto

Por havi flekseblecon en la datumstrukturo estas pli bone uzi tabelliston.

import java.io.File;
import java.util.Scanner;
import java.util.ArrayList;
import java.io.FileNotFoundException;


public class Exercise_11 {

    public static void main(String[] args) throws FileNotFoundException{

        File mioFile = new File("textinput.txt");

        if (!mioFile.exists()){//---------------------------------------------- file doesn't exist
            System.out.println("File not found.");
        }
        else {//---------------------------------------------------------------  file exists
            System.out.println("File exist.");

            Scanner lettore = new Scanner(mioFile);

            ArrayList<Integer> collezione = new ArrayList<Integer>();

            while (lettore.hasNextLine()) {
            int riga = lettore.nextInt();
            collezione.add(riga);
            }
            lettore.close();

            switch (collezione.size()){
                
                case 0:
                System.out.println("File empty.");
                break;

                case 1:
                System.out.println(collezione.get(0));
                break;

                case 2:
                System.out.println("Two numbers, and the sum is: " + (collezione.get(0)+collezione.get(1)));
                break;

                default:
                System.out.println("More than two numbers, and the result is: " + prodotto(collezione));
            }
        }  
    }

    public static int prodotto (ArrayList<Integer> x){

        int i = 0;
        int a = x.get(0);

        for (i = 1; i<= (x.size()-1); i++){
            a = a * x.get(i);
        }
        return a;
    } 
}

Ekzerco 12
Skribu java programon por administri mendojn ĉe restoraciotabloj.
Tabloj povas esti aranĝitaj en la restoracio, ĉiu kun nombra identigilo kaj kelkaj sidlokoj.
Por ĉiu tablo devas esti konservita la bevkaj la pladoj konsumitaj, devas esti eble aŭtomate kalkuli la pagitan fakturon.
La pladoj kaj la bevkaj disponeblaj, estas anstataŭe stokitaj en "Menuo" klaso kiu dividas ilin en du kategoriojn (pladoj kaj beviru, ja).
Ĉiu plado aŭ bevanda devas esti kvalifikita per unika alfanombra identigilo (nomo) kaj ĝia prezo.

Por administri la tabelojn ni faris tabelklason kun metodoj kaj atributoj por administrado. La menuo estis administrita de HashMap

import java.util.Scanner;
import java.util.HashMap;

//--------------------------------------------------------------------
//                            MAIN CLASS
//--------------------------------------------------------------------
public class Restaurant {

// Main method
    public static void main(String[] args){

        Scanner input = new Scanner(System.in);

    // Tables:
        Table tavolo1 = new Table(1,1);
        Table tavolo2 = new Table(2,2);
        Table tavolo3 = new Table(3,2);
        Table tavolo4 = new Table(4,8);
        Table tavolo5 = new Table(5,8);
        Table tavolo6 = new Table(6,8);

    // Menu as HashMap:
        HashMap<Integer, Integer> menu = new HashMap<Integer, Integer>();
        menu.put(1,5);
        menu.put(2,4);
        menu.put(3,1);
        menu.put(4,12);
        menu.put(5,1);
        menu.put(6,2);

    // Handle of request at the tables:
        while (true){
            System.out.println("Next Customers ?");
            System.out.println("(1): take a table");
            System.out.println("(2): Get an order");
            System.out.println("(3): The Bill");
            System.out.println("(0): Go Out.");

            int operazione = input.nextInt();

            if (operazione == 0)
                break;

         //switch on previous request:
            switch (operazione){

             // Take a table------------------------------------------
                case 1:
                System.out.println("Hoe many seats ?");
                System.out.println("(1): One seat");
                System.out.println("(2): Two seats");
                System.out.println("(3): from two to eight seats");

                int persone = input.nextInt();

             // switch on number of seats
                switch (persone){

                // One seat
                    case 1:
                    if (tavolo1.libero){
                        tavolo1.setOccupato();
                        System.out.println("Table number One !");
                    }
                    else
                        System.out.println("Sold Out.");
                    break;

                // Two seats
                    case 2:
                    if (tavolo2.libero){
                        tavolo2.setOccupato();
                        System.out.println("Table number Two !");
                    }
                    else if (tavolo3.libero){
                        tavolo3.setOccupato();
                        System.out.println("Table number Three !");
                    }
                    else
                        System.out.println("Sodl out.");

                    break;

                // 3 to 8 seats
                    case 3:
                    if (tavolo4.libero){
                        tavolo4.setOccupato();
                        System.out.println("Table number Four !");
                    }
                    else if (tavolo5.libero){
                        tavolo5.setOccupato();
                        System.out.println("Table number Five !");
                    }
                    else if (tavolo6.libero){
                        tavolo6.setOccupato();
                        System.out.println("Table number Six !");
                    }
                    else
                        System.out.println("Sold Out.");

                    break;

                // more than eight seats
                    default:
                    System.out.println("Not available.");
                }
                break;

             // Show Menu and take an order------------------------
                case 2:
                System.out.println("Tanle number:");
                int num = input.nextInt();//table number to get order
                System.out.println(".");

             //switch on table to order:
                switch (num){

                    case 1:
                    //loop to show menu on order
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo1.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 2:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo2.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    
                    break;

                    case 3:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo3.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 4:                 
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo4.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 5:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo5.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    case 6:
                    while (true){
                        System.out.println("MENU:");
                        System.out.println("(1) rise $5");
                        System.out.println("(2) spaghetti  $4");
                        System.out.println("(3) chicken $10");
                        System.out.println("(4) salmon $12");
                        System.out.println("(5) Water $1");
                        System.out.println("(6) coca cola $2");
                        System.out.println(".");

                        System.out.println("Insert order (0) to exit:");
                        int selezione = input.nextInt();

                        if (selezione == 0)
                            continue;
                        else {
                            tavolo6.setOrdineAttuale(selezione, menu.get(selezione));     
                        }
                        System.out.println("It's enough ?");
                        System.out.println("(1): Y; (2): N");
                        int ancora = input.nextInt();
                        if (ancora == 2)
                            break;
                    }
                    break;

                    default:
                    System.out.println("Invalid table");
                }   
                break;                

             // Payment and table available---------------------------
                case 3:
                System.out.println("Insert number of table:");
                int numero = input.nextInt();
                System.out.println(".");

             //switch on table ID
                switch (numero){

                    case 1:
                    int conto1 = somma(tavolo1.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto1);
                    
                    tavolo1.ordineAttuale = null;
                    tavolo1.libero = true;
                    break;

                    case 2:
                    int conto2 = somma(tavolo2.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto2);
                    
                    tavolo2.ordineAttuale = null;
                    tavolo2.libero = true;
                    break;

                    case 3:
                    int conto3 = somma(tavolo3.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto3);
                    
                    tavolo3.ordineAttuale = null;
                    tavolo3.libero = true;
                    break;

                    case 4:
                    int conto4 = somma(tavolo4.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto4);
                    
                    tavolo4.ordineAttuale = null;
                    tavolo4.libero = true;
                    break;

                    case 5:
                    int conto5 = somma(tavolo5.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto5);
                    
                    tavolo5.ordineAttuale = null;
                    tavolo5.libero = true;
                    break;

                    case 6:
                    int conto6 = somma(tavolo6.ordineAttuale);
                    System.out.println("Amount to pay: $" + conto6);
                    
                    tavolo6.ordineAttuale = null;
                    tavolo6.libero = true;
                    break;

                    default:
                    System.out.println("Table not available.");
                }
                break;

                default:
                System.out.println("Sold out.");
            }
            
        }
        input.close();
    }


// Method to sum amount of order 
    public static int somma(HashMap<Integer, Integer> conto){
        int a = 0;
        for (int i : conto.values()){
            a = a + i;
        }
        return a;
    }

}




//-----------------------------------------------------------------------
//                           Table class
//-----------------------------------------------------------------------

class Table {

    public boolean libero;
    public int tavoloID;
    public int coperti;
    HashMap<Integer, Integer> ordineAttuale; 

    public Table (int numero, int posti){
        this.libero = true;
        this.tavoloID = numero;
        this.coperti = posti;
        this.ordineAttuale = new HashMap<Integer, Integer>();
    }

// table not available
    public void setOccupato(){
        libero = false;
    }

// available table
    public void setLibero(){
        libero = true;
    }

// check the state of the table:
    public boolean getStato(){
        return this.libero;
    }

//
    public void setOrdineAttuale(int uno, int due){
        ordineAttuale.put(uno, due);
    }
}

redakcio BlogInnovazione.it

Etikedoj: ekzercojjavaseoprogramprojektoSoftvara EllaborantosoftvarigoProgramaro EngineeringProgramara Testado

la 9-an de oktobro 2022 6:15

sekva Fotoj, filmetoj, aŭdio: artefarita inteligenteco lernas reprodukti realecon "

antaŭa «Informtago - Disvolviĝo de la Datuma Spaco por Inteligentaj Komunumoj - Interreta evento, 18 oktobro 2022

Lastaj artikoloj

Artikoloj

Eldonistoj kaj OpenAI subskribas interkonsentojn por reguligi la fluon de informoj prilaboritaj de Artefarita Inteligenteco

Pasintlunde, la Financial Times anoncis interkonsenton kun OpenAI. FT licencas sian mondklasan ĵurnalismon...

30 aprilo 2024

Artikoloj

Interretaj Pagoj: Jen Kiel Fluaj Servoj Faras Vin Pagi Eterne

Milionoj da homoj pagas por streaming-servoj, pagante monatajn abonkotizojn. Estas komuna opinio, ke vi...

29 aprilo 2024

Comunicati Stampa

Veeam havas la plej ampleksan subtenon por ransomware, de protekto ĝis respondo kaj reakiro

Coveware de Veeam daŭre liveros servojn de respondaj incidentoj pri ciberĉantaĝo. Coveware ofertos krimmedicinajn kaj solvajn kapablojn...

23 aprilo 2024

Artikoloj

Verda kaj Cifereca Revolucio: Kiel Prognoza Prizorgado Transformas la Petrolo kaj Gasa Industrio

Prognoza prizorgado revolucias la petrolon kaj gasan sektoron, kun noviga kaj iniciatema aliro al plantadministrado...

22 aprilo 2024

Java-ekzercoj por trejna kurso de Java Base

Listo de javaj ekzercoj kun solvo por trejna kurso de Java Base.

Ekzerco 1Skribu Java-programon, kiu instigas la uzanton enigi du ŝnurojn kaj montras la uzanton vera se la ŝnuroj estas samaj kaj malvera se ili estas malsamaj.

Ekzerco 5Skribu Java-programon kiu prenas du klavarajn enigojn kaj eligas la sumon, konsiderante tion: - se ili estas du entjeroj, la sumo estas raportita kiel eligo - se ili estas du ĉenoj, la kunkateno estas raportita en la eligo

Ekzerco 6Reskribi la kodon de ekzerco 3 uzante la Ĝava troŝarĝon, definendo du metodoj, kiuj havas la saman nomon kaj kiuj efektivigas: la unua la aritmetika sumo kaj la dua la kunligado de ŝnuroj

Ekzerco 7Reskribi la kodon de ekzerco 4 uzante Java-troŝarĝon, rekonante la enhavon de ĉenoj per regulaj esprimoj. Se estas almenaŭ unu litero tiam ni kunkatenas, alie ni aldonas

Ekzerco 8Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

Ekzerco 9Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

Ekzerco 10Skribu java-programon kapablan administri la operaciojn de enigo, forigo kaj binara serĉo ene de listo de entjeroj, kun la celo administri ordigitan indekson de nombroj simulante la konduton de tabelindekso de rilata datumbazo.

Lastaj artikoloj

Eldonistoj kaj OpenAI subskribas interkonsentojn por reguligi la fluon de informoj prilaboritaj de Artefarita Inteligenteco

Interretaj Pagoj: Jen Kiel Fluaj Servoj Faras Vin Pagi Eterne

Veeam havas la plej ampleksan subtenon por ransomware, de protekto ĝis respondo kaj reakiro

Verda kaj Cifereca Revolucio: Kiel Prognoza Prizorgado Transformas la Petrolo kaj Gasa Industrio

Lastaj artikoloj

etikedo

Ekzerco 1
Skribu Java-programon, kiu instigas la uzanton enigi du ŝnurojn kaj montras la uzanton vera se la ŝnuroj estas samaj kaj malvera se ili estas malsamaj.

Ekzerco 5
Skribu Java-programon kiu prenas du klavarajn enigojn kaj eligas la sumon, konsiderante tion:
- se ili estas du entjeroj, la sumo estas raportita kiel eligo
- se ili estas du ĉenoj, la kunkateno estas raportita en la eligo

Ekzerco 6
Reskribi la kodon de ekzerco 3 uzante la Ĝava troŝarĝon, definendo du metodoj, kiuj havas la saman nomon kaj kiuj efektivigas: la unua la aritmetika sumo kaj la dua la kunligado de ŝnuroj

Ekzerco 7
Reskribi la kodon de ekzerco 4 uzante Java-troŝarĝon, rekonante la enhavon de ĉenoj per regulaj esprimoj. Se estas almenaŭ unu litero tiam ni kunkatenas, alie ni aldonas

Ekzerco 8
Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

Ekzerco 9
Skribi Java programon kiu donita nombron en enigo komputas la faktorialon uzante kaj rekurson kaj ripeton, kaj skribas ambaŭ rezultojn al la produktaĵo.

Ekzerco 10
Skribu java-programon kapablan administri la operaciojn de enigo, forigo kaj binara serĉo ene de listo de entjeroj, kun la celo administri ordigitan indekson de nombroj simulante la konduton de tabelindekso de rilata datumbazo.