little girl wearing her school uniform

Why You Don’t Have To Waste Your Time Driving From Shop To Shop When You Can Find School Uniform Suppliers Online

little girl wearing her school uniform

Sometimes when people get used to one certain way of doing things, it can be really hard for them to break their habit and to try a new way of doing this said thing. And this is often the case for people as they get older in life and soon enough, they look around and most things surrounding them have changed. For instance, there are some who have run a family business for years and years and who have continued to have a paper trail for everything rather than to digitalise.

And then there are those who love nothing more than visiting a physical store and so to them, web-based shopping is just a mess and doesn’t make sense. This is because they are not able to actually try the clothes on and more often than not, people will end up purchasing the wrong thing. However, as there are plenty of exhausted mums out there who need just a little bit of help, here is why you don’t have to waste your time driving from shop to shop when you can find school uniform suppliers online.

 

You don’t have to waste your time driving from shop to shop when you can find school suppliers online who can tailor-make things that you need

As mentioned above, one of the reasons why people can have a hard time wrapping their minds around using the internet to shop is because they are rarely able to find the right fit for their young ones. But what they may not realise is that they are able to easily send in measurements so that things can be made perfectly for their young one. This means that you don’t have to waste your time driving from shop to shop when you can find a reliable school uniform supplier online who can tailor-make things that you need.

And this can be important for parents who don’t have unlimited funds and who need to make sure that they are getting this right the first time. Especially for those who have a child who is constantly growing and who will have to replace all of their clothes in a couple of months again anyway and so they need to conserve their money.

 

You also don’t have to waste your time driving from shop to shop when you can find school uniform suppliers online who can ship directly to your home

Another one of the reasons why people may be so against the world of internet shopping is because they may not have thought about all of the potential benefits that they can experience. For instance, you also don’t have to waste your time driving from shop to shop when you can find school uniform suppliers online who can ship directly to your home. This means that parents don’t have to leave the house for yet another thing to purchase and they can actually sit down to relax once and while.

It can also be helpful for these parents to know that most companies out there will actually offer a free returns option so that they are able to send back anything that doesn’t fit if they need to. In conclusion, when people are tired of running around all of the time, it is important for them to know that they don’t have to do this and that there are indeed ways that they are able to make their lives a whole lot easier, even if it is only something small that helps them.…

Command Line Arguments

Command Line Arguments in Eclipse

Before we go on to JUnit testing, let’s cover another tricky situation in Eclipse: how do we use command line arguments from within a graphical IDE? You might have noticed that my class has methods to read strings from a text file and write strings to a new text file, but we haven’t tested them yet. Let’s re-write the main method to read as follows:

public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println("\nYou must specify the input and output file " +
                    "paths!\n\nExample: SortedStringList input.txt ouput.txt" +
                    "\n\n");
            System.exit(1);
        }
        SortedStringList list = new SortedStringList(args[0]);
        list.printToFile(args[1]);
        System.out.printf("\nResults written to: %s\n\n", args[1]);
    }

Be sure to save the file. Next, we’ll need an input file to use as an example. Here’s one I came up with:

input.txt

Whiskey
Oscar
Quebec
Delta
X-Ray
Sierra
Mike
Hotel
Uniform
Juliet
Tango
Lima
India
November
Golf
Bravo
Romeo
Yankee
Zulu
Papa
Victor
Charlie
Foxtrot
Echo
Alpha
Kilo

Now let’s see how this would work from the terminal. Let’s say the path to your input.txt file is input_path. Recompile your java bytecode and run the program again like this:

$ javac path/SortedStringList.java
$ java -cp path SortedStringList input_path/input.txt input_path/output.txt

Results written to: input_path/output.txt

JUnit Testing Java Code Using Eclipse

Trying to learn how to use the popular Eclipse IDE? Trying to do all three at once? Me too. Hopefully, this tutorial will help both of us. I’m using Eclipse 3.5.2, so you may have to adapt to changes in the GUI if your version is different than mine.

Example Java Class

Let’s start out with a class I wrote that represents an alphabetized String Array. It is a good example of how to use an Array as a data buffer, and it also demonstrates how to read and write files (one method, anyway).

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * This class represents a sorted list of Strings.
 * 
 * @author GreeenGuru ([email protected])
 * @version 1.0
 */
public class SortedStringList {
    /** The maximum length of the stringList_ */
    private static final int MAX_SIZE = 100;
    /** The list of strings */
    private String[] stringList_ = new String[MAX_SIZE];
    /** Keeps track of next available index in stringList_ */
    private int size_ = 0;

    /**
     * Constructor that initializes stringList_ from data stored in a text file,
     * sorted alphabetically
     * 
     * @param input
     *            Name of text file containing string data.
     */
    public SortedStringList(String input) {
        try {
            Scanner scan = new Scanner(new File(input));
            // Skip the heading line
            if (scan.hasNextLine()) {
                scan.nextLine();
            }
            while (scan.hasNextLine() && size_ < MAX_SIZE) {
                stringList_[size_++] = scan.nextLine();
            }
            scan.close();
        } catch (Exception e) {
            System.out.printf("Unable to read from input file: %s\n\nThe "
                    + "error encountered was:\n\n%s\n", input, e);
            System.exit(1);
        }
        // Sort the array using exchange sort
        String temp;
        for (int i = 0; i < size_ - 1; i++) {
            for (int j = i + 1; j < size_; j++) {
                if (stringList_[i].compareToIgnoreCase(stringList_[j]) > 0) {
                    temp = stringList_[i];
                    stringList_[i] = stringList_[j];
                    stringList_[j] = temp;
                }
            }
        }
    }

    /**
     * Default Constructor
     */
    public SortedStringList() {
        // Nothing to do here.
    }

    /**
     * Getter for list size.
     * 
     * @return The number of strings in the list.
     */
    public int getSize() {
        return size_;
    }

    /**
     * Adds a new string to the list.
     * 
     * @param newString
     *            The string to be added
     */
    public void add(String newString) {
        if (newString.equals("") || newString.equals(null) || size_ >= MAX_SIZE) {
            // If input is invalid or the array is maxed out
            System.out.println("The list is full or the string is invalid.");
            return;
        }
        int index = 0;
        // Find the right position for the new string
        for (int i = 0; i < size_; i++) {
            if (stringList_[i].compareToIgnoreCase(newString) < 0) {
                index++;
            } else {
                break;
            }
        }
        // Shift remaining strings to the right
        for (int i = size_; i > index; i--) {
            stringList_[i] = stringList_[i - 1];
        }
        size_++;
        // Add the new string
        stringList_[index] = newString;
    }

    /**
     * Removes the string at the given index.
     * 
     * @param index
     *            The index of the string to be removed.
     */
    public void remove(int index) {
        // If the index is invalid, do nothing
        if (index < 0 || index >= size_) {
            System.out.println("There is no string at the given index.");
            return;
        }
        // Shift the rest of the strings to the left
        for (int i = index; i < size_ - 1; i++) {
            stringList_[i] = stringList_[i + 1];
        }
        stringList_[size_ - 1] = null;
        size_--;
    }

    /**
     * Removes the string given.
     * 
     * @param string
     *            The string to be removed.
     */
    public void remove(String string) {
        int index = this.getIndexOf(string);
        // If the string is not found, do nothing
        if (index == -1) {
            return;
        }
        // Now that we know where the string is, call the other remove method
        this.remove(index);
    }

    /**
     * Returns the string at the given index.
     * 
     * @param index
     *            The index queried
     * @return The string stored at the queried index.
     */
    public String getStringAt(int index) {
        return stringList_[index];
    }

    /**
     * Get the index of the string in question or -1 if the string is not found.
     * 
     * @param string
     *            The string queried.
     * @return The index of the queried string or -1 if the string is not found.
     */
    public int getIndexOf(String string) {
        boolean stringFound = false;
        int index = 0;
        for (int i = 0; i < size_; i++) {
            if (stringList_[i].equals(string)) {
                stringFound = true;
                index = i;
            }
        }
        if (stringFound == false) {
            // If the string is not found, do nothing
            System.out.println("There is no such string in the list.");
            return -1;
        }
        return index;
    }

    /**
     * Prints the list to the screen.
     */
    public void print() {
        for (int i = 0; i < size_; i++) {
            System.out.println(stringList_[i]);
        }
    }

    /**
     * Writes the list to a file.
     * 
     * @param input
     *            The name of the file to be created
     */
    public void printToFile(String input) {
        try {
            FileWriter fw = new FileWriter(new File(input));
            PrintWriter pw = new PrintWriter(fw);
            for (int i = 0; i < size_; i++) {
                pw.print(stringList_[i] + "\n");
            }
            pw.close();
            fw.close();
        } catch (Exception e) {
            System.out.printf("Unable to write to file.  The "
                    + "error encountered was:\n\n%s\n", e);
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        SortedStringList list = new SortedStringList();
        list.add("Zulu");
        list.add("2010");
        list.add("juliet");
        list.add("09");
        list.add("FOXTROT");
        list.add("27");
        list.add("alpha");
        list.add("Delta");
        list.add("papa");
        list.print();
        list.remove("FOXTROT");
        System.out.printf(
                "\nAfter removing \"FOXTROT\", the list now contains %d strings:\n\n",
                list.getSize());
        list.print();
    }
}

I’m going to assume here that you know how to create a new project in Eclipse (named whatever you want), create a new class called SortedStringList, and insert the code above to complete the class. If you haven’t learned Eclipse enough to do that, I suggest reading another Eclipse tutorial first. Specifically, I’d recommend the built-in Eclipse tutorial available from the Help menu. Go to Help → Cheat Sheets…, open the Java Development folder, and select Create a Hello World application. This will open a short tutorial as a handy side pane. If you need more guidance than that, look around under Help → Help Contents and you should be able to find anything you need to know.

You may have noticed that I’ve included a main method in my code that calls some of the methods in my class. I like to do that as a quick functional test. It gives me some instant feedback, telling me whether or not my class works at all. Of course, this small functional test does not test all my methods, nor does it tell me how they will respond to marginal or invalid parameters. A better technique is to write unit tests for each method before you even start coding the method. When you’re finished coding, all you have to do is run the test and you’ll receive instant feedback telling you whether or not your method works. That is why we’re learning how to use JUnit, which can do just that. Until then, however, let’s run the functional test. Make sure you have our new class selected in Eclipse and click on the green Run button.

This tells us that the class is keeping the String Array sorted alphabetically even after adding strings in the wrong order and removing one from the middle. Great! By the way, we could have also run this from the terminal. First, we have to know where our Elipse workspace is located. From there, we need to navigate to the project directory we created and then to the src folder to find SortedStringList.java. If you can’t find it, just go to File → Properties and Eclipse will show you the location of the file. For our sake, let’s say the path to SortedStringList.java is path/SortedStringList.java. If you’re using Windows, the commands will be the same but the prompts will look different (obviously).

 …