Desktop Programming > Java

Six Fast Steps in Java 8 ... (a continuation of the Six Fast Steps series)

(1/2) > >>

David:
Here is a new "Six Fast Steps in Java 8" series of demo programs to fast-track new Java programmers.


Update!  FREE homework help NOW available via e-mail ... (or in person if in Toronto Ontario Canada region.)

You can contact me via:
http://sites.google.com/site/andeveryeyeshallseehim/home/he-comes
http://developers-heaven.net/forum/index.php/board,9.0.html


The first part consists of a series of 5 example programs that students may like to have for reference and to use as a working 'shell' from which to start a project.

1. The first program is just a most basic 'shell' that compiles, and when run, asks the user to press 'More' (y/n) ? to loop again or quit.

2. The next program illustrates getting a sum and finding the average of valid numeric input in a loop.

3. The next three programs progress from inputting numbers into an ARRAY that has the max size fixed at compile time ... to using an ArrayList ... and then a LinkedList container to hold as many numbers as the user wishes (limited only by available memory). They also illustrate how to SORT, FIND, or ERASE elements from the respective containers.

(All the numeric input examples above find the sum and average value of the numbers input.)

Then the 6th program features using a Java class ... class BP (Blood Pressure) 


But firstly, a little 'TakeInLine' class ...

to facilitate prompting for ...

and inputting (whole lines) from the keyboard ...

to obtain valid and crash-proof ...

Java int, long and double, etc... data types.



--- Code: ---/**
 * @version: 2017-11-27
 * @author: dwz
 * See file: TakeInLineTest.java for demo of how to use. //
 */

 
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;


public class TakeInLine {
    // Create a BufferedReader using System.in ... //
    private BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
   
    private static String errFormatStr = "Please enter a VALID '%s' number.%n";
   
    public String takeInLine( String msg ) {
        System.out.print( msg );
        String line = null;
        try {
            line = br.readLine();
        } catch( IOException e ) {
            System.err.println( e );
            System.out.println( "UNEXPECTED string input error." );
            line = ""; // default here to empty line ... //
        }
        return line;
    }
 
 
    public char takeInChar( String msg ) {   
        String line = takeInLine( msg );
        if( line.length() > 0 ) {
            return (char)line.charAt(0);
        } else {
            return (char)0;
        }
    }


    public int takeInInt( String msg ) {   
        while( true )
        {
            try {
                return Integer.parseInt( takeInLine( msg ) );
            } catch( NumberFormatException e ) {
                System.out.format( errFormatStr, "int"  );
            };
        }
    }
   

    public long takeInLong( String msg ) {   
        while( true ) {
            try {
                return Long.parseLong( takeInLine( msg ) );
            } catch( NumberFormatException e ) {
                System.out.format( errFormatStr, "long" );
            }
        }
    }
   
   
    public double takeInDouble( String msg ) {   
        while( true ) {
            try {
                return Double.parseDouble( takeInLine( msg ) );
            } catch( NumberFormatException e ) {
                System.out.format( errFormatStr, "double"  );
            }
        }
    }
   



    // call as more('y') if yes is to be the default case ...
    // call as more('n') if no is to be the default case //

    public boolean more( final char defaultChar ) { // 'y' or 'n' tells 'defaultChar' ... //

        char reply = Character.toLowerCase( takeInChar( "More (y/n) ? " ) );
       
        if( defaultChar == 'y' ) {
            return reply != 'n';
        } else {
            return reply == 'y';
        }
    }

    // this defaults to case: "yes more"
    // unless 'n' or 'N' is entered as first char on line //
    public boolean more() {
        return more( 'y' );
    }
}
--- End code ---


And a little test program ...


--- Code: ---/**
 * @version: 2017-11-21
 * @author: dwz
 *
 * Short demo of using my custom class TakeInLine
 */

class TakeInLineTest {

    private static TakeInLine til = new TakeInLine();
   
    public static void main( String[] args ) {
        int pin = 0;
        long id = 0L;
        for( ; ; ) {
            String name   = til.takeInLine(   "Enter this user name :  " );
            for( ; ; ) {
                pin       = til.takeInInt(    "Enter pin (8 digits) :  " );
                if( validNumDigits( pin, 8 ) ) break;
                System.out.println( "Need 8 digits to continue ..." );
            }
            for( ; ; ) {
                id       = til.takeInLong(    "Enter ID (16 digits) :  " );
                if( validNumDigits( id, 16 ) ) break;
                System.out.println( "Need 16 digits to continue ..." );
            }
            double amount = til.takeInDouble( "Enter $ amount owing :  " );
            System.out.println();

            System.out.format( "%s, %d, %d owes: %,1.2f dollars. %n", name, pin, id, amount );
            System.out.println();
            System.out.println( "On to next client?" );
            System.out.print( "Whenever you are ready, enter y or n, " );
            System.out.println( "or just press the Enter key for 'y'." );
           
            if( !til.more() ) break;
        }
    }
   
    static boolean validNumDigits( long num, int numDig ) {
        String valStr = "" + num;
        return valStr.length() == numDig;
    }
}
--- End code ---


Now the first program in this series ... it just loops and prompts the user asking More (y/n)?

(1.)

--- Code: ---// 2016-09-29 //


// uses my custom class TakeInLine  //


class DoWhileMore {

    public static void main( String[] args ) {

        // create a new TakeInLine object called til //
        TakeInLine til = new TakeInLine();

        do {

            // Your code goes here //

        } while( til.takeInChar( "More (y/n) ? " ) != 'n' );
    }
}

--- End code ---


Now the 2nd program in this series ...

(2.)

--- Code: ---// 2017-11-21 //

// uses my custom class TakeInLine  //


class MoreInts {
   
    public static void main( String[] args ) {

        // loop repeatedly while more() returns true ...
        // Note that the default return value of more()
        // if nothing entered (and just pressed return) is true //
       
        long sum = 0;
        int count = 0;
        // create a new TakeInLine object called til //
        TakeInLine til = new TakeInLine();
        do {
            // call my method takeInInt and pass in the required prompt String //
            int num = til.takeInInt( "Enter an 'int' number: " );
            ++ count;
            // update the sum
            sum += num;
        } while( til.more() );

        System.out.println( "The sum of the " + count
                            + " numbers is: " + sum );
        System.out.println( "The avg of the " + count
                            + " numbers is: " + (double)sum/count );
    }
}

--- End code ---

P.S.

You might like to look at the next link to see an other very simple,
and beginning student inspired,
Java class to handle Console IO:
https://www.daniweb.com/programming/software-development/threads/506147/developing-a-class-to-ease-student-coding-crash-proof-and-valid-io

David:
An array of type int

(3.a )

--- Code: ---// 2016-11-16 //


// uses my custom class TakeInLine
// enters integer data, finds sum, average, sorts, finds value, erase, show ... //


import java.util.Arrays;


class ArrayInt {
    final static int MAX_SIZE = 5; // use a small size here to ease testing //   
 
    public static void main( String[] args ) {

        int[] myAry = new int[ MAX_SIZE ]; // create to hold up to MAX_SIZE int's //
        int size = 0;
       
        TakeInLine til = new TakeInLine();

        do {
            myAry[ size ] = til.takeInInt( "Enter next integer to sum: " );
            ++ size;
            if( size == MAX_SIZE ) {
                System.out.println( "You have reached the maximum "
                                    + MAX_SIZE + " number of elements." );
                break;
            }
        } while( til.more() );
       
        double sum = sumAry( myAry, size );
       
        System.out.println( "\nFor " + size+ " numbers entered, sum is "
                            + sum + " and array average is " + sum/size );
             
        System.out.print( "\nshowAry: " );
        showAry( myAry, size );
       

        int last = myAry[ size-1 ]; // size is always at least 1 //

        Arrays.sort( myAry, 0, size );
        reverse( myAry, size );
     

        System.out.print( "\nAfter sorting and reversing ...\nshowAry: " );
        showAry( myAry, size );
   
        int i = findIndex( myAry, size, last );
        if( i != -1 ) {
            size = eraseIndex( myAry, size, i );

            System.out.println( "\nAfter erasing " + last + " ..." );
            System.out.println( "\nshowAry: " );
            showAry( myAry, size );
        } else {
            System.out.println( last + " NOT found in array." );
        }           
    }


    static double sumAry( final int[] ary, final int size ) {
        double sum = 0.0;
        for( int i = 0; i < size; ++ i ) {
            sum += ary[i];
        }
        return sum;
    }

    static void showAry( final int[] ary, final int size ) {
        for( int i = 0; i < size; ++ i ) {
            System.out.print( ary[i] + " " );
        }
        System.out.println();
    }


    static int findIndex( final int[] ary, final int size, final int value ) {
        for( int i = 0; i < size; ++i ) {
            if( ary[i] == value )
                return i;
        }
        // else if reach here ...
        return -1;
    }

    static int eraseIndex( int[] ary, final int size,
                           final int index ) {
        for( int i = index; i < size-1; ++i ) {
            ary[i] = ary[i+1]; // copy each element above, down one index, so erased
        }
        return size-1;
    }

    static void reverse( int[] ary, final int size ) {
        int tmp;
        for( int i = 0, end = size - 1; i < end; ++i, --end ) {
            tmp = ary[i];
            ary[i] = ary[end];
            ary[end] = tmp;
        }
    }
}

--- End code ---


(3.b)  <-- a variant of (3.a)

--- Code: ---// 2016-11-16 //


// uses my custom class TakeInLine
// enters integer data, finds sum, average, sorts, finds value, erase, show ... //


import java.util.Arrays;
import java.util.stream.IntStream;



class ArrayInt2 {
    final static int MAX_SIZE = 5; // use a small size here to ease testing //   
 
    public static void main( String[] args ) {

        int[] myAry = new int[ MAX_SIZE ]; // create ALL zero, to hold up to MAX_SIZE int's //
        int size = 0;
       
        TakeInLine til = new TakeInLine();

        do {
            myAry[ size ] = til.takeInInt( "Enter next integer to sum: " );
            ++ size;
            if( size == MAX_SIZE ) {
                System.out.println( "You have reached the maximum "
                                    + MAX_SIZE + " number of elements." );
                break;
            }
        } while( til.more() );
       
        //double sum = sumAry( myAry, size );
        //double sum = IntStream.of( myAry ).sum();
        double sum = IntStream.of( myAry ).parallel().sum(); // NOTE! Any unused elements were initialed to 0 value //
       
        System.out.println( "\nFor " + size+ " numbers entered, sum is "
                            + sum + " and array average is " + sum/size );
             
        System.out.print( "\nshowAry: " );
        showAry( myAry, size );
       

        int last = myAry[ size-1 ]; // size is always at least 1 //

        Arrays.sort( myAry, 0, size );
     

        System.out.print( "\nAfter sorting  ...\nshowAry: " );
        showAry( myAry, size );
   
        //int i = findIndex( myAry, size, last );
        int i = Arrays.binarySearch( myAry, 0, size, last );

        if( i != -1 ) {
            size = eraseIndex( myAry, size, i );

            System.out.print( "\nAfter erasing " + last + " and reversing ... " );
            reverse( myAry, size );
            System.out.println( "\nshowAry: " );
            showAry( myAry, size );
        } else {
            System.out.println( last + " NOT found in array." );
        }           
    }

/*
    static double sumAry( final int[] ary, final int size ) {
        double sum = 0.0;
        for( int i = 0; i < size; ++ i ) {
            sum += ary[i];
        }
        return sum;
    }
*/
    static void showAry( final int[] ary, final int size ) {
        for( int i = 0; i < size; ++ i ) {
            System.out.print( ary[i] + " " );
        }
        System.out.println();
    }

/*
    static int findIndex( final int[] ary, final int size, final int value ) {
        for( int i = 0; i < size; ++i ) {
            if( ary[i] == value )
                return i;
        }
        // else if reach here ...
        return -1;
    }
*/
    static int eraseIndex( int[] ary, final int size,  final int index ) {
        for( int i = index; i < size-1; ++i ) {
            ary[i] = ary[i+1]; // copy each element above, down one index, so erased
        }
        return size-1;
    }

    static void reverse( int[] ary, final int size ) {
        int tmp;
        for( int i = 0, end = size - 1; i < end; ++i, --end ) {
            tmp = ary[i];
            ary[i] = ary[end];
            ary[end] = tmp;
        }
    }
}

--- End code ---


And also, an array of Java type Integer

(3.c)

--- Code: ---/// 2016-11-16 //


// uses my custom class TakeInLine
// enters integer data, finds sum, average, sorts, finds value, erase, show ... //


import java.util.Arrays;
import java.util.Comparator;



class ArrayInteger
{
    final static int MAX_SIZE = 5; // use a small size here to ease testing //   
 
    public static void main( String[] args ) {

        // create to hold up to MAX_SIZE int's //
        Integer[] myAry = new Integer[ MAX_SIZE ];

        int size = 0; // index of next postion available to fill //
       
        TakeInLine til = new TakeInLine();

        do {
            myAry[ size ] = til.takeInInt( "Enter next integer to sum: " );
            ++ size;
            if( size == MAX_SIZE ) {
                System.out.println( "You have reached the maximum "
                                    + MAX_SIZE + " number of elements." );
                break;
            }
        } while( til.more() );
       
        double sum = sumAry( myAry, size );;
       
        System.out.println( "\nFor " + size+ " numbers entered, sum is "
                            + sum + " and array average is " + sum/size );
             
        System.out.print( "\nshowAry: " );
        showAry( myAry, size );
       

        Integer last = myAry[ size-1 ]; // size is always at least 1 //

        Arrays.sort( myAry, 0, size );

        System.out.print( "\nAfter sorting ...\nshowAry: " );
        showAry( myAry, size );
   
        //int i = findIndex( myAry, size, last );
        int i = Arrays.binarySearch( myAry, 0, size, last );
        if( i != -1 ) {
            size = eraseIndex( myAry, size, i );

            System.out.println( "\nAfter erasing " + last + " ..." );

            Arrays.sort( myAry, 0, size, new ReverseIntegers() );

            System.out.print( "\nAfter sorting in reversed order ...\nshowAry: " );
            showAry( myAry, size );
        } else {
            System.out.println( last + " NOT found in array." );
        }           
    }


    static double sumAry( final Integer[] ary, final int size ) {
        double sum = 0.0;
        for( int i = 0; i < size; ++ i ) {
            sum += ary[i];
        }
        return sum;
    }

    static void showAry( final Integer[] ary, final int size ) {
        for( int i = 0; i < size; ++ i ) {
            System.out.print( ary[i] + " " );
        }
        System.out.println();
    }

/*
    static int findIndex( final Integer[] ary, final int size,
                          final Integer value ) {
        for( int i = 0; i < size; ++i ) {
            if( value == ary[i] ) {
                return i;
            }
        }
        // else if reach here ...
        return -1;       
    }
*/
    static int eraseIndex( Integer[] ary, final int size, final int index ) {
        for( int i = index; i < size-1; ++i ) {
            ary[i] = ary[i+1]; // copy each element above, down one index, so erased
        }
        return size-1;
    }
}


class ReverseIntegers implements Comparator < Integer > {
    public int compare( Integer a, Integer b ) {
        return b.compareTo(a);
    }
}

--- End code ---

David:
Java class ArrayListInt


(4.)

--- Code: ---// 2016-09-29 //


// uses my custom class TakeInLine
// enters integer data, finds sum, average, sorts, finds value, erase, show ... //


import java.util.List;
import java.util.ArrayList;
import java.util.Collections;


class ArrayListInt {

    public static void main( String[] args ) {

        // get a new TaKeInLine obj.
        TakeInLine til = new TakeInLine();

        // get a new (empty) ArrayList to hold Integers
        List < Integer > my_lst = new ArrayList<>();

        do {
            // prompt and takeIn next int that gets converts to Integer when append to List
            int tmpInt = til.takeInInt( "Enter next integer to sum: " );
            my_lst.add(tmpInt);

        } while( til.more() );
       
        double sum = sumLst( my_lst );
       
        System.out.format( "%nFor %d numbers entered, sum is: %1.2f", my_lst.size(), sum );
        System.out.format( "%nArrayList average is: %1.2f%n", sum/my_lst.size() );
             
        System.out.println( "my_lst: " + my_lst );
       

        int last = my_lst.get(my_lst.size()-1);

        Collections.sort( my_lst, (a, b) -> -a.compareTo(b) );

        System.out.println( "\nAfter sorting descending ...\nmy_lst: " + my_lst );

   
        int i = my_lst.indexOf( last );

        if( i != -1 ) {
            my_lst.remove( i );

            System.out.println( "\nAfter erasing " + last + " ..." );
            System.out.println( "my_lst: " + my_lst );
        } else {
            System.out.println( last + " NOT found in lst." );
        }
    }


    static double sumLst( final List< Integer > lst ) {
        double sum = 0.0;
        for( int val : lst ) {
            sum += val;
        }
        return sum;
    }
}

--- End code ---


Java class LinkedListInt

(5.)

--- Code: ---// 2016-09-29 //


// uses my custom class TakeInLine
// enters integer data, finds sum, average, sorts, finds value, erase, show ... //



import java.util.List;
import java.util.LinkedList;
import java.util.Collections;


class LinkedListInt {

    public static void main( String[] args ) {

        // get a new TaKeInLine obj.
        TakeInLine til = new TakeInLine();

        // get a new (empty) List to hold Integers
        List < Integer > my_lst = new LinkedList<>();

        do {
            // prompt and takeIn next int that gets converts to Integer when append to List
            int tmpInt = til.takeInInt( "Enter next integer to sum: " );
            my_lst.add(tmpInt);

        } while( til.more() );
       
        double sum = sumLst( my_lst );
       
        System.out.format( "%nFor %d numbers entered, sum is: %1.2f", my_lst.size(), sum );
        System.out.format( "%nArrayList average is: %1.2f%n", sum/my_lst.size() );
             
        System.out.println( "my_lst: " + my_lst );
       

        int last = my_lst.get(my_lst.size()-1);

        Collections.sort( my_lst, (a, b) -> -a.compareTo(b) );

        System.out.println( "\nAfter sorting descending ...\nmy_lst: " + my_lst );
       
       
        //int i = my_lst.indexOf( last );

        // MUST pass in Integer object here, to use call to lst.remove(obj) //
        if( /*i != -1*/ my_lst.remove( new Integer(last) ) ) {
            //my_lst.remove( i ); // call here is to lst_remove( intIndex ) //

            System.out.println( "\nAfter remove of " + last + " ..." );
            System.out.println( "my_lst: " + my_lst );
        } else {
            System.out.println( last + " NOT found in lst." );
        }       
    }


    static double sumLst( final List< Integer > lst ) {
        double sum = 0.0;
        for( int val : lst ) {
            sum += val;
        }
        return sum;
    }
}

--- End code ---

David:
This 6th step features reading and writing (text) data files,

using Java's latest nio - file New IO ...
 

(6.)

--- Code: ---/**
 * @version: 2017-12-04
 * @author: dwz
 * This demo uses the latest Java 'new file io' (nio) ...
 * to read a .txt data file of names and blood pressures
 * and then to print a possible diagnosis to console and file.
 */


// structure of data file: BP.txt //
/*
Smith Jane 133/76
Jones Rob 98/70
Costello Judy-Ann 144/90
Frank-Anderson Bibby-Bonnie 190/30
Sue Peggy 10/5
James-Thomas Andrew 190/111
*/


import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.charset.Charset;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;


class BloodPressure {
   
    final static String FNAME = "BP.txt";
    final static String RESULTS_FNAME = "Results" + FNAME;

    public static void main( String[] args ) {
       
        if( Files.exists( Paths.get( FNAME ) ) ) {
            try( BufferedReader fin = Files.newBufferedReader( Paths.get( FNAME ) ); // note ; here //
               
                    BufferedWriter fout = Files.newBufferedWriter( Paths.get( RESULTS_FNAME ),
                            Charset.defaultCharset() ) ) {
                 
                BP bp  = new BP();
                String line = null;
             
                // read lines until EOF is reached, i.e. here ... until null is returned //
                while( ( line = fin.readLine() ) != null ) {
                    String[] lst = line.split( "[/ ]" );
                    //System.out.println( "lst.length = " + lst.length ); //debugging//
                    bp.lname = lst[0];
                    bp.fname = lst[1];
                    try {
                        bp.sys = Integer.parseInt( lst[2] );
                        bp.dia = Integer.parseInt( lst[3] );
                       
                    } catch( NumberFormatException ex ) {
                        System.out.println( ex );
                    }
                   
                    String text = bp.toString();
                    System.out.println(text); // write to console screen ...

                    //fout.write( text, 0, text.length() );
                    fout.write( text ); // write to RESULT file //
                    fout.newLine(); // Write separator //
                }

            }
            catch( IOException ex) {
                System.out.println( ex );
            }
        } else {
            System.out.println( "There was a problem finding file: " + FNAME );
        }
    }
}


class BP { // class BP handles data and methods called for Blood Pressure Objects //

    final static String UNKNOWN = " <--\n Unrecognized diagnosis. \n" +
        "* CHECK VALIDITY of DATA entered. *";
    String lname, fname;
    int sys, dia;
       
    String getDiagnosis() { // Note: need since returning as part of toString //

        if( sys < 120/2 || dia < 80/2 ) // ?? //
            return UNKNOWN;
        if( sys > 120*2 || dia > 80*2 ) // ?? //
            return UNKNOWN;

        if( sys >= 160 || dia > 100 )
            return " <--\n CHECK AGE re. possible Stage 2 Hypertension.";
        if( sys >= 140 || dia >= 90 )
            return " <--\n CHECK AGE re. possible Stage 1 Hypertension.";
        if( sys >= 120 || dia >= 80 )
            return " <--\n CHECK AGE re. possible Pre-Hypertension.";
        // else ...
        return "\n Normal";
    }
   
    @Override
    public String toString() { // Note that this toString method also calls the getDiagnosis method //
        // print left adujust string in 40 spaces, right adjusts each number in 3 spaces
        // then print
        return String.format( "%-40s %3d/%3d %s", (lname + ", " + fname),
            sys, dia, getDiagnosis() );
    }
}

--- End code ---

David:
(6. version 2)  New file stream version - uses file: class BP below



--- Code: ---/**
 * @version: 2017-12-05
 * @author: dwz
 * This demos using the latest Java 8 Stream, with map and ForEach methods,
 * to read a .txt data file of names and blood pressures
 * and then to print a possible diagnosis to console and file.
 * (Note that each result (String) gets stored in a List <String> container here.)
 */
 

// structure of data file: BP.txt //
/*
Smith Jane 133/76
Jones Rob 98/70
Costello Judy-Ann 144/90
Frank-Anderson Bibby-Bonnie 190/30
Sue Peggy 10/5
James-Thomas Andrew 190/111
*/


import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.charset.Charset;

import java.io.IOException;

import java.util.stream.Stream;
import java.util.List;
import java.util.ArrayList;


public class BloodPressure2 {

    final static String FNAME = "BP.txt";
    final static String RESULTS_FNAME = "Results" + FNAME;
    // get (a ref to) an empty List to be filled up below //
    final static List< String > results = new ArrayList<> ();

    public static void main( String[] args ) {
           
        try( Stream< String > lines = Files.lines( Paths.get( FNAME ) ) ) {
            lines.map( line -> diagnoseAndAddResultString(line) )
                 .forEach( System.out::println );
       
        } catch( IOException ex ) {
            System.out.println( ex );
        }
       
        // ok ... now can write List of results to file ...
        try {
            Files.write( Paths.get( RESULTS_FNAME ), results, Charset.defaultCharset() );
        } catch( IOException ex ) {
            System.out.println( ex );
        }
    }
   
    static String diagnoseAndAddResultString( String line ) {
        BP bp = new BP( line );
        String tmp = bp.toString(); // tmp now holds diagnosis also //
        results.add( tmp ); // Note that results is a (ref. to a) List< String > object //
        return tmp;
    }
}

--- End code ---


And here is the class BP used above ...


--- Code: ---/**
 * @version: 2017-12-05
 * @author: dwz
 * class BP handles Blood Pressure data
 * and methods to get and show a diagnosis
 */


// structure of data file ...
// BP.txt //
/*
Smith Jane 133/76
Jones Rob 98/70
Costello Judy-Ann 144/90
Frank-Anderson Bibby-Bonnie 190/30
Sue Peggy 10/5
James-Thomas Andrew 190/111
*/


public class BP {

    private final static String UNKNOWN = " <--\n Unrecognized diagnosis. \n" +
        "* CHECK VALIDITY of DATA entered. *";
    private String lname, fname;
    private int sys, dia;
   
    // ctor from passed in String line of data (from file) //
    public BP( String line ) {
        String[] ary = line.split( "[/ ]" ); // split on char '/' or char ' ' //
        //System.out.println( "ary.length = " + ary.length ); //debugging//
        lname = ary[0];
        fname = ary[1];
        try {
            sys = Integer.parseInt( ary[2] );
            dia = Integer.parseInt( ary[3] );
           
        } catch( NumberFormatException ex ) {
            System.out.println( ex );
        }
    }
       
    // Note: this returned string is also returned as part of below toString() //
    public String getDiagnosis() {

        if( sys < 120/2 || dia < 80/2 ) // ?? //
            return UNKNOWN;
        if( sys > 120*2 || dia > 80*2 ) // ?? //
            return UNKNOWN;

        if( sys >= 160 || dia > 100 )
            return " <--\n CHECK AGE re. possible Stage 2 Hypertension.";
        if( sys >= 140 || dia >= 90 )
            return " <--\n CHECK AGE re. possible Stage 1 Hypertension.";
        if( sys >= 120 || dia >= 80 )
            return " <--\n CHECK AGE re. possible Pre-Hypertension.";
        // else ...
        return "\n Normal";
    }
   
    // Note that this method calls above method getDiagnosis() //
    @Override
    public String toString() {
        // left adjust string of combined lname + ", " + fname in 40 spaces,
        // right adjust each number in 3 spaces
        return String.format( "%-40s %3d/%3d %s", (lname + ", " + fname),
            sys, dia, getDiagnosis() );
    }
}

--- End code ---


And a demo text data file:  BP.txt


--- Code: ---Smith Jane 133/76
Jones Rob 98/70
Costello Judy-Ann 144/90
Frank-Anderson Bibby-Bonnie 190/30
Sue Peggy 10/5
James-Thomas Andrew 190/111

--- End code ---


And another Java 8 way ...
6. (version 2a)


--- Code: ---/**
 * @version: 2017-12-05
 * @author: dwz
 * This demos using the latest Java 8 Stream with map, filter and collect methods ...
 * to read a .txt data file of names and blood pressures
 * and then to print a possible diagnosis to console and file
 * for all NOT Normal results ... sorted by names (Note result String starts with lname, fname).
 */
 

// structure of data file: BP.txt //
/*
Smith Jane 133/76
Jones Rob 98/70
Costello Judy-Ann 144/90
Frank-Anderson Bibby-Bonnie 190/30
Sue Peggy 10/5
James-Thomas Andrew 190/111
*/


import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.charset.Charset;

import java.io.IOException;

import java.util.stream.Stream;
import java.util.stream.Collectors;
import java.util.List;
//import java.util.Collections;


public class BloodPressure2a {

    final static String FNAME = "BP.txt";
    final static String RESULTS_FNAME = "Results" + FNAME;


    public static void main( String[] args ) {

        List< String > results = null;
           
        try( Stream< String > lines = Files.lines( Paths.get( FNAME ) ) ) {
            // filter out all Normal results //
            results = lines.map( line -> (new BP( line )).toString() )
                           .filter( diaText -> ! diaText.substring(diaText.length()-6).equals("Normal") )
                           .sorted()
                           .collect( Collectors.toList() );
       
        } catch( IOException ex ) {
            System.out.println( ex );
        }


        // Now can sort result strings by names (that appear at front of each result string) //
        //Collections.sort( results );


        //for( String result : results ) // Now can print list of (NOT Normal) results to Console //
            //System.out.println( result );
        // or //
        results.stream().forEach( System.out::println );

        try { // And now can write List of results to file //
                       
            Files.write( Paths.get( RESULTS_FNAME ), results, Charset.defaultCharset() );
        } catch( IOException ex ) {
            System.out.println( ex );
        }
    }
}

--- End code ---

Navigation

[0] Message Index

[#] Next page