/*
 *   Intro to Programming CSE 1310
 * University of Texas at Arlington
 */

package code11apr19;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.Scanner;

/**
 *
 * @author jcmtiernan
 */
public class Code11Apr19 
{

    /**
     * @param args the command line arguments
     */
    final static int LAST = 0;
    final static int FIRST = 1;
    final static int SH = 2;
    ///int globalIndex = 0;  // 1310 global class variable
    final static int PUBYR = 0; // column indicates the content
    final static int MOVYR =  1;
    final static int AGE = 2;
    
    public static void main(String[] args) 
    {
        /*
            Multi-dimensional arrays

        */
        // This version handles errors in the input data file
        File nameAgeFile = new File("namesDatesErr21Mar.txt");
        Scanner nameDataFile = new Scanner(System.in);
        try
        {
            nameDataFile = new Scanner(nameAgeFile);
        }
        catch (FileNotFoundException fnfe)
        {
            System.out.println("No data file found");
        }

        // ### What happens if array is too small?
        // ### How can we handle this?
        
        final int MAXNUM = 50;  
        
        // format should be lastName, firstName ; SHName pubYr movieYr
        //String[] lastNm = new String[MAXNUM];
        //String[] firstNm = new String[MAXNUM];
        //String[] shNm = new String[MAXNUM];
        // use constant
        /*
        final int LAST = 0;
        final int FIRST = 1;
        final int SH = 2;
        */
        String[][] heroNm = new String [MAXNUM][3];  //  [ROW][COLUMN] Col [0] = last, col [1] = first, col [2] = shNm
        /*
        int[] pubYr = new int[MAXNUM];
        int[] movYr = new int[MAXNUM];
        int[] age = new int[MAXNUM];
        */
        /*
        final int PUBYR = 0; // column indicates the content
        final int MOVYR =  1;
        final int AGE = 2;
        */
        int[][] heroNums = new int [MAXNUM][3]; 
        
        
        
        
        
        // Initialize all string arrays to prevent crashing due to null pointer values
        for (int i=0; i<MAXNUM; i++)
        {
            heroNm[i][LAST] = "";
            heroNm[i][FIRST] = "";
            heroNm[i][SH] = "";
        }
        
        String oneLine = "";
        Scanner inLine;
        int index = 0;
        boolean valid = true;
        String number = "";
        boolean lnValid = true;
        int origCount = 1;
        
        while (nameDataFile.hasNextLine()) //  && (index < lastNm.length))
        {
            valid = true;
            lnValid = true;
            inLine = new Scanner(nameDataFile.nextLine());
            /*
                Read all inputs as Strings
                Use delimiters as needed to seperate values
                Convert Strings to numbers
                Store each data element into appropriate array
            */
            
            try
            {
                inLine.useDelimiter(", ");
                heroNm[index][LAST] = inLine.next();  //lastNm[index]
                heroNm[index][LAST] = removeBlanks(heroNm[index][LAST]);
                inLine.reset();
                if (heroNm[index][LAST].isEmpty())  // superhero must have one "real" name but can be first or last
                    lnValid = false;          // so use boolean to record if there is no last name
                
                inLine.next(); // read comma
                inLine.useDelimiter(" : "); 
                heroNm[index][FIRST] = inLine.next();
                //System.out.println("firstNm["+index+"] is "+firstNm[index]);
                heroNm[index][FIRST] = removeBlanks(heroNm[index][FIRST]); 
                inLine.reset();
                if (heroNm[index][FIRST].isEmpty() && !lnValid)  // if superhero has no real name, i.e. no first and no last name
                { 
                    valid = false;                         // this is an invalid line of data
                    System.out.println("::: "+origCount+". No valid first or last name");
                }
                    
                inLine.next(); // read colon
                inLine.useDelimiter("-*[+0-9]");   // works with neg numbers
                //inLine.useDelimiter("-?\\d");  // alternate way to catch pos and neg numbers
                heroNm[index][SH] = inLine.next();
                heroNm[index][SH] = removeBlanks(heroNm[index][SH]);
                if (heroNm[index][SH].isEmpty())  // superhero must have a superhero name
                {
                    valid = false; 
                    System.out.println("::: "+origCount+". No valid superhero name");
                }
                try
                {
                    int shTempInt = Integer.parseInt(heroNm[index][SH]);
                    valid = false;
                    System.out.println("::: "+origCount+". Superhero name is a number");
                }
                catch (NumberFormatException nfe)
                {   
                   // Correct behavior is for this try to fail and go to the catch
                }
                // use the line below (with the "*") when you are NOT using 
                // removeBlanks in order to see all the blanks around the 
                // name and how they change the name sort
                //shNm[index] = "*"+shNm[index]+"*";                 
                
            }
            catch (NoSuchElementException nsee)
            {
                System.out.println("::: "+origCount+". Insufficient name data available on current line");
                valid = false;
            }

            inLine.reset(); 
            // reading numbers as strings and parsing
            if (valid && inLine.hasNext())
            {
                try
                {
                    number = inLine.next();  
                    //System.out.println("number (pubYr) = "+number);
                    heroNums[index][PUBYR] = Integer.valueOf(number);  //Integer  assigned to int  
                    //System.out.println("pubYr["+index+"] is "+pubYr[index]);

                    number = inLine.next();  
                    //System.out.println("number (movYr) = "+number); 
                    heroNums[index][MOVYR] = Integer.parseInt(number);  // int
                    //System.out.println("movYr["+index+"] is "+movYr[index]);
                }
                catch (NumberFormatException nfe)
                {   
                    System.out.println("::: "+origCount+". Year data is invalid");
                    valid = false;
                }
                catch (NoSuchElementException nsee)
                {
                    System.out.println("::: "+origCount+". Insufficient numeric data available on current line");
                    valid = false;
                }
                if (valid && (heroNums[index][PUBYR] < 1837))
                {
                    System.out.println("::: "+origCount+". Publication year is invalid");
                    valid = false;
                }
                if (valid && ((heroNums[index][MOVYR] !=0) && (heroNums[index][MOVYR]  < 1888)))
                {
                    System.out.println("::: "+origCount+". Movie year is invalid");
                    valid = false;
                }                
            }
            if (!valid)
                index--;  // if the data isn't valid, ignore the current row of values and replace
                
                

            origCount++;
            index++;
            
            
        }  // end of while (nameDataFile.hasNextLine())
        
        System.out.println("Read "+origCount+" lines from the file");
        for (int k = 0; k < index; k++)
        {
            heroNums[k][AGE] = heroNums[k][MOVYR]  - heroNums[k][PUBYR];
            if (heroNums[k][MOVYR] == 0)
            {
                heroNums[k][AGE] = 2019 - heroNums[k][PUBYR];
            }
        }
        
        System.out.println("\nFile data with calculated age is:");
        //printTableFLS(lastNm, firstNm, shNm, pubYr, movYr, age, index); // method call with mult args
        //printTableFLS(heroNm, pubYr, movYr, age, index); // method call with mult args
        printTableFLS(heroNm, heroNums, index); 
        System.out.println("");
        

        /* 
            Sort all arrays together by age using bubble sort with multiple arguments1
            Print table to verify
        */  
        
        //int countSwaps = bubbleSortAllbyNumberSwap(heroNm, AGE, heroNums, index);
        int countSwaps = bubbleSortAllbyAnySwap(2, heroNm, AGE, heroNums, index);  // 2 indicates a numeric sort, AGE indicates sort by age       
        //System.out.println("After bubble sort, element count is "+index +" and the number of swaps was "+countSwaps);
        
        System.out.println("\nTable after sorting on age: ");
        
        boolean table = printTableFLS(heroNm, heroNums, index);  // method call with mult args
        //System.out.println("The table did "+ (table ? "" : "not ") +"print correctly.");
        System.out.println("The table had an "+(table?"even ":"odd ")+"number of superheros with no movies");
        System.out.println("");
        
        //bubbleSortAllbySHNameSwap(lastNm, firstNm, shNm, pubYr, movYr, age, index);
        //bubbleSortAllbyAnyNameSwap(shNm, firstNm, lastNm, pubYr, movYr, age, index);
        //bubbleSortAllbyAnyNameSwap(heroNm, SH, heroNums, index);
        bubbleSortAllbyAnySwap(1, heroNm, SH, heroNums, index); // 1 indicates a String sort, SH indicates sort by superhero name
        
        System.out.println("\nTable after shNm sorting using AnyName sort: ");
        printTableFLS(heroNm, heroNums, index);  // method call with mult args
        System.out.println(""); 
        
        //bubbleSortAllbyAnyNameSwap(heroNm, LAST, heroNums, index);
        bubbleSortAllbyAnySwap(1, heroNm, LAST, heroNums, index);
        
        System.out.println("\nTable after LastNm sorting using AnyName sort: ");
        printTableFLS(heroNm, heroNums, index);  // method call with mult args
        System.out.println("");        
 
        //bubbleSortAllbyNumberSwap(heroNm, PUBYR, heroNums, index);
        bubbleSortAllbyAnySwap(2, heroNm, PUBYR, heroNums, index);
        //System.out.println("After bubble sort, element count is "+index +" and the number of swaps was "+countSwaps);
        
        System.out.println("\nTable after sorting on publication year: ");
        
        printTableFLS(heroNm, heroNums, index);  // method call with mult args

        /*
        bubbleSortAllbyAnyNameSwap(lastNm, firstNm, shNm, pubYr, movYr, age, index);
        
        System.out.println("\nTable after lastNm sorting using AnyName sort: ");
        printTableFLS(heroNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("");   
        
        bubbleSortAllbyAnyNameSwap(firstNm, lastNm, shNm, movYr, pubYr, age, index);
        
        System.out.println("\nTable after firstNm sorting using AnyName sort: ");
        printTableFLS(heroNm, pubYr, movYr, age, index); // method call with mult args
        System.out.println("\n"); 
        */
        
        
        /*
        // ### add a value to a sorted array?
        int[] testAge = new int[MAXNUM];
        testAge = age.clone();  // make a copy of an array with .clone()
        
        System.out.println("\nTestAge:");
        for (int p=0; p < index; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]);
        
        bubbleSortAgeSwap( testAge, index);
        
        System.out.println("\nSorted testAge:");
        for (int p=0; p < index; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]); 
        
        System.out.println("\nInsert a new element of 32 into testAge");
        int testIndex = index;  // testIndex is number of valid elements in array
        testIndex = insertElement(testAge,testIndex,32);
        
        System.out.println("\nAdded element of 32 to testAge:");
        for (int p=0; p < testIndex; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]);  
        
        testIndex = insertElement(testAge,testIndex,88);
        
        System.out.println("\nAdded element of 88 to testAge:");
        for (int p=0; p < testIndex; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]); 

        testIndex = insertElement(testAge,testIndex,-1);
        
        System.out.println("\nAdded element of -1 to testAge:");
        for (int p=0; p < testIndex; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]);         

        // ### delete a value from a sorted array?

        testIndex = deleteElement(testAge,testIndex,40);
        
        System.out.println("\nRemoved element of 40 to testAge:");
        for (int p=0; p < testIndex; p++  )
            System.out.println("testAge["+p+"] = "+testAge[p]); 
        
        System.out.println("\nPrinting testAge "+testAge);
        
        ArrayList<Integer> testAgeAL = new ArrayList<>();
        if (testAgeAL.isEmpty())
            System.out.println("\ntestAgeAL has no values");
        
        for (int p=0; p < testIndex; p++  )
        {
            testAgeAL.add(testAge[p]);
        }
        if (testAgeAL.isEmpty())
            System.out.println("\ntestAgeAL still has no values"); 
        else
            System.out.println("\nPrinting testAgeAL "+testAgeAL);
        
        testAgeAL.add(10);
        System.out.println("\nPrinting testAgeAL with 10 "+testAgeAL);
        System.out.println("Length of testAgeAL is "+testAgeAL.size());
        
        Integer val = 40;
        testAgeAL.remove(val);
        System.out.println("\nPrinting testAgeAL with 40 removed "+testAgeAL);
        System.out.println("Length of testAgeAL is "+testAgeAL.size());    
        
        testAgeAL.remove(0);
        System.out.println("\nPrinting testAgeAL with index 0 removed "+testAgeAL);
        System.out.println("Length of testAgeAL is "+testAgeAL.size()); 
        
        
        int testIndexAL = deleteElementAL(testAgeAL,testIndex,77);
        System.out.println("\nPrinting testAgeAL with value 77 removed "+testAgeAL);
        System.out.println("Length of testAgeAL is "+testAgeAL.size()+ " or "+ testIndexAL); 

        testAgeAL.add(39);
        testAgeAL.add(21);
        testAgeAL.add(9);
        testAgeAL.add(-4);
        System.out.println("\nPrinting testAgeAL with values added "+testAgeAL);
        countSwaps = bubbleSortAgeSwapAL(testAgeAL);
        System.out.println("\nPrinting testAgeAL after bubblesort "+testAgeAL);
        */
    }
    
    public static int bubbleSortAllbyAnySwap(int strNum, String[][] heroNm, int colNum, int[][] list, int sz)
    {
        // strNum = 1 means Strings, strNum = 2 means ints
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {   
                
                if (((strNum == 2) &&
                    (list[comp][colNum] > list[comp+1][colNum])) ||
                    ((strNum == 1) &&
                    ( (heroNm[comp][colNum].compareToIgnoreCase(heroNm[comp+1][colNum])) > 0 )))
                    
                { // swap
                    swap(list,comp);
                    swap(heroNm, comp);
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }   

    
    
    /*
    
    public static int bubbleSortAgeSwapAL( ArrayList<Integer> list)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < list.size(); pass++)  // sz would list.length()
        { for (int comp = 0; comp <  list.size() -1 ; comp++)
            {
                if (list.get(comp) > list.get(comp+1))
                { // swap
                    swap(list,comp);
                    countswaps++;
                }
            }
            
        }
        return countswaps;        
    }  
    
    private static void swap(ArrayList<Integer> list, int comp)
    {   Integer temp;
        //System.out.println("In int swap, trade "+list[comp]+" and "+list[comp+1]);
        //System.out.println("In Integer swap, trade "+list.get(comp)+" and "+list.get(comp+1));
        //temp = list[comp];
        temp = list.get(comp);
        //list[comp] = list[comp+1];
        list.set(comp,list.get(comp+1));
        //list[comp+1] = temp; 
        list.set(comp+1,temp );
               
    }    
    
    
    public static int deleteElementAL( ArrayList<Integer> list, int sz, int element)
    {
        Integer val = element;
        list.remove(val);
        return list.size();
    }
    */
    
    /*
    method deleteElement
    removes the passed in element from list and moves all values in
    list below element up to fill in the space where element was
    */
    /*
    public static int deleteElement( int[] list,int sz, int element)
    {   
        
        
        int loc = sz;  // assume element is at the end
        // find the location of element
        for (int i= 0; ((i < sz) && (loc == sz)); i++)
        {  // look for array value that matches element
            if (list[i] == element)
            {
                loc = i;
            }
        } 
        // move values below element to fill in its location
        if (loc < sz)
        {
            for(int r = loc; r < sz; r++ )
            {
                list[r] = list[r+1];
            }
        }
        if (loc == sz)
            return sz;  // element was not in the array
        else
            return sz-1;  // return new size of array
    }
    
    
    public static int insertElement( int[] list,int sz, int element)
    {   
        int loc = sz;  // assume new element goes at the end
        // find the location to add element
        for (int i= 0; ((i < sz) && (loc == sz)); i++)
        {  // find an element greater than one to be added
            if (list[i] > element)
            {
                loc = i;
            }
        } 
        // move any values that might need to be moved
        if (loc < sz)
        {
            for(int r = sz-1; r >= loc; r-- )
            {
                list[r+1] = list[r];
            }
        }
        // insert/add the new element
        list[loc] = element;  
        return sz+1;  // return new size of array
    }
    */
    /*
    public static int bubbleSortAllbyAnyNameSwap(String[] Nm1, String[] Nm2, 
            String[] Nm3,int[] Yr1, int[] Yr2, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {   
                //do you need to check for blank strings?
                if ( (Nm1[comp].compareToIgnoreCase(Nm1[comp+1])) > 0 )
                { // swap
                    //System.out.print("Nm1["+comp+"] = "+Nm1[comp]);
                    //System.out.println(" compared to Nm1["+(comp+1)+"] = "+Nm1[comp+1]);
                    swap(list,comp);
                    swap(Nm1, comp);
                    swap(Nm2, comp);
                    swap(Nm3, comp);
                    swap(Yr1, comp);
                    swap(Yr2, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }    
    
    public static int bubbleSortAllbyAnyNameSwap(String[][] heroNm, int colNum, int[][] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {   
                //do you need to check for blank strings?
                if ( (heroNm[comp][colNum].compareToIgnoreCase(heroNm[comp+1][colNum])) > 0 )
                { // swap
                    //System.out.print("Nm1["+comp+"] = "+Nm1[comp]);
                    //System.out.println(" compared to Nm1["+(comp+1)+"] = "+Nm1[comp+1]);
                    swap(list,comp);
                    swap(heroNm, comp);
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }   
    */
    /*
    public static int bubbleSortAllbySHNameSwap(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                //do you need to check for blank strings?
                if ( (shNm[comp].compareToIgnoreCase(shNm[comp+1])) > 0 )
                { // swap
                    swap(list,comp);
                    swap(lastNm, comp);
                    swap(firstNm, comp);
                    swap(shNm, comp);
                    swap(pubYr, comp);
                    swap(movYr, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    } 
    */
    /*
public static int bubbleSortAllbyAgeSwap(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp] > list[comp+1])
                { // swap
                    swap(list,comp);
                    swap(lastNm, comp);
                    swap(firstNm, comp);
                    swap(shNm, comp);
                    swap(pubYr, comp);
                    swap(movYr, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }
    */
/*
public static int bubbleSortAllbyAgeSwap( String[][] heroNm,int[] pubYr, int[] movYr, int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp] > list[comp+1])
                { // swap
                    swap(list,comp);
                    
                    //swap(lastNm, comp);
                    //swap(firstNm, comp);
                    //swap(shNm, comp);
                    
                    swap(heroNm, comp);
                    swap(pubYr, comp);
                    swap(movYr, comp); 
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }
*/
    /*
    public static int bubbleSortAllbyAgeSwap( String[][] heroNm,int[][] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp][AGE] > list[comp+1][AGE])
                { // swap
                    swap(list,comp);
                    swap(heroNm, comp);
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }
*/
    /*
    public static int bubbleSortAllbyNumberSwap( String[][] heroNm,int colNum, int[][] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp][colNum] > list[comp+1][colNum])
                { // swap
                    swap(list,comp);
                    swap(heroNm, comp);
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    }
*/
    /*
    public static int bubbleSortAgeSwap( int[] list, int sz)
    {
        int countswaps = 0;
        int temp;
        String tempStr;
        for (int pass = 0; pass < sz; pass++)  // sz would list.length()
        { for (int comp = 0; comp <  sz -1 ; comp++)
            {
                if (list[comp] > list[comp+1])
                { // swap
                    swap(list,comp);
                    countswaps++;
                }
            }
            
        }
        sz = 0;
        return countswaps;        
    } 
*/
    private static void swap(int[][] list, int comp)
    {   int[] temp;
        //System.out.println("In int swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }      
    
    
    private static void swap(String[][] list, int comp)
    {   String[] temp;
        //System.out.println("In int swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }  
    /*
    private static void swap(int[] list, int comp)
    {   int temp;
        //System.out.println("In int swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }
    private static void swap(String[] list, int comp)
    {   String temp;
        //System.out.println("In String swap, trade "+list[comp]+" and "+list[comp+1]);
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp;        
    }
    private static void swap(double[] list, int comp)
    {   double temp;
        temp = list[comp];
        list[comp] = list[comp+1];
        list[comp+1] = temp; 
        return;
    }  
*/
    public static boolean printTableFLS(String[][] heroNm,int[][] heroNums, int sz)
    {
        boolean tableTF = true;
        // printing for verification
        System.out.printf("\n%20s %12s %17s %5s %5s %5s\n","SHName","First","Last","Comic","Movie","Age");
        for(int i=0; i < 80; i++)
            System.out.print("-");
        System.out.println("");
        for(int i=0; i < sz; i++)
        {
           System.out.printf("%20s %12s %17s %5d %5d %5d\n", 
                   heroNm[i][SH], heroNm[i][FIRST], heroNm[i][LAST], 
                   heroNums[i][PUBYR], heroNums[i][MOVYR], heroNums[i][AGE]);
           //System.out.printf("%15s %24\n",firstNm[i],lastNm[i]);
           if (heroNums[i][MOVYR] == 0)  // just an example of testing something and 
               tableTF = !tableTF;  // setting a boolean
           
        }  
        return tableTF;
    } 
    /*
    public static boolean printTableFLS(String[][] heroNm,int[] pubYr, int[] movYr, int[] age, int sz)
    {
        boolean tableTF = true;
        // printing for verification
        System.out.printf("\n%20s %12s %17s %5s %5s %5s\n","SHName","First","Last","Comic","Movie","Age");
        for(int i=0; i < 80; i++)
            System.out.print("-");
        System.out.println("");
        for(int i=0; i < sz; i++)
        {
           System.out.printf("%20s %12s %17s %5d %5d %5d\n", 
                   heroNm[i][SH], heroNm[i][FIRST], heroNm[i][LAST], pubYr[i], movYr[i], age[i]);
           //System.out.printf("%15s %24\n",firstNm[i],lastNm[i]);
           if (movYr[i] == 0)  // just an example of testing something and 
               tableTF = !tableTF;  // setting a boolean
           
        }  
        return tableTF;
    }
    */
    /*
    public static boolean printTableFLS(String[] lastNm, String[] firstNm, 
            String[] shNm,int[] pubYr, int[] movYr, int[] age, int sz)
    {
        boolean tableTF = true;
        // printing for verification
        System.out.printf("\n%20s %12s %17s %5s %5s %5s\n","SHName","First","Last","Comic","Movie","Age");
        for(int i=0; i < 80; i++)
            System.out.print("-");
        System.out.println("");
        for(int i=0; i < sz; i++)
        {
           System.out.printf("%20s %12s %17s %5d %5d %5d\n", 
                   shNm[i], firstNm[i], lastNm[i],pubYr[i], movYr[i], age[i]);
           //System.out.printf("%15s %24\n",firstNm[i],lastNm[i]);
           if (movYr[i] == 0)  // just an example of testing something and 
               tableTF = !tableTF;  // setting a boolean
           
        }  
        return tableTF;
    }
*/
    public static String removeBlanks(String inStr)
    {
        //System.out.println("In rB, string is *"+inStr+"*");
        //String nStr = inStr.trim();
        String nStr = inStr;
        //System.out.println("In rB, string after trim is *"+nStr+"*");
        int cnt = 0;
        if (nStr.length() > 0)
        {
            //System.out.println("in rB, in if, before 1st while, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
            while ((nStr.length() > 0) && (nStr.charAt(cnt) == ' ') ) // check lenght BEFORE checking charAt when string is too short
            {
                //System.out.println("in rB, in if, in 1st while, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
                nStr = nStr.substring(1);
                //System.out.println("in rB, in if, in 1st while after subs, nStr.length() = "+nStr.length()+" & cnt = "+cnt);
                
            }
            //System.out.println("In rB, string after remove front blanks is *"+nStr+"*");
        }
        if (nStr.length() > 0)
        {
            //System.out.println("in rB, in 2nd if, before while, nStr.length() = "+nStr.length());
            while ((nStr.length()>0) && (nStr.charAt(nStr.length()-1) == ' ') )
            {
                nStr = nStr.substring(0, nStr.length()-1);
            }
        }
        //System.out.println("In rB, string after remove back blanks is *"+nStr+"*");
        return nStr;
    }    

}