货物

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

标签： esercizijava的搜索引擎优化软件设计软件开发人员软件开发软件工程软件测试

9 年 2022 月 6 日下午 15:XNUMX

后照片、视频、音频：人工智能正在学习复制现实”

前 «信息日 - 为智能社区部署数据空间 - 在线活动，18 年 2022 月 XNUMX 日

Articoli最新回应

货物

卡塔尼亚综合诊所的 Apple 观众对增强现实进行创新干预

卡塔尼亚综合诊所使用 Apple Vision Pro 商业查看器进行了眼部整形手术……

3 2024五月

货物

儿童涂色页的好处 - 适合所有年龄段的魔法世界

通过着色培养精细运动技能可以帮助孩子们为写作等更复杂的技能做好准备。填色…

2 2024五月

货物

未来已来：航运业如何彻底改变全球经济

海军部门是真正的全球经济力量，已迈向 150 亿美元的市场……

1 2024五月

货物

出版商和 OpenAI 签署协议以规范人工智能处理的信息流

上周一，英国《金融时报》宣布与 OpenAI 达成协议。英国《金融时报》授予其世界级新闻报道许可……

四月30 2024

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程序，目的是通过模拟关系数据库的表索引的行为来管理数字的有序索引。

Articoli最新回应

卡塔尼亚综合诊所的 Apple 观众对增强现实进行创新干预

儿童涂色页的好处 - 适合所有年龄段的魔法世界

未来已来：航运业如何彻底改变全球经济

出版商和 OpenAI 签署协议以规范人工智能处理的信息流

Articoli最新回应

标签

练习 1
编写一个 Java 程序，提示用户输入两个字符串，如果字符串相同，则向用户显示 true，如果不同，则向用户显示 false。

练习 5
编写一个 Java 程序，它接受两个键盘输入并输出总和，考虑到：
- 如果它们是两个整数，则将总和报告为输出
- 如果它们是两个字符串，则在输出中报告连接

练习 6
使用 Java 重载重写练习 3 的代码， definendo 两个具有相同名称并实现的方法：第一个是算术和，第二个是字符串连接

练习 7
使用 Java 重载重写练习 4 的代码，使用正则表达式识别字符串的内容。如果至少有一个字母，那么我们连接，否则我们添加

练习 8
编写一个在输入中给定数字的 Java 程序，使用递归和迭代计算阶乘，并将两个结果写入输出。

练习 9
编写一个在输入中给定数字的 Java 程序，使用递归和迭代计算阶乘，并将两个结果写入输出。

练习 10
编写一个能够管理整数列表中的插入、删除和二进制搜索操作的java程序，目的是通过模拟关系数据库的表索引的行为来管理数字的有序索引。