diff --git a/Sorting/AlgorithmTester.java b/Sorting/AlgorithmTester.java
index 07e4102..07b6e6f 100644
--- a/Sorting/AlgorithmTester.java
+++ b/Sorting/AlgorithmTester.java
@@ -138,33 +138,33 @@ public class AlgorithmTester{
         boolean quickTWP=sortingAlgoChoices[5];
         boolean merge=sortingAlgoChoices[6];
         ArrayList<SortResult> results = new ArrayList<SortResult>();
-        
+        RandomNumberFileReader reader = new RandomNumberFileReader(filename);
         if(bubble){
-            BubbleSorter bubSorter = new BubbleSorter(filename);
+            BubbleSorter bubSorter = new BubbleSorter(reader);
             results.add(bubSorter.measuredSort());
         }
         if(selection){
-            SelectionSorter selSorter = new SelectionSorter(filename);
+            SelectionSorter selSorter = new SelectionSorter(reader);
             results.add(selSorter.measuredSort());
         }
         if(insertion){
-            InsertionSorter inSorter = new InsertionSorter(filename);
+            InsertionSorter inSorter = new InsertionSorter(reader);
             results.add(inSorter.measuredSort());
         }
         if(counting){
-            CountingSorter countSorter = new CountingSorter(filename);
+            CountingSorter countSorter = new CountingSorter(reader);
             results.add(countSorter.measuredSort());
         }
         if(quick){
-            QuickSorter qSorter = new QuickSorter(filename);
+            QuickSorter qSorter = new QuickSorter(reader);
             results.add(qSorter.measuredSort());
         }
         if(quickTWP){
-            QuickSorterThreeWay qTWPSorter = new QuickSorterThreeWay(filename);
+            QuickSorterThreeWay qTWPSorter = new QuickSorterThreeWay(reader);
             results.add(qTWPSorter.measuredSort());
         }
         if(merge){
-            MergeSorter mSorter = new MergeSorter(filename);
+            MergeSorter mSorter = new MergeSorter(reader);
             results.add(mSorter.measuredSort());
         }
         for(SortResult e: results){
@@ -174,7 +174,7 @@ public class AlgorithmTester{
                 }
                 System.out.print("\n");
             }
-            System.out.println("\n"+e.getSortType()+" of "+e.getSortCount()+" numbers took:");
+            System.out.println("\n"+e.getSortType()+" of "+e.getSortCount()+" numbers with range "+e.getMin()+" to "+e.getMax()+" took:");
             System.out.println(e.getComparisonsUsed()+" comparisons");
             System.out.println(e.getWritesUsed()+" write operations");
             System.out.println(e.getTimeUsed()+" milliseconds");
diff --git a/Sorting/BubbleSorter.java b/Sorting/BubbleSorter.java
index edbf0a1..e52d162 100644
--- a/Sorting/BubbleSorter.java
+++ b/Sorting/BubbleSorter.java
@@ -3,8 +3,8 @@ package Sorting;
 public class BubbleSorter extends Sorter{
     //a class to sort arrays of numbers using bubble sort
 
-    public BubbleSorter(String filename){
-        super("bubble sort", filename);
+    public BubbleSorter(RandomNumberFileReader reader){
+        super("bubble sort", reader);
     }
 
     void sort(){
diff --git a/Sorting/CountingSorter.java b/Sorting/CountingSorter.java
index c5e2a79..2d2a31b 100644
--- a/Sorting/CountingSorter.java
+++ b/Sorting/CountingSorter.java
@@ -4,8 +4,8 @@ import java.util.Arrays;
 
 public class CountingSorter extends Sorter{
 
-    public CountingSorter(String filename){
-        super("counting sort", filename);
+    public CountingSorter(RandomNumberFileReader reader){
+        super("counting sort", reader);
     }
 
     void sort(){
diff --git a/Sorting/InsertionSorter.java b/Sorting/InsertionSorter.java
index aa781c3..1d61453 100644
--- a/Sorting/InsertionSorter.java
+++ b/Sorting/InsertionSorter.java
@@ -5,8 +5,8 @@ package Sorting;
 
 public class InsertionSorter extends Sorter{
     
-    public InsertionSorter(String filename){
-        super("insertion sort", filename);
+    public InsertionSorter(RandomNumberFileReader reader){
+        super("insertion sort", reader);
     }
 
     void sort(){
diff --git a/Sorting/MergeSorter.java b/Sorting/MergeSorter.java
index 4dbb5f7..045c993 100644
--- a/Sorting/MergeSorter.java
+++ b/Sorting/MergeSorter.java
@@ -2,8 +2,8 @@ package Sorting;
 
 public class MergeSorter extends Sorter{
     
-    public MergeSorter(String filename){
-        super("merge sort",filename);
+    public MergeSorter(RandomNumberFileReader reader){
+        super("merge sort",reader);
     }
 
     void sort(){
@@ -28,41 +28,34 @@ public class MergeSorter extends Sorter{
     void merge(int leftIndex, int middleIndex, int rightIndex){
         int sizeLeft=middleIndex-leftIndex+1;//add 1 to include both endpoints
         int sizeRight=rightIndex-middleIndex;//both endpoints already included, as middleIndex is part of left array
-        int[] left=new int[sizeLeft];
-        int[] right=new int[sizeRight];
+        Integer[] left=new Integer[sizeLeft];
+        Integer[] right=new Integer[sizeRight];
         for(int i=0;i<sizeLeft;i++){
-            left[i]=numbers[leftIndex+i];
-            writesUsed++;
+            writeToArray(left, i, numbers[leftIndex+i]);
         }
         for(int i=0;i<sizeRight;i++){
-            right[i]=numbers[middleIndex+1+i];
-            writesUsed++;
+            writeToArray(right, i, numbers[middleIndex+1+i]);
         }
         int i=0, j=0;//indices of left and right array
         int k=leftIndex;//index of numbers array
         while(i<sizeLeft&&j<sizeRight){
             if(compare(left[i],right[j])<1){
-                numbers[k]=left[i];
-                writesUsed++;
-
+                writeToArray(numbers, k, left[i]);
                 i++;
             }
             else{
-                numbers[k]=right[j];
-                writesUsed++;
+                writeToArray(numbers, k, right[j]);
                 j++;
             }
             k++;
         }
         while(i<sizeLeft){
-            numbers[k]=left[i];
-            writesUsed++;
+            writeToArray(numbers, k, left[i]);
             i++;
             k++;
         }
         while(j<sizeRight){
-            numbers[k]=right[j];
-            writesUsed++;
+            writeToArray(numbers, k, right[j]);
             j++;
             k++;
         }
diff --git a/Sorting/QuickSorter.java b/Sorting/QuickSorter.java
index ced6b42..8d31a66 100644
--- a/Sorting/QuickSorter.java
+++ b/Sorting/QuickSorter.java
@@ -2,12 +2,12 @@ package Sorting;
 
 public class QuickSorter extends Sorter{
     
-    public QuickSorter(String filename){
-        super("quick sort", filename);
+    public QuickSorter(RandomNumberFileReader reader){
+        super("quick sort", reader);
     }
 
-    public QuickSorter(String qsortVariant, String filename){
-        super(qsortVariant, filename);
+    public QuickSorter(String qsortVariant, RandomNumberFileReader reader){
+        super(qsortVariant, reader);
     }
 
     void sort(){
diff --git a/Sorting/QuickSorterThreeWay.java b/Sorting/QuickSorterThreeWay.java
index 6d7fa1c..a0069f9 100644
--- a/Sorting/QuickSorterThreeWay.java
+++ b/Sorting/QuickSorterThreeWay.java
@@ -6,8 +6,8 @@ package Sorting;
 
 public class QuickSorterThreeWay extends QuickSorter{
 
-    public QuickSorterThreeWay(String filename){
-        super("quick sort (3-way partition)", filename);
+    public QuickSorterThreeWay(RandomNumberFileReader reader){
+        super("quick sort (3-way partition)", reader);
     }
     /*
     void sort(){
diff --git a/Sorting/RandomNumberFileMaker.java b/Sorting/RandomNumberFileMaker.java
index ab13f64..d79c143 100644
--- a/Sorting/RandomNumberFileMaker.java
+++ b/Sorting/RandomNumberFileMaker.java
@@ -1,9 +1,14 @@
 package Sorting;
 
-import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.io.BufferedWriter;
+import java.util.Random;
 import java.io.IOException;
-import java.io.FileWriter;
-import java.lang.Math;
+//import java.io.File;
+//import java.io.FileWriter;
+//import java.lang.Math;
 
 /**
  * This class will allow the user to make a file of random integers.
@@ -24,6 +29,27 @@ public class RandomNumberFileMaker {
        max=M+1;
     }
 
+    //new version using streams and a try-with-resouces block
+    public void writeFile(){
+        try(BufferedWriter writer = Files.newBufferedWriter(Path.of(filename), StandardOpenOption.CREATE_NEW)){
+            Random random = new Random();
+            random.ints(count, min, max+1)
+                .forEach(num -> 
+                    {
+                        try{
+                            writer.write(Integer.toString(num)); writer.newLine();
+                        }catch (IOException ex){
+                            System.out.println("An error occurred.");
+                        }  
+                    });
+        }catch (IOException ex){
+            System.out.println("Could not make new file named "+filename);
+        }
+    }
+
+
+    //previous version retained for reference.
+    /*
     public void writeFile(){
         try{
             File randomNumbers = new File(filename);
@@ -42,6 +68,6 @@ public class RandomNumberFileMaker {
         }catch (IOException ex){
             System.err.println(ex);
         }
-    }
+    }*/
 
 }
\ No newline at end of file
diff --git a/Sorting/RandomNumberFileReader.java b/Sorting/RandomNumberFileReader.java
index cf33277..5040bc7 100644
--- a/Sorting/RandomNumberFileReader.java
+++ b/Sorting/RandomNumberFileReader.java
@@ -12,6 +12,17 @@ class RandomNumberFileReader{
 	private ArrayList<Integer> numbers = new ArrayList<Integer>();
 
 	public RandomNumberFileReader(String file){
+		//reads text from file of integers, one on each line
+		//uses try-with-resources loop to automatically close BufferedReader
+		//uses Stream operations instead of while loop
+		try(BufferedReader reader = Files.newBufferedReader(Path.of(file));){
+			reader.lines().mapToInt(Integer::parseInt).forEach(num -> numbers.add(num));
+		}catch (IOException ex){
+			System.err.println(ex);
+		}
+		
+		/*
+		//previous version retained for reference
 		//Reads in from a text file of integers, one on each line
 		try{
 			BufferedReader reader = Files.newBufferedReader(Path.of(file));
@@ -23,8 +34,9 @@ class RandomNumberFileReader{
 		} catch (IOException ex){
 			System.err.println(ex);
 		}
+		*/
 	}
-	
+
 	public ArrayList<Integer> getNumbers(){
 		return numbers;
 	}
diff --git a/Sorting/SelectionSorter.java b/Sorting/SelectionSorter.java
index 1add6fa..d545fdd 100644
--- a/Sorting/SelectionSorter.java
+++ b/Sorting/SelectionSorter.java
@@ -2,8 +2,8 @@ package Sorting;
 
 public class SelectionSorter extends Sorter {
     //a class to sort an array of numbers using selection sort
-    public SelectionSorter(String filename){
-        super("selection sort", filename);
+    public SelectionSorter(RandomNumberFileReader reader){
+        super("selection sort", reader);
     }
 
     void sort(){
diff --git a/Sorting/SortResult.java b/Sorting/SortResult.java
index 1dc09a1..e339c7b 100644
--- a/Sorting/SortResult.java
+++ b/Sorting/SortResult.java
@@ -75,4 +75,14 @@ public class SortResult {
         return nf.format(sortedArray.length);
     }
 
+    public String getMin(){
+        NumberFormat nf = NumberFormat.getInstance(Locale.US);
+        return nf.format(sortedArray[0]);
+    }
+
+    public String getMax(){
+        NumberFormat nf = NumberFormat.getInstance(Locale.US);
+        return nf.format(sortedArray[sortedArray.length-1]);
+    }
+
 }
\ No newline at end of file
diff --git a/Sorting/Sorter.java b/Sorting/Sorter.java
index bdb152d..dd0e9ab 100644
--- a/Sorting/Sorter.java
+++ b/Sorting/Sorter.java
@@ -15,9 +15,9 @@ abstract class Sorter {
     protected long comparisonsUsed = 0;
     protected long writesUsed=0;
 
-    public Sorter(String st, String filename){
+    public Sorter(String st, RandomNumberFileReader reader){
         sortType=st;
-        RandomNumberFileReader reader = new RandomNumberFileReader(filename);
+        //RandomNumberFileReader reader = new RandomNumberFileReader(filename);
         numbers = new Integer[reader.getNumbers().size()];
         reader.getNumbers().toArray(numbers);
     }