API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 8th, 2019
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 21.78 KB | None | 0 0
raw download clone embed print report
  1. package trabalhoPratico3;
  2.  
  3. import java.util.Locale;
  4. import java.util.Scanner;
  5.  
  6. public class ShopEST {
  7.  
  8.     public static void main(String[] args) {
  9.         Locale.setDefault(Locale.US);
  10.         int tamMax = 100;
  11.  
  12.         String[] nome = new String[tamMax];
  13.         double[] quanto = new double[tamMax];
  14.         double[] preco = new double[tamMax];
  15.         boolean[] feito = new boolean[tamMax];
  16.  
  17.         //Arrays para copia de dados
  18.         String[] nomeCopia = new String[tamMax];
  19.         double[] quantoCopia = new double[tamMax];
  20.         double[] precoCopia = new double[tamMax];
  21.         boolean[] feitoCopia = new boolean[tamMax];
  22.  
  23.         int[] posicaoInserida = new int[tamMax];
  24.         int posicaoUltimoInserido = 0;
  25.         int nItens = 0;
  26.         menuPrincipal(nItens, nome, quanto, preco, feito, posicaoUltimoInserido, posicaoInserida);
  27.     }
  28.  
  29.     static void menuPrincipal(int nItens, String nome[], double quanto[], double preco[], boolean feito[], int posicaoUltimoInserido, int posicaoInserida[]) {
  30.         char opcao;
  31.         do {
  32.             System.out.println("(E)ditar lista.");
  33.             System.out.println("(F)azer compras.");
  34.             System.out.println("Fazer (c)ontas.");
  35.             System.out.println("(U)tilidades.");
  36.             System.out.println("(S)air.");
  37.             opcao = lerChar();
  38.             switch (opcao) {
  39.             case 'E':
  40.             case 'e':
  41.                 nItens = editarLista(nItens, nome, quanto, preco, feito, posicaoUltimoInserido, posicaoInserida);
  42.                 break;
  43.             case 'F':
  44.             case 'f':
  45.                 fazerCompras(nItens, nome, quanto, preco, feito);
  46.                 break;
  47.             case 'C':
  48.             case 'c':
  49.                 fazerContas(nItens, nome, quanto, preco, feito);
  50.                 break;
  51.             case 'U':
  52.             case 'u':
  53.                 utilidades(nItens, nome, quanto, preco, feito);
  54.                 break;
  55.             case 'S':
  56.             case 's':
  57.                 System.out.println("**Adeus, obrigado por usar shopEST!**");
  58.                 break;
  59.             default:
  60.                 System.out.println("Escolha uma opção válida.");
  61.                 break;
  62.             }
  63.         } while (opcao != 's' && opcao != 'S');
  64.     }
  65.  
  66.     /*//////////////////////////////////////////////////
  67.     //////////////////EDITAR LISTA////////////////////*/
  68.     static int editarLista(int nItens, String nome[], double quanto[], double preco[], boolean feito[], int posicaoUltimoInserido, int posicaoInserida[]) {
  69.         char editar;
  70.         do {
  71.             System.out.println("(I)nserir item no fim da lista.");
  72.             System.out.println("Inserir item na (p)osição n da lista.");
  73.             System.out.println("Apagar últim(o) item inserido na lista.");
  74.             System.out.println("Apagar item na posição (n) da lista.");
  75.             System.out.println("(A)pagar itens da posição m à n da lista.");
  76.             System.out.println("(L)istar todos os itens.");
  77.             System.out.println("(V)oltar.");
  78.             editar = lerChar();
  79.             switch (editar) {
  80.             case 'I':
  81.             case 'i':
  82.                 nItens = inserirFimLista(nItens, nome, quanto, preco, feito, posicaoUltimoInserido, posicaoInserida);
  83.                 posicaoUltimoInserido++;   
  84.                 break;
  85.             case 'p':
  86.             case 'P':
  87.                 nItens = inserirPosicaoN(nItens, nome, quanto, preco, feito, posicaoUltimoInserido, posicaoInserida);
  88.                 posicaoUltimoInserido++;
  89.                 break;
  90.             case 'o':
  91.             case 'O':
  92.                 nItens = apagarUltimoInserido(nItens, nome, quanto, preco, feito, posicaoUltimoInserido, posicaoInserida);
  93.                 posicaoUltimoInserido--;
  94.                 break;
  95.             case 'n':
  96.             case 'N':
  97.                 nItens = apagarPosicaoN(nItens, nome, quanto, preco, feito);
  98.                 break;
  99.             case 'a':
  100.             case 'A':
  101.                 //como neste caso o nItens precisava do maior e menor da funcao, decidi fazer return do propio nItens.
  102.                 nItens = apagarMN(nItens, nome, quanto, preco, feito);
  103.                 break;
  104.             case 'l':
  105.             case 'L':
  106.                 listarItems(nItens, nome, quanto, preco, feito);
  107.                 break;
  108.             case 'V':
  109.             case 'v':
  110.                 System.out.println("A voltar atrás no menu...");
  111.                 break;
  112.             default:
  113.                 System.out.println("Escolha uma opção válida.");
  114.                 break;
  115.             }
  116.  
  117.         } while (editar != 'v' && editar != 'V');
  118.         return nItens;
  119.     }
  120.  
  121.     static int inserirFimLista(int nItens, String nome[], double quanto[], double preco[], boolean feito[], int posicaoUltimoInserido, int posicaoInserida[]) {
  122.         if (nItens < nome.length) {
  123.             System.out.println("Qual o nome do produto?");
  124.             nome[nItens] = lerString();
  125.             System.out.println("Quantas unidades?");
  126.             quanto[nItens] = lerInt();
  127.             System.out.println("Qual o preço?");
  128.             preco[nItens] = lerDouble();
  129.             feito[nItens] = false;
  130.             posicaoInserida[posicaoUltimoInserido] = nItens;
  131.             nItens++;
  132.         } else {
  133.             System.out.println("A lista já está cheia!");
  134.         }
  135.         return nItens;
  136.     }
  137.     static int inserirPosicaoN(int nItens, String nome[], double quanto[], double preco[], boolean feito[], int posicaoUltimoInserido, int posicaoInserida[]) {
  138.         System.out.println("Em que posição deseja inserir o item?");
  139.         int inserirPosicao = lerInt();
  140.         if (nItens != 0) { /*caso a lista estiver vazia e quiser adicionar na posicao 0 é possivel*/
  141.             while (inserirPosicao > nItens - 1 || inserirPosicao < 0) {
  142.                 System.out.println("Por favor, escolha uma posição já ocupada.");
  143.                 System.out.println("Em que posição deseja inserir o item?");
  144.                 inserirPosicao = lerInt();
  145.             }
  146.  
  147.             /*Executamos um ciclo for para passar para a frente os items desde a posição em que foi inserido o item,
  148.               colocando depois o item no espaço vazio que resultou do ciclo for.
  149.               O aux server para aceder à posição inicial do item a passar para a direita.*/
  150.  
  151.             for (int i = 0, aux = 1; i < (nItens - inserirPosicao); i++, aux++) {
  152.                 nome[nItens - i] = nome[nItens - aux];
  153.                 quanto[nItens - i] = quanto[nItens - aux];
  154.                 preco[nItens - i] = preco[nItens - aux];
  155.                 feito[nItens - i] = feito[nItens - aux];
  156.             }
  157.         }
  158.         System.out.println("Qual o nome do produto?");
  159.         nome[inserirPosicao] = lerString();
  160.         System.out.println("Quantas unidades?");
  161.         quanto[inserirPosicao] = lerDouble();
  162.         System.out.println("Qual o preço?");
  163.         preco[inserirPosicao] = lerDouble();
  164.         feito[inserirPosicao] = false;
  165.         posicaoInserida[posicaoUltimoInserido] = inserirPosicao; /*Guarda no array posicaoInserida o indice da lista em que foi inserido, caso seja preciso apagar no futuro*/
  166.         nItens++;
  167.         return nItens;
  168.     }
  169.     static int apagarUltimoInserido(int nItens, String nome[], double quanto[], double preco[], boolean feito[], int posicaoUltimoInserido, int posicaoInserida[]) {
  170.         if (nItens == 0) {
  171.             System.out.println("A lista está vazia");
  172.         } else {
  173.             /*Vai buscar ao array posicaoInserida o valor do indice que temos que apagar, e caso esteja no meio da lista o
  174.               ciclo for serve para puxar para trás uma casa cada item, desde a posição do item apagado*/
  175.             for (int i = 1, aux = 0; i < (nItens - posicaoInserida[posicaoUltimoInserido - 1]); i++, aux++) {
  176.                 nome[posicaoInserida[posicaoUltimoInserido - 1] + aux] = nome[posicaoInserida[posicaoUltimoInserido - 1] + i];
  177.                 quanto[posicaoInserida[posicaoUltimoInserido - 1] + aux] = quanto[posicaoInserida[posicaoUltimoInserido - 1] + i];
  178.                 preco[posicaoInserida[posicaoUltimoInserido - 1] + aux] = preco[posicaoInserida[posicaoUltimoInserido - 1] + i];
  179.                 feito[posicaoInserida[posicaoUltimoInserido - 1] + aux] = feito[posicaoInserida[posicaoUltimoInserido - 1] + i];
  180.             }  
  181.             nItens--;
  182.         }
  183.         return nItens;
  184.     }
  185.     static int apagarPosicaoN(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  186.         if (nItens == 0) {
  187.             System.out.println("A lista está vazia.");
  188.         } else {
  189.             System.out.println("Em que posição deseja retirar o item?");
  190.             int apagarPosicao = lerInt();
  191.             while (apagarPosicao > nItens - 1 || apagarPosicao < 0) {
  192.                 System.out.println("Por favor, escolha uma posição ocupada.");
  193.                 System.out.println("Em que posição deseja retirar o item?");
  194.                 apagarPosicao = lerInt();
  195.             }
  196.  
  197.             /*Usamos o ciclo for para puxar para trás uma casa cada item, desde a posição do item apagado.
  198.               O aux é usado para anexar o indice anterior, o i o indice a seguir, enquanto percorre a lista.*/
  199.  
  200.             for (int i = 1, aux = 0; i < (nItens - apagarPosicao); i++, aux++) {
  201.                 nome[apagarPosicao + aux] = nome[apagarPosicao + i];
  202.                 quanto[apagarPosicao + aux] = quanto[apagarPosicao + i];
  203.                 preco[apagarPosicao + aux] = preco[apagarPosicao + i];
  204.                 feito[apagarPosicao + aux] = feito[apagarPosicao + i];
  205.             }
  206.             nItens--;
  207.         }
  208.         return nItens;
  209.     }
  210.     static int apagarMN(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  211.         if (nItens == 0) {
  212.             System.out.println("A lista está vazia.");
  213.             return nItens;
  214.         } else {
  215.             int posicaoM, posicaoN;
  216.             System.out.println("Indique a posicao m e n para apagar da lista.");
  217.             posicaoM = lerInt();
  218.             posicaoN = lerInt();
  219.             while (posicaoM == posicaoN || posicaoM > nItens || posicaoN > nItens || posicaoM < 0 || posicaoN < 0) {
  220.                 System.out.println("As posições têm de existir na lista e não podem ser iguais.");
  221.                 System.out.println("Indique a posicao m e n para apagar da lista.");
  222.                 posicaoM = lerInt();
  223.                 posicaoN = lerInt();
  224.             }
  225.             /*Usamos o codigo seguinte para caso os numeros introduzidos pelo utilizador não estejam ordenados,
  226.               o aux será será o numero de vezes que temos que andar para a esquerda para "fechar" a lista quando apagadas as posições.*/
  227.  
  228.             int maior = (posicaoM > posicaoN) ? posicaoM : posicaoN;
  229.             int menor = (posicaoM < posicaoN) ? posicaoM : posicaoN;
  230.             int aux = nItens - maior - 1;
  231.  
  232.             /*Os numeros que se encontrarem a partir do maior para a frente serao copiados para o lugar do menor e adiante.*/
  233.  
  234.             for (int i = 0; i < aux; i++) {
  235.                 nome[menor + i] = nome[maior + i + 1];
  236.                 quanto[menor + i] = quanto[maior + i + 1];
  237.                 preco[menor + i] = preco[maior + i + 1];
  238.                 feito[menor + i] = feito[maior + i + 1];
  239.             }
  240.             nItens -= maior - menor + 1;
  241.             return nItens;
  242.         }
  243.     }
  244.     static void listarItems(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  245.         if (nItens == 0) {
  246.             System.out.println("\n**A lista está vazia.**");
  247.         } else {
  248.             System.out.printf("%7s %20s %15s %15s\n", "Item", "Quantidade", "Preço", "Comprado");
  249.             for (int i = 0; i < nItens; i++) {
  250.                 System.out.printf("%d: %-15s %-12.3f  %10.2f€ %12s\n", i, nome[i], quanto[i], preco[i], feito[i] ? "x" : "");
  251.             }
  252.             System.out.println();
  253.         }
  254.     }
  255.     /*//////////////////////////////////////////////////
  256.     //////////////////FAZER COMPRAS////////////////////*/
  257.     static void fazerCompras(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  258.         char fazerCompras;
  259.         do {
  260.             System.out.println("(M)arcar primeiro item por comprar.");
  261.             System.out.println("(D)esmarcar primeiro item comprado.");
  262.             System.out.println("Trocar estado por (n)ome.");
  263.             System.out.println("Trocar estado por (p)osição.");
  264.             System.out.println("(L)istar.");
  265.             System.out.println("(V)oltar.");
  266.             fazerCompras = lerChar();
  267.             switch (fazerCompras) {
  268.             case 'M':
  269.             case 'm':
  270.                 marcarPrimeiro(nItens, feito);
  271.                 break;
  272.             case 'd':
  273.             case 'D':
  274.                 desmarcarPrimeiro(nItens, feito);
  275.                 break;
  276.             case 'n':
  277.             case 'N':
  278.                 trocarEstadoNome(nItens, nome, feito);
  279.                 break;
  280.             case 'p':
  281.             case 'P':
  282.                 trocarEstadoPosicao(nItens, feito);
  283.                 break;
  284.             case 'l':
  285.             case 'L':
  286.                 listar(nItens, nome, quanto, preco, feito);
  287.                 break;
  288.             case 'V':
  289.             case 'v':
  290.                 System.out.println("A voltar atrás no menu...");
  291.                 break;
  292.             default:
  293.                 System.out.println("Escolha uma opção válida.");
  294.                 break;
  295.             }
  296.         } while (fazerCompras != 'v' && fazerCompras != 'V');
  297.     }
  298.     static void marcarPrimeiro(int nItens, boolean feito[]) {
  299.         if (nItens == 0) {
  300.             System.out.println("A lista está vazia.");
  301.         } else {
  302.             boolean porComprar = false;
  303.             /*Vamos percorrer a lista e encontrar o 1º item que esteja por comprar e marca-lo como comprado.*/
  304.             for (int i = 0; i < nItens; i++) {
  305.                 if (feito[i] == false) {
  306.                     feito[i] = true;
  307.                     porComprar = true;
  308.                     break;
  309.                 }
  310.             }
  311.             if (!porComprar) {
  312.                 System.out.println("Não há items por comprar.");
  313.             }
  314.         }
  315.     }
  316.     static void desmarcarPrimeiro(int nItens, boolean feito[]) {
  317.         if (nItens == 0) {
  318.             System.out.println("A lista está vazia.");
  319.         } else {
  320.             boolean comprado = false;
  321.             /*Percorremos a lista e desmarcamos o primeiro item comprado que encontrarmos.*/
  322.             for (int i = 0; i < nItens; i++) {
  323.                 if (feito[i] == true) {
  324.                     feito[i] = false;
  325.                     comprado = true;
  326.                     break;
  327.                 }
  328.             }
  329.             if (!comprado) {
  330.                 System.out.println("Não há items comprados para desmarcar.");
  331.             }
  332.         }
  333.     }
  334.     static void trocarEstadoNome(int nItens, String nome[], boolean feito[]) {
  335.         if (nItens == 0) {
  336.             System.out.println("A lista está vazia.");
  337.         } else {
  338.             System.out.println("Indique o nome do item para trocar de estado (comprado/não comprado)");
  339.             String nomeTrocarEstado = lerString();
  340.             boolean nomeExiste = false;
  341.             for (int i = 0; i < nItens; i++) {
  342.                 if (nome[i].equalsIgnoreCase(nomeTrocarEstado)) {
  343.                     feito[i] = !feito[i];
  344.                     nomeExiste = true;
  345.                     break;
  346.                 }
  347.             }
  348.             if (!nomeExiste) {
  349.                 System.out.println("O nome que procura não existe.");
  350.             }
  351.         }
  352.     }
  353.     static void trocarEstadoPosicao(int nItens, boolean feito[]) {
  354.         if (nItens == 0) {
  355.             System.out.println("A lista está vazia.");
  356.         } else {
  357.             System.out.println("Indique a posição do item para trocar de estado (comprado/não comprado)");
  358.             int posicaoTrocarEstado = lerInt();
  359.             if (posicaoTrocarEstado < 0 || posicaoTrocarEstado > nItens - 1) {
  360.                 System.out.println("A posição não existe.");
  361.             } else {
  362.                 feito[posicaoTrocarEstado] = !feito[posicaoTrocarEstado];
  363.             }
  364.         }
  365.     }
  366.     static void listar(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  367.         char listar;
  368.         do {
  369.             System.out.println("Listar (t)odos os itens");
  370.             System.out.println("Listar itens (c)omprados");
  371.             System.out.println("Listar itens (p)or comprar");
  372.             System.out.println("(V)oltar.");
  373.             listar = lerChar();
  374.             switch (listar) {
  375.             case 't':
  376.             case 'T':
  377.                 listarItems(nItens, nome, quanto, preco, feito);
  378.                 break;
  379.             case 'c':
  380.             case 'C':
  381.                 listaComprados(nItens, nome, quanto, preco, feito);
  382.                 break;
  383.             case 'p':
  384.             case 'P':
  385.                 listaPorComprar(nItens, nome, quanto, preco, feito);
  386.                 break;
  387.             case 'V':
  388.             case 'v':
  389.                 System.out.println("A voltar atrás no menu...");
  390.                 break;
  391.             default:
  392.                 System.out.println("Escolha uma opção válida.");
  393.                 break;
  394.             }
  395.         } while (listar != 'v' && listar != 'V');
  396.  
  397.     }
  398.     static void listaComprados(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  399.         int itensComprados = 0;
  400.         if (nItens == 0) {
  401.             System.out.println("\nA lista está vazia.");
  402.         } else {
  403.             for (int i = 0; i < nItens; i++) {
  404.                 if (feito[i]) {
  405.                     itensComprados++;
  406.                 }
  407.             }
  408.             if (itensComprados < 1) {
  409.                 System.out.println("Não ha itens comprados.");
  410.             } else {
  411.                 String nomeAux[] = new String[itensComprados];
  412.                 double quantoAux[] = new double[itensComprados];
  413.                 double precoAux[] = new double[itensComprados];
  414.                 boolean feitoAux[] = new boolean[itensComprados];
  415.                 for (int i = 0, j = 0; i < nItens; i++) {
  416.                     if (feito[i]) {
  417.                         nomeAux[j] = nome[i];
  418.                         quantoAux[j] = quanto[i];
  419.                         precoAux[j] = preco[i];
  420.                         feitoAux[j] = feito[i];
  421.                         j++;
  422.                     }
  423.                 }
  424.                 listarItems(itensComprados, nomeAux, quantoAux, precoAux, feitoAux);
  425.                 System.out.println();
  426.             }
  427.         }
  428.     }
  429.     static void listaPorComprar(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  430.         int porComprar = 0;
  431.         if (nItens == 0) {
  432.             System.out.println("\nA lista está vazia.");
  433.         } else {
  434.             for (int i = 0; i < nItens; i++) {
  435.                 if (!feito[i]) {
  436.                     porComprar++;
  437.                 }
  438.             }
  439.             if (porComprar < 1) {
  440.                 System.out.println("Não restam itens por comprar.");
  441.             } else {
  442.                 String nomeAux[] = new String[porComprar];
  443.                 double quantoAux[] = new double[porComprar];
  444.                 double precoAux[] = new double[porComprar];
  445.                 boolean feitoAux[] = new boolean[porComprar];
  446.                 for (int i = 0, j = 0; i < nItens; i++) {
  447.                     if (!feito[i]) {
  448.                         nomeAux[j] = nome[i];
  449.                         quantoAux[j] = quanto[i];
  450.                         precoAux[j] = preco[i];
  451.                         feitoAux[j] = feito[i];
  452.                         j++;
  453.                     }
  454.                 }
  455.                 listarItems(porComprar, nomeAux, quantoAux, precoAux, feitoAux);
  456.                 System.out.println();
  457.             }
  458.         }
  459.     }
  460.     /*//////////////////////////////////////////////////
  461.     //////////////////FAZER CONTAS////////////////////*/
  462.     static void fazerContas(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  463.         char fazerContas;
  464.         do {
  465.             System.out.println("Quanto custa a (l)ista?");
  466.             System.out.println("Quanto já (g)astei?");
  467.             System.out.println("Quanto custa o que (f)alta comprar?");
  468.             System.out.println("Qual o preço (m)édio por item?");
  469.             System.out.println("(V)oltar.");
  470.             fazerContas = lerChar();
  471.             switch (fazerContas) {
  472.             case 'l':
  473.             case 'L':
  474.                 custoLista(nItens, quanto, preco);
  475.                 break;
  476.             case 'g':
  477.             case 'G':
  478.                 quantoGastei(nItens, quanto, preco, feito);
  479.                 break;
  480.             case 'f':
  481.             case 'F':
  482.                 quantoCustaFaltaComprar(nItens, quanto, preco, feito);
  483.                 break;
  484.             case 'm':
  485.             case 'M':
  486.                 precoMedio(nItens, quanto, preco);
  487.                 break;
  488.             case 'V':
  489.             case 'v':
  490.                 System.out.println("A voltar atrás no menu...");
  491.                 break;
  492.             default:
  493.                 System.out.println("Escolha uma opção válida.");
  494.                 break;
  495.             }
  496.         } while (fazerContas != 'v' && fazerContas != 'V');
  497.     }
  498.     static void custoLista(int nItens, double quanto[], double preco[]) {
  499.         if (nItens == 0) {
  500.             System.out.println("A lista está vazia.");
  501.         } else {
  502.             double custoLista = 0;
  503.             for (int i = 0; i < nItens; i++) {
  504.                 custoLista += preco[i] * quanto[i];
  505.             }
  506.             System.out.printf("A lista custa %.2f€\n", custoLista);
  507.         }
  508.     }
  509.     static void quantoGastei(int nItens, double quanto[], double preco[], boolean feito[]) {
  510.         if (nItens == 0) {
  511.             System.out.println("A lista está vazia.");
  512.         } else {
  513.             double gasto = 0;
  514.             for (int i = 0; i < nItens; i++) {
  515.                 if (feito[i]) {
  516.                     gasto += preco[i] * quanto[i];
  517.                 }
  518.             }
  519.             System.out.printf("Gastou %.2f€\n", gasto);
  520.         }
  521.     }
  522.     static void quantoCustaFaltaComprar(int nItens, double quanto[], double preco[], boolean feito[]) {
  523.         if (nItens == 0) {
  524.             System.out.println("A lista está vazia.");
  525.         } else {
  526.             double faltaComprar = 0;
  527.             for (int i = 0; i < nItens; i++) {
  528.                 if (!feito[i]) {
  529.                     faltaComprar += preco[i] * quanto[i];
  530.                 }
  531.             }
  532.             System.out.printf("Falta comprar o total de: %.2f€\n", faltaComprar);
  533.         }
  534.     }
  535.     static void precoMedio(int nItens, double quanto[], double preco[]) {
  536.         double precoMedio = 0;
  537.         double quantidadeTotal = 0;
  538.         if (nItens == 0) {
  539.             System.out.println("A lista está vazia.");
  540.         } else {
  541.             for (int i = 0; i < nItens; i++) {
  542.                 precoMedio += preco[i] * quanto[i];
  543.                 quantidadeTotal += quanto[i];
  544.             }
  545.             System.out.printf("Preço médio por item: %.2f€\n", precoMedio / quantidadeTotal);
  546.         }
  547.     }
  548.     /*//////////////////////////////////////////////////
  549.     //////////////////UTILIDADES//////////////////////*/
  550.     static void utilidades(int nItens, String nome[], double quanto[], double preco[], boolean feito[]) {
  551.         char utilidades;
  552.         do {
  553.             System.out.println("(L)istar itens.");
  554.             System.out.println("Co(p)iar itens da posição m à n");
  555.             System.out.println("(C)ortar itens da posição m à n.");
  556.             System.out.println("(I)nserir na posição n a partir da memória.");
  557.             System.out.println("(S)ubstituir na posição n a partir da memória.");
  558.             System.out.println("(E)ditar item.");
  559.             System.out.println("(V)oltar.");
  560.             utilidades = lerChar();
  561.             switch (utilidades) {
  562.             case 'l':
  563.             case 'L':
  564.                 listarItems(nItens, nome, quanto, preco, feito);
  565.                 break;
  566.             case 'p':
  567.             case 'P':
  568.                 copiarMN();
  569.                 break;
  570.             case 'C':
  571.             case 'c':
  572.                 cortarMN();
  573.                 break;
  574.             case 'I':
  575.             case 'i':
  576.                 inserirPosicaoNMemoria();
  577.                 break;
  578.             case 'S':
  579.             case 's':
  580.                 substituirPosicaoNMemoria();
  581.                 break;
  582.             case 'E':
  583.             case 'e':
  584.                 editarItem();
  585.                 break;
  586.             case 'V':
  587.             case 'v':
  588.                 System.out.println("A voltar atrás no menu...");
  589.                 break;
  590.             default:
  591.                 System.out.println("Escolha uma opção válida.");
  592.                 break;
  593.             }
  594.         } while (utilidades != 'v' && utilidades != 'V');
  595.  
  596.     }
  597.     static int copiarMN(String nome[], double quanto[], double preco[], boolean feito[], String nomeCopia[], double quantoCopia[], double precoCopia[], boolean feitoCopia[]) {
  598.         System.out.println("Insira as posições a copia");
  599.         int posicao1 = lerInt();
  600.         int posicao2 = lerInt();
  601.  
  602.         int maior = posicao1 > posicao2? posicao1:posicao2;
  603.         int menor = posicao1 < posicao2? posicao1:posicao2;
  604.         int mAn = maior - menor;
  605.         for (int i = 0;i<mAn;i++) {
  606.             nomeCopia[i] = nome[menor+i];
  607.             quantoCopia[i] = quanto[menor+i];
  608.             precoCopia[i] = preco[menor+i];
  609.             feitoCopia[i] = feito[menor+i];
  610.         }
  611.         return mAn;
  612.     }
  613.     static void cortarMN() {
  614.         System.out.println("funcionou C");
  615.     }
  616.     static void inserirPosicaoNMemoria(int mAn) {
  617.         System.out.println("Em que posição quer inserir?");
  618.         int posicaoN = lerInt();
  619.     }
  620.     static void substituirPosicaoNMemoria() {
  621.         System.out.println("Funcionou s");
  622.     }
  623.     static void editarItem() {
  624.         System.out.println("Funcionou E");
  625.     }
  626.  
  627.     static char lerChar() {
  628.         Scanner sc = new Scanner(System.in);
  629.         char ch;
  630.         ch = sc.next().charAt(0);
  631.         sc.nextLine();
  632.         return ch;
  633.     }
  634.  
  635.     static int lerInt() {
  636.         Scanner sc = new Scanner(System.in);
  637.         int inteiro;
  638.  
  639.         while(!sc.hasNextInt()) {
  640.             System.out.println("Insira um número inteiro");
  641.             sc.nextLine();
  642.         }
  643.  
  644.         inteiro = sc.nextInt();
  645.         sc.nextLine();
  646.         return inteiro;
  647.     }
  648.     static double lerDouble() {
  649.         Scanner sc = new Scanner(System.in);
  650.         double nReal;
  651.  
  652.         while(!sc.hasNextInt()) {
  653.             System.out.println("Insira o preço");
  654.             sc.nextLine();
  655.         }
  656.  
  657.         nReal= sc.nextDouble();
  658.         sc.nextLine();
  659.         return nReal;
  660.     }
  661.     static String lerString() {
  662.         Scanner sc = new Scanner(System.in);
  663.         String nome ;
  664.  
  665.         nome= sc.nextLine();
  666.         return nome;
  667.     }
  668. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!