Java code Optimization and Safe

Question

class Testing{
    private static int counter;
    private static int[] intArray;
    public static ReturnClassName className(File f){
        ReturnClassName returnCN= new ReturnClassName();
        byte[] b;
        try{
            DataInputStream dataIStream= new DataInputStream(new FileInputStream(f));
            intArray= new int[dataIStream.available()];
            b= new byte[dataIStream.available()];
            dataIStream.read(b);
            intArray= b;
            // setting methods for ReturnClassName 
            // counter increment
            returnCN.setNumber(someMethod(5));
            }//catch() block

    return returnCN;
}
private static int[] someMethod(int l){
    return Arrays.copyOfRange(intArray, counter, counter + l);
}

Or

class Testing{
    private static int counter;
    public static ReturnClassName className(File f){
        ReturnClassName returnCN= new ReturnClassName();
        byte[] b;
        try{
            DataInputStream dataIStream= new DataInputStream(new FileInputStream(f));
            intArray= new int[dataIStream.available()];
            b= new byte[dataIStream.available()];
            dataIStream.read(b);
            intArray= b;
            // setting methods for ReturnClassName 
            // counter increment
            returnCN.setNumber(someMethod(intArray,5));

    }//catch() block

    return returnCN;
}

private static int[] someMethod(int[] iArray, int l){

    return Arrays.copyOfRange(iArray, counter, counter + l);
}

I want to know which one is more optimized and safe of the above two codes. Also while passing the array in the 2nd code, is it passing the whole array or just the address of that array. Like both intArray and iArray are pointing to the same integer array?

Answer 1

Arrays are passed by reference so both snippets are equivalent concerning efficiency except for the fact that if you are not using intArray for some other purpose: The second version will unreference the array and make it a candidate for garbage collection.

This is, in the second case, the array will be a candidate to be collected as soon as someMethod execution returns whereas the first version will keep the array referenced until the program ends since it is static.

From your comments I understand that you will call className once per file for different files and for each file you will call 'someMethod' many times. Then I like a solution similar to the firstone at some points but different to both the first and the second one.

That solution is to have a instance of Testing for each file you load data from:

1. Force each instance to be associated with a concrete file.
2. Make methods and attributes not static. This is for each Testing element to have its own data loaded from its file.
3. Change className so it will load data from its file only once.

4. Make a right user of Testing and its instances.

   class Testing{
   
       public Testing(File f)
       {
           this.f = f;
       }
   
       private File f;
       private int[] intArray;
       public static ReturnClassName className(){
           ReturnClassName returnCN= new ReturnClassName();
           byte[] b;
           if(intArray == null || intArray.length > 0) return //If it was called before, then we don't load the file again.
           {
               try{
                   DataInputStream dataIStream= new DataInputStream(new FileInputStream(f));
                   intArray= new int[dataIStream.available()];
                   b = new byte[dataIStream.available()];
                   dataIStream.read(b);
                   intArray= b;
                   // setting methods for ReturnClassName 
                   // counter increment
               } catch(Exception e) { 
               ...
               ...
               }
           }
           returnCN.setNumber(someMethod(5));
           return returnCN;
       }
   
       private int[] someMethod(int l){
           return Arrays.copyOfRange(intArray, counter, counter + l);
       }
   }
   

Example of use:

Testing forFile1 = new Testing(fileObj01);
ReturnClassName x = ReforFile1.className();
ReturnClassName y = ReforFile1.className();

Testing forFile2 = new Testing(fileObj02);
ReturnClassName z = ReforFile2.className();
ReturnClassName w = ReforFile2.className();

You could, on the other hand, implement a better solution were you have a map of integer arrays indexed by the input file (like a cache) and you keep a copy if their bytes on it. Having thus a single instance od Testing and keep File f as input parameter for 'className'.