SHARE
TWEET

Untitled

a guest Dec 8th, 2019 74 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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
 
Top