Schamppu

Lentävät lautaset

May 8th, 2019
776
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 12.38 KB | None | 0 0
  1. package lentävät.lautaset;
  2.  
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.util.ArrayList;
  6. import java.util.Collections;
  7. import java.util.Comparator;
  8. import java.util.HashMap;
  9. import java.util.LinkedHashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import static java.util.Map.Entry.comparingByValue;
  13. import java.util.NoSuchElementException;
  14. import java.util.Scanner;
  15. import java.util.TreeMap;
  16. import java.util.function.Function;
  17. import java.util.logging.Level;
  18. import java.util.logging.Logger;
  19. import java.util.stream.*;
  20. import static java.util.stream.Collectors.groupingBy;
  21. import static java.util.stream.Collectors.summingInt;
  22. import static java.util.stream.Collectors.toMap;
  23.  
  24. public class LentävätLautaset {
  25.  
  26.  
  27.     public static void main(String[] args) {
  28.        
  29.         Scanner lukija = new Scanner(System.in);
  30.         System.out.print("tiedosto:");
  31.         String tiedosto = lukija.nextLine();
  32.        
  33.         List<String> paivamaara = new ArrayList<>();
  34.         List<String> paikka = new ArrayList<>();
  35.         List<String> osavaltio = new ArrayList<>();
  36.         List<String> maa = new ArrayList<>();
  37.         List<String> muoto = new ArrayList<>();
  38.         List<Double> kesto = new ArrayList<>();
  39.         List<Double> pituusaste = new ArrayList<>();
  40.         List<Double> leveysaste = new ArrayList<>();
  41.         List<String> kuvaus = new ArrayList<>();
  42.        
  43.         try {
  44.             lukija = new Scanner(new File(tiedosto));
  45.         } catch (FileNotFoundException ex) {
  46.             System.out.println("tiedostoa ei voi avata");
  47.         }
  48.        
  49.         while(lukija.hasNext()) {
  50.             String rivi = lukija.nextLine();
  51.             String[] palat = rivi.split(";");
  52.            
  53.             paivamaara.add(palat[0]);
  54.             paikka.add(palat[1]);
  55.             osavaltio.add(palat[2]);
  56.             maa.add(palat[3]);
  57.             muoto.add(palat[4]);
  58.             kesto.add(Double.valueOf(palat[5]));
  59.             pituusaste.add(Double.valueOf(palat[6]));
  60.             leveysaste.add(Double.valueOf(palat[7]));
  61.             kuvaus.add(palat[8]);
  62.            
  63.             //System.out.println(lukija.nextLine());
  64.         }
  65.        
  66.         // Tulostetaan tulokset
  67.         havaintojenMaara(paivamaara);
  68.         lyhyinHavainto(kesto);
  69.         pisinHavainto(kesto);
  70.         keskimaarainenHavainto(kesto);
  71.         System.out.println("");
  72.         havaintojenMuodot(muoto);
  73.         System.out.println("");
  74.         havaintojenVuodet(paivamaara);
  75.         System.out.println("");
  76.         havaintojenTunnit(paivamaara);
  77.         System.out.println("");
  78.         havaintojenKestotjaMuodot(kesto,muoto);
  79.         System.out.println("");
  80.         yleisimmatSanat(kuvaus);
  81.        
  82.     }
  83.    
  84.     public static void havaintojenMaara(List lista) {
  85.         // Tulostaa havaintojen lkm.
  86.         System.out.println("Havaintoja: "+lista.size());
  87.        
  88.     }
  89.    
  90.     public static void lyhyinHavainto(List lista) {
  91.         // Tulostaa lyhyimmän havainnon
  92.        
  93.         double min = lista.stream()
  94.                 .mapToDouble(v -> (Double) v)
  95.                 .min().orElseThrow(NoSuchElementException::new);
  96.        
  97.         System.out.println("Lyhyimmän havainnon kesto sekunteina: "+min);
  98.        
  99.     }
  100.    
  101.     public static void pisinHavainto(List lista) {
  102.         // Tulostaa lyhyimmän havainnon
  103.        
  104.         double max = lista.stream()
  105.                 .mapToDouble(v -> (Double) v)
  106.                 .max().orElseThrow(NoSuchElementException::new);
  107.        
  108.         System.out.println("Pisimmän havainnon kesto sekunteina: "+max);
  109.        
  110.     }
  111.    
  112.     public static void keskimaarainenHavainto(List lista) {
  113.         // Tulostaa lyhyimmän havainnon
  114.        
  115.         double average = lista.stream()
  116.                 .mapToDouble(v -> (Double) v)
  117.                 .average().orElseThrow(NoSuchElementException::new);
  118.        
  119.         System.out.println("Pisimmän havainnon kesto sekunteina: "+average);
  120.        
  121.     }
  122.  
  123.     public static void havaintojenMuodot(List lista) {
  124.         // Tulostaa lyhyimmän havainnon
  125.        
  126.         System.out.println("Esineiden muodot");
  127.      
  128.         HashMap<String, Integer> muodot = new HashMap<>();
  129.        
  130.         int eniten = 0;
  131.         String enit = "";
  132.        
  133.         for (String havainto: (ArrayList<String>) lista) {
  134.             if (muodot.containsKey(havainto) == false) {
  135.                 muodot.put(havainto, 1);
  136.                 if (eniten == 0) {
  137.                     enit = "Eniten havaintoja: "+havainto+", 1 kerran";
  138.                     eniten = 1;
  139.                 }
  140.                
  141.             } else {
  142.                 muodot.replace(havainto, muodot.get(havainto)+1);
  143.                 if (eniten < muodot.get(havainto)) {
  144.                     eniten = muodot.get(havainto);
  145.                     enit = "Eniten havaintoja: "+havainto+", "+muodot.get(havainto)+" kertaa";
  146.                 }
  147.             }
  148.         }
  149.        
  150.         List<String> havainnot = new ArrayList<>();
  151.        
  152.         for (String havainto: muodot.keySet()) {
  153.             havainnot.add(havainto+", havaintoja: "+muodot.get(havainto));
  154.         }
  155.        
  156.         //havainnot.sort(String::compareToIgnoreCase);
  157.        
  158.         havainnot.stream()
  159.                 .map(havainto -> (String) havainto)
  160.                 .sorted()
  161.                 .forEach(havainto -> System.out.println("    "+havainto));
  162.        
  163.         System.out.println(enit);
  164.        
  165.        
  166.     }
  167.    
  168.     public static void havaintojenVuodet(List lista) {
  169.         // Tulostaa lyhyimmän havainnon
  170.        
  171.         System.out.println("Havainnot vuosittain");
  172.      
  173.         HashMap<Integer, Integer> muodot = new HashMap<>();
  174.        
  175.        
  176.         for (String havainto: (ArrayList<String>) lista) {
  177.            
  178.             String[] palat = havainto.split("/");
  179.             String[] vuosiAika = palat[2].split(" ");
  180.             int vuosi = Integer.valueOf(vuosiAika[0]);
  181.            
  182.            
  183.             if (muodot.containsKey(vuosi) == false) {
  184.                 muodot.put(vuosi, 1);
  185.                
  186.             } else {
  187.                 muodot.replace(vuosi, muodot.get(vuosi)+1);
  188.             }
  189.         }
  190.        
  191.         List<String> havainnot = new ArrayList<>();
  192.        
  193.         for (Integer havainto: muodot.keySet()) {
  194.             havainnot.add(havainto+", havaintoja: "+muodot.get(havainto));
  195.         }
  196.        
  197.         //havainnot.sort(String::compareToIgnoreCase);
  198.        
  199.         havainnot.stream()
  200.                 .map(havainto -> (String) havainto)
  201.                 .sorted()
  202.                 .forEach(havainto -> System.out.println("    "+havainto));
  203.        
  204.        
  205.     }
  206.    
  207.     public static void havaintojenTunnit(List lista) {
  208.        
  209.         System.out.println("Havainnot tunneittain");
  210.         List<String> ajat = new ArrayList<>();
  211.         int yht = 0;
  212.        
  213.         for (String havainto: (ArrayList<String>) lista) {
  214.            
  215.             String[] palat = havainto.split("/");
  216.             String[] kellonAika = palat[2].split(" ");
  217.             String[] aika = kellonAika[1].split(":");
  218.             String tunti = aika[0];
  219.             ajat.add(tunti);
  220.            
  221.             yht ++;
  222.            
  223.         }
  224.        
  225. // Kerätään mappiin collect listassa olevat sanat ja lasketaan niiden esiintymismäärä
  226. Map<String, Integer> collect =
  227.  (Map<String, Integer>) ajat.stream().collect(groupingBy(Function.identity(), summingInt(e -> 1)));
  228.  
  229. // Järjestetään mappi käyttämällä treeMappia aakkosjärjestykseen
  230. Map<String, Integer> treeMap = new TreeMap<String, Integer>(collect);
  231.        
  232.         for(String aika: treeMap.keySet()) {
  233.            
  234.             double prosentti = 1.0 * Integer.valueOf(collect.get(aika)) / yht;
  235.             prosentti = prosentti*100;
  236.            
  237.             System.out.println("    "+Integer.valueOf(aika)+"-"+(Integer.valueOf(aika)+1)+", havaintoja "+collect.get(aika)+", "+prosentti+"%");
  238.            
  239.         }
  240.        
  241.        
  242.        
  243.        
  244.     }
  245.    
  246.     public static void havaintojenKestotjaMuodot(List kesto, List muoto) {
  247.        
  248.         System.out.println("Muodot havainnon keston mukaan ryhmiteltynä");
  249.        
  250.         int lyhyt = 0;
  251.         int keski = 0;
  252.         int pitka = 0;
  253.        
  254.         for (Double aika: (ArrayList<Double>) kesto) {
  255.             if (aika <= 60.0) {
  256.                 lyhyt ++;
  257.             } else if (aika <= 1200.0) {
  258.                 keski ++;
  259.             } else if (aika <= 3600.0) {
  260.                 pitka ++;
  261.             }
  262.            
  263.         }
  264.        
  265.         System.out.println("lyhyt: 0-60.0, havaintoja "+lyhyt);
  266.         System.out.println("keskipitkä: 60.0-1200.0, havaintoja "+keski);
  267.         System.out.println("pitkä: 1200.0-3600.0.0, havaintoja "+pitka);
  268.        
  269.         System.out.println("");
  270.             System.out.format("%-15s%-15s%-15s%-15s\n", new String[] {"muoto","lyhyt","keskipitkä","pitkä"});
  271.        
  272.        
  273.         HashMap<String, ArrayList<Double>> muodot = new HashMap<>();
  274.        
  275.         for (int i = 0; i < kesto.size(); i++) {
  276.            
  277.             double kestoVal = (Double) kesto.get(i);
  278.             String muotoTx = (String) muoto.get(i);
  279.            
  280.             if (muodot.containsKey(muotoTx) == false) {
  281.                 ArrayList<Double> uusi = new ArrayList<>();
  282.                 uusi.add(kestoVal);
  283.                 muodot.put(muotoTx, uusi);
  284.                
  285.             } else {
  286.                 muodot.get(muotoTx).add(kestoVal);
  287.             }
  288.         }
  289.        
  290.         Map<String, ArrayList<Double>> treeMap = new TreeMap<String, ArrayList<Double>>(muodot);
  291.        
  292.         for (String shape: treeMap.keySet()) {
  293.            
  294.             ArrayList<Double> kestolista = treeMap.get(shape);
  295.             lyhyt = 0;
  296.             keski = 0;
  297.             pitka = 0;
  298.             for (Double aika: (ArrayList<Double>) kestolista) {
  299.                 if (aika <= 60.0) {
  300.                     lyhyt ++;
  301.                 } else if (aika <= 1200.0) {
  302.                     keski ++;
  303.                 } else if (aika <= 3600.0) {
  304.                     pitka ++;
  305.                 }
  306.  
  307.             }
  308.            
  309.             String[] rivi = {shape,Integer.toString(lyhyt),Integer.toString(keski),Integer.toString(pitka)};
  310.            
  311.             System.out.format("%-15s%-15s%-15s%-15s\n", rivi);
  312.            
  313.            
  314.            
  315.            
  316.            
  317.         }
  318.        
  319.        
  320.        
  321.        
  322.     }
  323.    
  324.     public static void yleisimmatSanat(List kuvaus) {
  325.  
  326.         // Tulostetaan alku
  327.         System.out.println("Yleisimmät sanat esiintymiskertojen mukaan järjestettynä");
  328.  
  329.         // Luodaan lista
  330.         ArrayList<String> sanat = new ArrayList<>();
  331.  
  332.         // Pilkotaan teksti sanoiksi ja siivotaan siitä erikoismerkit
  333.         for (String teksti: (ArrayList<String>) kuvaus) {
  334.             String siivottuteksti = teksti.replaceAll("[^a-zA-Z ]","");
  335.             String palat[] = siivottuteksti.split(" ");
  336.             for (int i = 0; i < palat.length; i++) {
  337.                 if (!palat[i].contains(" ") && palat[i].length() > 0) {
  338.                     sanat.add(palat[i].toLowerCase());
  339.                 }
  340.             }
  341.  
  342.  
  343.         }
  344.  
  345.         // Lasketaan listasta jossa sanoja yleisimmät sanat HashMappiin
  346.         Map<String, Long> yleisimmat =
  347.             (Map<String, Long>) sanat.stream().collect(Collectors.groupingBy(w -> w, Collectors.counting()));
  348.  
  349.         // Sortataan mappi sanojen yleisyyden mukaan (laskeva järjestys)
  350.         Map<String, Long> jarjestetty = yleisimmat
  351.             .entrySet()
  352.             .stream()
  353.             .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
  354.             .collect(toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2,LinkedHashMap::new));
  355.  
  356.  
  357.         // Sortataan mappi sanojen yleisyyden mukaan (nouseva järjestys)
  358.         Map<String, Long> jarjestetty = yleisimmat
  359.             .entrySet()
  360.             .stream()
  361.             .sorted(comparingByValue())
  362.             .collect(toMap(e -> e.getKey(), e -> e.getValue(), (e1, e2) -> e2,LinkedHashMap::new));
  363.  
  364.  
  365.         // Tulostetaan mappi
  366.         int monesko = 0;
  367.         for (String sana: jarjestetty.keySet()) {
  368.             if (monesko < 15) {
  369.                 System.out.println(sana+", "+jarjestetty.get(sana));
  370.             }
  371.             monesko ++;
  372.         }
  373.  
  374.  
  375.     }
  376.    
  377.    
  378.    
  379. }
Advertisement
Add Comment
Please, Sign In to add comment