Please help

Question about the task

Resolved

Sorry if my code is a little messy, hope the notes make it easier to read

Read file names from the console until the word "exit" is entered.
Pass the file name to the ReadThread thread.
The ReadThread thread should find the byte that occurs most frequently in the file, and add it to resultMap,
where the String parameter is the file name and the Integer parameter is the relevant byte.
Close the streams.

Requirements:

The program must read file names from the console until the word "exit" is entered.
For each file, create and start a ReadThread thread.
After each thread is start, ReadThread should create its own file input stream.
Then each thread must find the most frequently occurring byte in its file and add it to resultMap.
The file input stream in each thread must be closed.

package com.codegym.task.task18.task1823; import java.io.*; import java.lang.reflect.Array; import java.util.*; /* Threads and bytes */ public class Solution { public static Map<String, Integer> resultMap = new HashMap<String, Integer>(); public static void main(String[] args) throws IOException, InterruptedException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); while (true){ String fileName = reader.readLine(); if (fileName.equals("exit")) break; ReadThread readThread = new ReadThread(fileName); readThread.start(); readThread.join(); resultMap.put(fileName, readThread.getFrequentByteAsInteger()); } } public static class ReadThread extends Thread { private String fileName; private Integer frequentByteAsInteger; public ReadThread(String fileName) throws IOException { // Implement constructor body this.fileName = fileName; } // Implement file reading here @Override public void run() { //create InputStream for file and read to buffer FileInputStream fileInputStream = null; try { fileInputStream = new FileInputStream(this.fileName); } catch (FileNotFoundException e) { e.printStackTrace(); } byte[] buffer = new byte[0]; try { buffer = new byte[fileInputStream.available()]; } catch (IOException e) { e.printStackTrace(); } while (true){ try { if (!(fileInputStream.available()>0)) break; } catch (IOException e) { e.printStackTrace(); } try { fileInputStream.read(buffer); } catch (IOException e) { e.printStackTrace(); } } //copy to Byte Array Byte[] bufferByte = new Byte[buffer.length]; int i = 0; for (byte b : buffer) bufferByte[i++] = b; //copy to ArrayList and find most frequent element ArrayList<Byte> bytes = (ArrayList<Byte>) Arrays.asList(bufferByte); int frequency =0; Byte frequentByte =0; for (int x = 0; x<bytes.size();x++) { if (Collections.frequency(bytes, bytes.get(x)) > frequency) { frequency = Collections.frequency(bytes, bytes.get(x)); frequentByte = bytes.get(x); } } this.frequentByteAsInteger = Integer.valueOf(frequentByte); try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } public Integer getFrequentByteAsInteger(){ return this.frequentByteAsInteger; } } }

Comments (1)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

16 January 2020, 14:54

solution

Try changing line 76 to: List<Byte> bytes = Arrays.asList(temp); Some tips: try-catch blocks should contain everything that is going to be used for a class that needs the structure. Take for example lines 43-66 and lines 89-93, there are 5 separate try-catch blocks that are all related to FileInputStream. If you were to remove all of those lines, you could replace them with just this: byte[] buffer = null;

try {
   FileInputStream fileInputStream = new FileInputStream(this.fileName);
   buffer = new byte[fileInputStream.available()];
   fileInputStream.read(buffer);
   fileInputStream.close();
}catch (Exception e){
   e.printStackTrace();
 }

This brings me to the next point: when using streams, make sure that you close them when finished using them. The reason to close them is to free up resources because streams are greedy in using them, if you close them after all your algorithms then there is no reason to close them at all (they close automatically when the program exits). Using this tip, the main method can be changed to this so that the reader is closed after using it:

public static void main(String[] args) throws IOException, InterruptedException {
   BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
   ArrayList<String> names = new ArrayList<>();
   {
      String fileName;
      while (!(fileName = reader.readLine()).equals("exit"))
         names.add(fileName);
   }
   // added a block here so that 'filename' only exists in block
   reader.close();

   for (String fileName : names) { // and i can re-use 'filename' here
      ReadThread readThread = new ReadThread(fileName);
      readThread.start();
      readThread.join();
      resultMap.put(fileName, readThread.getFrequentByteAsInteger());
   }
}