품목

Java Base 교육 과정을 위한 Java 연습

Java Base 교육 과정에 대한 솔루션이 포함된 Java 연습 목록입니다.

연습의 번호는 가장 간단한 것부터 가장 복잡한 것까지 난이도를 나타냅니다. 의견, 질문 또는 제안 사항이 있으면 info @로 저희에게 편지를 보내주십시오.bloginnovazione.it

연습 1
사용자에게 두 개의 문자열을 입력하라는 메시지를 표시하고 문자열이 같으면 true를 표시하고 다르면 false를 표시하는 Java 프로그램을 작성하십시오.

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
사용자에게 두 개의 문자열(str1 및 str2)을 입력하도록 프롬프트하고 다음 조건에서 사용자에게 다른 문장을 표시하는 Java 프로그램을 작성하십시오.
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) XNUMX진수를 XNUMX진수 및 XNUMX진수 출력으로 변환하는 경우
2) XNUMX진수를 XNUMX진수 및 XNUMX진수로 출력하는 경우
3) XNUMX진수가 XNUMX진수 및 XNUMX진수 출력으로 변환되는 경우
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의 코드를 다시 작성합니다. defi이름이 같고 구현하는 두 가지 방법: 첫 번째는 산술 합계이고 두 번째는 문자열 연결입니다.

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이 될 때까지 숫자를 XNUMX단위로 줄이는 것을 볼 수 있습니다. 이는 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 클래스에 Java에서 String을 반전시키는 데 사용할 수 있는 reverse() 메소드를 제공합니다. 그러나 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 프로그램을 작성하십시오.

인덱스 관리를 위해 인덱스 읽기, 인덱스 삽입, 인덱스 제거 메소드가 있는 인덱스 클래스 생성을 진행해 보겠습니다. 작업은 항상 이진 키 검색이 선행됩니다.

데이터 구조에 유연성을 가지려면 arraylist를 사용하는 것이 좋습니다.

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
textinput.txt라는 입력 파일을 읽고 내용을 확인하는 자바 프로그램을 작성하세요.
1) 파일이 존재하지 않는 경우 "파일이 존재하지 않음"으로 작성
2) 파일이 존재하고 비어있는 경우 "the textinput.txt 파일이 비어있습니다"라고 작성
3) 파일이 존재하고 하나의 숫자만 포함하는 경우 화면에 숫자를 인쇄합니다.
4) 파일이 존재하고 두 줄에 두 개의 숫자가 포함된 경우 두 숫자 사이의 합계를 출력합니다.
5) 파일이 존재하고 두 개 이상의 숫자를 포함하는 경우 제품으로

데이터 구조에 유연성을 가지려면 arraylist를 사용하는 것이 좋습니다.

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
식당 테이블에서 주문을 관리하는 자바 프로그램을 작성하십시오.
레스토랑에는 숫자 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

태그 : 연습 문제자바검색 엔진 최적화소프트웨어 설계소프트웨어 개발자소프트웨어 개발소프트웨어 공학소프트웨어 테스팅

9년 2022월 6일 오후 15시 XNUMX분

다음의 사진, 비디오, 오디오 : 인공 지능은 현실을 복제하는 법을 배우고 있습니다 "

Precedente «Info Day - 스마트 커뮤니티를 위한 데이터 공간 배포 - 온라인 이벤트, 18년 2022월 XNUMX일

최근 기사

품목

어린이를 위한 컬러링 페이지의 장점 - 모든 연령대를 위한 마법의 세계

색칠을 통해 소근육 운동 능력을 키우면 아이들이 글쓰기와 같은 보다 복잡한 기술을 준비할 수 있습니다. 색칠하다…

2 월 2024

품목

미래가 여기에 있습니다: 해운 산업이 글로벌 경제를 어떻게 혁신하고 있습니까?

해군 부문은 150억 시장을 향해 항해해온 진정한 글로벌 경제강국입니다.

1 월 2024

품목

출판사와 OpenAI, 인공지능이 처리하는 정보의 흐름을 규제하기 위한 계약 체결

지난 월요일, Financial Times는 OpenAI와의 계약을 발표했습니다. FT는 세계적 수준의 저널리즘에 라이선스를 부여합니다…

4월 30 2024

품목

온라인 결제: 스트리밍 서비스를 통해 영원히 결제하는 방법은 다음과 같습니다.

수백만 명의 사람들이 스트리밍 서비스 비용을 지불하고 월간 구독료를 지불합니다. 당신은…

4월 29 2024

Java Base 교육 과정을 위한 Java 연습

Java Base 교육 과정에 대한 솔루션이 포함된 Java 연습 목록입니다.

연습 1사용자에게 두 개의 문자열을 입력하라는 메시지를 표시하고 문자열이 같으면 true를 표시하고 다르면 false를 표시하는 Java 프로그램을 작성하십시오.

연습 5다음을 고려하여 두 개의 키보드 입력을 받아 합을 출력하는 Java 프로그램을 작성하십시오. - 두 개의 정수인 경우 합계가 출력으로 보고됩니다. - 두 문자열이면 연결이 출력에 보고됩니다.

연습 6Java 오버로드를 사용하여 연습 3의 코드를 다시 작성합니다. defi이름이 같고 구현하는 두 가지 방법: 첫 번째는 산술 합계이고 두 번째는 문자열 연결입니다.

연습 7정규 표현식을 사용하여 문자열의 내용을 인식하고 Java 오버로딩을 사용하여 연습 4의 코드를 다시 작성합니다. 적어도 하나의 문자가 있으면 연결하고, 그렇지 않으면 추가합니다.

연습 8입력에 숫자가 지정된 Java 프로그램을 작성하면 재귀와 반복을 모두 사용하여 계승을 계산하고 두 결과를 출력에 기록합니다.

연습 9입력에 숫자가 지정된 Java 프로그램을 작성하면 재귀와 반복을 모두 사용하여 계승을 계산하고 두 결과를 출력에 기록합니다.

연습 10관계형 데이터베이스의 테이블 인덱스 동작을 시뮬레이션하여 정렬된 숫자 인덱스를 관리하는 것을 목표로 정수 목록 내에서 삽입, 삭제 및 이진 검색 작업을 관리할 수 있는 Java 프로그램을 작성하십시오.

최근 기사

어린이를 위한 컬러링 페이지의 장점 - 모든 연령대를 위한 마법의 세계

미래가 여기에 있습니다: 해운 산업이 글로벌 경제를 어떻게 혁신하고 있습니까?

출판사와 OpenAI, 인공지능이 처리하는 정보의 흐름을 규제하기 위한 계약 체결

온라인 결제: 스트리밍 서비스를 통해 영원히 결제하는 방법은 다음과 같습니다.

최근 기사

꼬리표

연습 1
사용자에게 두 개의 문자열을 입력하라는 메시지를 표시하고 문자열이 같으면 true를 표시하고 다르면 false를 표시하는 Java 프로그램을 작성하십시오.

연습 5
다음을 고려하여 두 개의 키보드 입력을 받아 합을 출력하는 Java 프로그램을 작성하십시오.
- 두 개의 정수인 경우 합계가 출력으로 보고됩니다.
- 두 문자열이면 연결이 출력에 보고됩니다.

연습 6
Java 오버로드를 사용하여 연습 3의 코드를 다시 작성합니다. defi이름이 같고 구현하는 두 가지 방법: 첫 번째는 산술 합계이고 두 번째는 문자열 연결입니다.

연습 7
정규 표현식을 사용하여 문자열의 내용을 인식하고 Java 오버로딩을 사용하여 연습 4의 코드를 다시 작성합니다. 적어도 하나의 문자가 있으면 연결하고, 그렇지 않으면 추가합니다.

연습 8
입력에 숫자가 지정된 Java 프로그램을 작성하면 재귀와 반복을 모두 사용하여 계승을 계산하고 두 결과를 출력에 기록합니다.

연습 9
입력에 숫자가 지정된 Java 프로그램을 작성하면 재귀와 반복을 모두 사용하여 계승을 계산하고 두 결과를 출력에 기록합니다.

연습 10
관계형 데이터베이스의 테이블 인덱스 동작을 시뮬레이션하여 정렬된 숫자 인덱스를 관리하는 것을 목표로 정수 목록 내에서 삽입, 삭제 및 이진 검색 작업을 관리할 수 있는 Java 프로그램을 작성하십시오.