Advertisement
Hiitsu

Sortowanie Plikow na Watkach

Sep 16th, 2018
98
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 4.36 KB | None | 0 0
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.BlockingQueue;
  5.  
  6. public class Main {
  7.  
  8.     public static void main(String[] args) throws IOException, InterruptedException {
  9.         if
  10.                 (args.length ==0)
  11.         {
  12.             System.err.println("Nie podano scieżki ani ilości plików");
  13.             System.exit(0);
  14.         }
  15.         int ilosc_plikow;
  16.         System.out.println("args " + args[0]);
  17.         String sciezka = (args[0]);
  18.         ilosc_plikow = Integer.parseInt(args[1]);
  19.  
  20.         int pojemnosc = 4;
  21.         BlockingQueue<File> kolejka = new ArrayBlockingQueue<File>(pojemnosc);
  22.  
  23.         int liczba_wątków = 4;
  24.  
  25.  
  26.  
  27.         Sort[] watki = new Sort[liczba_wątków];
  28.         for (int i = 0; i < watki.length; i++) {
  29.             watki[i] = new Sort("Watek" +i, sciezka, kolejka);
  30.             watki[i].start();
  31.  
  32.         }
  33.  
  34.         Utworz_pliki Up = new Utworz_pliki(sciezka, ilosc_plikow);
  35.         File file = new File(sciezka);
  36.         if (file.isDirectory()) {
  37.             File[] files = file.listFiles();
  38.             for (File f : files) {
  39.                 System.out.println(f.getName());
  40.                 kolejka.put(f);
  41.                
  42.             }
  43.  
  44.         }
  45.          }}
  46.  
  47. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  48. import java.io.*;
  49. import java.util.ArrayList;
  50. import java.util.Scanner;
  51. import java.util.*;
  52. import java.util.concurrent.BlockingQueue;
  53.  
  54.  
  55. public class Sort extends Thread{
  56.     private BlockingQueue<File> kolejka;
  57.  
  58.     String sciezka;
  59.     public Sort(String _nazwa, String sciezka, BlockingQueue<File> _kolejka){
  60.         super(_nazwa);
  61.         this.sciezka = sciezka;
  62.         kolejka = _kolejka;
  63.  
  64.     }
  65.  
  66.     FileWriter zapis = null;
  67.  
  68.  
  69.     public void run(){
  70.         try{
  71.             while(true){
  72.                 File z_kolejki = kolejka.take();
  73.                 Scanner sc = null;
  74.                 try{
  75.                     sc = new Scanner(z_kolejki);
  76.  
  77.                 } catch (FileNotFoundException e) {
  78.                     e.printStackTrace();
  79.                 }
  80.                 ArrayList<String> lista=new ArrayList<String>();
  81.                 while(sc.hasNext())
  82.                 {
  83.                     lista.add(sc.next());
  84.                 }
  85.                 sc.close();
  86.  
  87.                 ArrayList<Integer> liczby = new ArrayList<Integer>();
  88.                 for(String number : lista)
  89.                 {
  90.                     liczby.add(Integer.parseInt(number));
  91.                 }
  92.  
  93.                 Collections.sort(liczby);
  94.  
  95.                 System.out.println(Thread.currentThread().getName()+ " obsluzyl" + " sortowanie: " + liczby.toString());
  96.                 try {
  97.                     zapis = new FileWriter(z_kolejki);
  98.                 } catch (IOException e) {
  99.                     e.printStackTrace();
  100.                 }
  101.  
  102.                 try {
  103.                     zapis.write(String.valueOf(liczby));
  104.                 } catch (IOException e) {
  105.                     e.printStackTrace();
  106.                 }
  107.                 try {
  108.                     zapis.close();
  109.                 } catch (IOException e) {
  110.                     e.printStackTrace();
  111.                 }
  112.             }
  113.  
  114.  
  115.         } catch (InterruptedException e) {e.printStackTrace();}
  116.  
  117.  
  118.  
  119. }}
  120.  
  121. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  122. import java.io.*;
  123. import java.util.Random;
  124.  
  125. public class Utworz_pliki {
  126. public String sciezka;
  127. public int ilosc_plikow;
  128. public Utworz_pliki(String sciezka,int ilosc_plikow) throws IOException {
  129. this.sciezka = sciezka;
  130. this.ilosc_plikow=ilosc_plikow;
  131.  
  132.  
  133.     PrintWriter writer;
  134.     Random los = new Random();
  135.     int wielkosc_plikow = 250;
  136.     int decrement = wielkosc_plikow/ilosc_plikow;
  137.  
  138.     for(int i = 1;i<=ilosc_plikow;i++){
  139.         writer = new PrintWriter(sciezka + "Dokument"+i+".txt");
  140.         for(int j=0;j<wielkosc_plikow;j++){
  141.         int n =los.nextInt(100)+1;
  142.         writer.println(n);
  143.  
  144.     }
  145.     writer.close();
  146.     wielkosc_plikow=wielkosc_plikow-decrement;
  147.  
  148.     }
  149.  
  150.     }
  151. }
  152.  
  153. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement