用品

Java Base 培訓課程的 Java 練習

Java Base 培訓課程的 Java 練習列表和解決方案。

練習的編號表示難度級別，從最簡單到最複雜。如果您有任何意見、問題或建議：寫信給我們 info@bloginnovazione.it

練習 1
編寫一個 Java 程序，提示用戶輸入兩個字符串，如果字符串相同，則向用戶顯示 true，如果不同，則向用戶顯示 false。

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();

   }
}

練習 2
編寫一個 Java 程序，提示用戶輸入兩個字符串（str1 和 str2），並在以下條件下向用戶顯示不同的句子：
1）如果它們是相同的寫“字符串”+ + “等於” +
2）如果它們不同，請寫“字符串”+ +“不同於”+
3) 如果兩者之一包含在另一個“字符串”中 + + ”包含在 + 字符串中
4）如果其中一個包含在另一個中，請說出出現的次數，然後寫
“出現的情況是：” +

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.");
   }
}

練習 3
給定一個鍵盤輸入，檢查內容，（前三個條件並不排斥，而前三個條件的假（同時代）暗示第四個選項）：
1）如果二進制數轉換為十進制和十六進制輸出
2）如果十進制數轉換為二進制和十六進制輸出
3）如果十六進制數轉換為二進制和十進制輸出
4) 在所有其他情況下報告不可接受的輸入和請求插入
然後對於輸入 '101' 進行轉換 1、2 和 3
對於輸入 '123' 進行轉換 2 和 3
對於輸入 '89A' 進行轉換 3
對於輸入“89G”，執行第 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();
    }
}

練習 4
編寫一個程序，將溫度從攝氏度轉換為開氏度。該程序必須有兩個標籤、兩個文本字段和一個按鈕。文本字段和標籤必須組織在具有單列網格佈局的面板中；另一個面板將包含單個按鈕，主面板將包含所描述的兩個面板。

程序讀取在文本字段中輸入的與溫度相對應的值（以攝氏度為單位）。如果輸入的文本為空，則無需進行任何操作；否則將文本轉換為雙精度值，並將該值增加 273.15 以獲得開爾文度數，然後將其寫入相應的文本字段。

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();
   }
}

練習 5
編寫一個 Java 程序，它接受兩個鍵盤輸入並輸出總和，考慮到：
- 如果它們是兩個整數，則將總和報告為輸出
- 如果它們是兩個字符串，則在輸出中報告連接

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");
   }	
		
}

練習 6
使用 Java 重載重寫練習 3 的代碼， definendo 兩個具有相同名稱並實現的方法：第一個是算術和，第二個是字符串連接

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();
        

    }


}

練習 7
使用 Java 重載重寫練習 4 的代碼，使用正則表達式識別字符串的內容。如果至少有一個字母，那麼我們連接，否則我們添加

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();

    }
}

練習 8
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

在第一種情況下，我們將使用遞歸，其中方法調用自身以獲得解決方案，在第二種情況下，我們將使用類似 for 和 while 循環的循環來獲取迭代。

為了創建遞歸解決方案，我們需要一個程序終止並且遞歸停止的基本情況。我們看到基本情況是 1 的階乘，即 1，因此當您的函數調用階乘 (1) 時，您可以直接返回 1 而無需進行任何計算。並且，如果數字大於 1，我們繼續遞歸地應用階乘公式，方法是使用 n - 1 調用相同的階乘。一旦輸入變為 1，該方法將中止遞歸調用並返回 1。從那裡開始，方法堆棧有開始向下滾動，最後計算並返回一個數字的階乘。

而是使用迭代，然後使用 for 循環來計算階乘 n！ = n(n-1)(n-2) ... ..1. 你可以看到我們從數字開始，乘以初始化為1的階乘，然後我們將數字減少一個單位，直到數字變為1，也就是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();

    }
}

練習 9
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

在 Java 中有很多方法可以反轉字符串。我們可以使用高級 Java API 來快速反轉任何 String 對象的內容。 Java 庫提供了 StringBuffer 和 StringBuilder 類，帶有 reverse() 方法，可用於在 Java 中反轉 String。但是由於reverse是遞歸的，所以我們可以使用遞歸。

這是在不使用 StringBuffer 或其他 API 方法的情況下在 Java 中反轉某個字符串的算法和代碼。下面的方法展示瞭如何反轉字符串，您可以進一步重複使用它來檢查給定的字符串是否為回文。

在驗證初始輸入後，逐個字符地訪問字符串，從結尾到開頭並生成一個反向字符串。

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();
    }
}

練習 10
編寫一個能夠管理整數列表中的插入、刪除和二進制搜索操作的java程序，目的是通過模擬關係數據庫的表索引的行為來管理數字的有序索引。

為了管理索引，讓我們繼續創建索引類，其中方法是讀取索引、插入索引和刪除索引。操作之前總是有一個二元鍵搜索。

為了在數據結構中具有靈活性，最好使用數組列表。

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;
    }
}

練習 11
編寫一個 java 程序，讀取名為 textinput.txt 的輸入文件並檢查其內容
1）如果文件不存在，寫“文件不存在”
2）如果文件存在且為空，則寫“textinput.txt文件為空”
3) 如果文件存在且只包含一個數字，則在屏幕上打印該數字
4）如果文件存在並且在兩行包含兩個數字，則打印兩個數字之間的總和
5）如果文件存在並且包含兩個以上的數字，則將其設為產品

為了管理索引，讓我們繼續創建索引類，其中方法是讀取索引、插入索引和刪除索引。操作之前總是有一個二元鍵搜索。

為了在數據結構中具有靈活性，最好使用數組列表。

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;
    } 
}

練習 12
編寫一個 java 程序來管理餐廳餐桌上的訂單。
餐廳可以安排桌子，每張桌子都有一個數字 ID 和多個座位。
對於每個表必須存儲 bev以及消費的菜品，必須能夠自動計算賬單來支付。
菜品和 bev和可用的，而是存儲在“菜單”類中，該類將它們分為兩類（菜餚和 bev確實，走吧）。
每道菜或 bevanda 必須由唯一的字母數字標識符（名稱）及其價格限定。

為了管理表格，我們製作了一個帶有管理方法和屬性的表格類。菜單由 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);
    }
}

起草 BlogInnovazione.it

標籤：演習Java的SEO軟件設計軟件開發軟件開發軟件工程軟件測試

9 年 2022 月 6 日晚上 15:XNUMX

後照片、視頻、音頻：人工智能正在學習複製現實 »

Precedente « 信息日 - 智能社區數據空間部署 - 在線活動，18 年 2022 月 XNUMX 日

線上支付：串流服務如何讓您永遠付款

數百萬人為串流媒體服務付費，每月支付訂閱費用。人們普遍認為您...

29月2024

新聞發布

Veeam 為勒索軟體提供最全面的支持，從保護到回應和恢復

Veeam 的 Coveware 將繼續提供網路勒索事件回應服務。 Coveware 將提供取證和修復功能…

23月2024

用品

綠色與數位革命：預測性維護如何改變石油和天然氣產業

預測性維護正在透過創新和主動的工廠管理方法徹底改變石油和天然氣行業。

22月2024

用品

英國反壟斷監管機構對 GenAI 向 BigTech 發出警報

英國 CMA 對大型科技公司在人工智慧市場的行為發出了警告。那裡…

18月2024

Java Base 培訓課程的 Java 練習

Java Base 培訓課程的 Java 練習列表和解決方案。

練習 1
編寫一個 Java 程序，提示用戶輸入兩個字符串，如果字符串相同，則向用戶顯示 true，如果不同，則向用戶顯示 false。

練習 4
編寫一個程序，將溫度從攝氏度轉換為開氏度。該程序必須有兩個標籤、兩個文本字段和一個按鈕。文本字段和標籤必須組織在具有單列網格佈局的面板中；另一個面板將包含單個按鈕，主面板將包含所描述的兩個面板。

練習 5
編寫一個 Java 程序，它接受兩個鍵盤輸入並輸出總和，考慮到：
- 如果它們是兩個整數，則將總和報告為輸出
- 如果它們是兩個字符串，則在輸出中報告連接

練習 6
使用 Java 重載重寫練習 3 的代碼， definendo 兩個具有相同名稱並實現的方法：第一個是算術和，第二個是字符串連接

練習 7
使用 Java 重載重寫練習 4 的代碼，使用正則表達式識別字符串的內容。如果至少有一個字母，那麼我們連接，否則我們添加

練習 8
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 9
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 10
編寫一個能夠管理整數列表中的插入、刪除和二進制搜索操作的java程序，目的是通過模擬關係數據庫的表索引的行為來管理數字的有序索引。

最近的文章

線上支付：串流服務如何讓您永遠付款

Veeam 為勒索軟體提供最全面的支持，從保護到回應和恢復

綠色與數位革命：預測性維護如何改變石油和天然氣產業

英國反壟斷監管機構對 GenAI 向 BigTech 發出警報

最近的文章

標籤

Java Base 培訓課程的 Java 練習

Java Base 培訓課程的 Java 練習列表和解決方案。

練習 1編寫一個 Java 程序，提示用戶輸入兩個字符串，如果字符串相同，則向用戶顯示 true，如果不同，則向用戶顯示 false。

練習 5編寫一個 Java 程序，它接受兩個鍵盤輸入並輸出總和，考慮到： - 如果它們是兩個整數，則將總和報告為輸出 - 如果它們是兩個字符串，則在輸出中報告連接

練習 6使用 Java 重載重寫練習 3 的代碼， definendo 兩個具有相同名稱並實現的方法：第一個是算術和，第二個是字符串連接

練習 7使用 Java 重載重寫練習 4 的代碼，使用正則表達式識別字符串的內容。 如果至少有一個字母，那麼我們連接，否則我們添加

練習 8編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 9編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 10編寫一個能夠管理整數列表中的插入、刪除和二進制搜索操作的java程序，目的是通過模擬關係數據庫的表索引的行為來管理數字的有序索引。

最近的文章

線上支付：串流服務如何讓您永遠付款

Veeam 為勒索軟體提供最全面的支持，從保護到回應和恢復

綠色與數位革命：預測性維護如何改變石油和天然氣產業

英國反壟斷監管機構對 GenAI 向 BigTech 發出警報

最近的文章

標籤

練習 1
編寫一個 Java 程序，提示用戶輸入兩個字符串，如果字符串相同，則向用戶顯示 true，如果不同，則向用戶顯示 false。

練習 5
編寫一個 Java 程序，它接受兩個鍵盤輸入並輸出總和，考慮到：
- 如果它們是兩個整數，則將總和報告為輸出
- 如果它們是兩個字符串，則在輸出中報告連接

練習 6
使用 Java 重載重寫練習 3 的代碼， definendo 兩個具有相同名稱並實現的方法：第一個是算術和，第二個是字符串連接

練習 7
使用 Java 重載重寫練習 4 的代碼，使用正則表達式識別字符串的內容。如果至少有一個字母，那麼我們連接，否則我們添加

練習 8
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 9
編寫一個在輸入中給定數字的 Java 程序，使用遞歸和迭代計算階乘，並將兩個結果寫入輸出。

練習 10
編寫一個能夠管理整數列表中的插入、刪除和二進制搜索操作的java程序，目的是通過模擬關係數據庫的表索引的行為來管理數字的有序索引。