How to use array instead of arraylist in loading line by line object from file in java

Question

(Homework:) I want to use array instead of arraylist in this situation. I have the arraylist name Employee and i have to insert data of it into the tree. I load data line by line from file. But i want to use array for the Employee not arraylist. How can i do that ? There're any ways to use array instead of arraylist in this situation. The following code is my example code for arraylist Employee. I want to change List to Employee[] how can i write the following function in style of Array.

public static void main(String[] args) {
    List<Employee> employees = read("employees.txt");

    BST bst = new BST();
    for(Employee e : employees){
        bst.insert(e);
    }

}

public static List<Employee> read(String file) {
    try {
        List<Employee> employees = new ArrayList<>();

        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line;
        while((line = reader.readLine()) != null ){
            String[] arr = line.split("-");
            Employee emp = new Employee();
            emp.ccode = Integer.parseInt(arr[0]);
            emp.cus_name = arr[1];
            emp.phone = arr[2];
            employees.add(emp);
        }
        return employees;
    } catch (IOException ex) {
        Logger.getLogger(TestMusic.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
}

Answer 1

This approach is not the best one, but might solve your problem. to be used for java versions < 8. The approach is to parse the file to get no. of lines, to create the employee array, and parse again to get data of all the individual employees

public static void main(String[] args) {
   int empSize = getNumberOfEmployees("employees.txt");
   employees = new Employee[empSize]; 
   employees = read("employees.txt");

    BST bst = new BST();
    for(Employee e : employees){
        bst.insert(e);
    }

}

public static int getNumberOfEmployees (String file) {

    int totalEmp = 0;
    try {
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line;
        while((line = reader.readLine()) != null ) {
            totalEmp ++;
        }
    }catch (IOException e) {
        e.printStackTrace();
    }
    return totalEmp;
}

public static Employee[] read(String file) {
    try {

        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line;
        int i=0;

        while((line = reader.readLine()) != null ){
            String[] arr = line.split("-");
            Employee emp = new Employee();
            emp.ccode = Integer.parseInt(arr[0]);
            emp.cus_name = arr[1];
            emp.phone = arr[2];
            employees[i] = emp;
            i++;
        }
        return employees;
    } catch (IOException ex) {
        Logger.getLogger(TestMusic.class.getName()).log(Level.SEVERE, null, ex);
    }
    return null;
}

Answer 2

Without giving you any code (do it by yourself ;-)):

Parse the file twice:

1. get the number of lines, create an Array based on the number of lines

2. parse the file again, fill the Array

And some Research (keywords BufferedReader and Array) would help you too.

Answer 3

It is unclear from your requirements what you want to do in the following situations:

• one line fails to parse;
• cannot open the file for reading.

Here is a solution which (eww) will just ignore the unparseable entries and return an empty array if the file cannot be parsed:

public final class TestMusic
{
    private static final Employee[] NO_EMPLOYEES = new Employee[0];

    public static void main(final String... args)
    {
        final BST bst = new BST();
        for (final Employee emp: getArray())
            bst.insert(emp);
    }

    private static Employee toEmployee(final String input)
    {
        final String[] arr = input.split["-"];
        final Employee emp = new Employee();

        try {
            emp.ccode = Integer.parseInt(arr[0]);
            emp.cus_name = arr[1];
            emp.phone = arr[2];
            return emp;
        } catch (NumberFormatException | IndexOutOfBoundsException e) {
            return null;
        }
    }

    private static Employee[] getArray()
    {
        final Path path = Paths.get("employees.txt");

        try (
            Stream<String> lines = Files.lines(path);
        ) {
            return lines.map(TestMusic::toEmployee)
                .filter(Objects::nonNull)
                .toArray(Employee[]::new);
        } catch (IOException ignored) {
            return NO_EMPLOYEES;
        }
    }
}

---

Note how this solution does not use an intermediate list at all; instead, it makes use of the Java 8 Stream API.

What is left to do here is to handle errors... That is for you to decide :)

Answer 4

if you want to convert ArrayList to array use the following code:

Employee [] arrayOfEmpolyees = new Employee[employees.size()]
employees.toArray(arrayOfEmpolyees);

Answer 5

That is like doing a step backwards. Java collections (for example the List interface and the ArrayList implementation) have various advantages compared to "plain old" arrays.

The only real advantage of arrays is their reduced overhead - but that is only important when dealing with millions or billions of things to store in a container.

So the real answer is: don't do that. Just keep using List/ArrayList.

But in case you insist, you can of course use arrays - but then you have to add that part that makes ArrayList more convenient: you have to provide code that dynamically "grows" your array once you hit its size limit. That works like this:

• you start with an initial array of size 100 for example
• while populating that array, you keep track of the number of slots "in use"
• when your code wants to add the 101st element, you "grow" the array

Growing works by:

• creating a new array, that has like currentArray.length + 100 capacity
• using System.arraycopy() to move all entries from the old to the new array

Answer 6

Guess the size of the array, for example by taking the size of the file and dividing by 20 (approximately the size of the line in the example you gave). Then read into the array, counting the lines. If the array is full before you have reached the end of the file, allocate a new array double the size, copy everything from the old array to the new array, replace the old array with the new array and continue the same way until done. You can look at the source of ArrayList to see an example of how it is done - basically this is what ArrayList does internally.