How to create public array accessible by all methods, but have user input determine the size of it?

Question

I have multiple arrays whose sizes need to be determined by the user input. These arrays should be accessible in the main method as well as the stepTwo() method. However, I am stuck. The user input doesn't come until the main method, but if I declare the arrays in the main method, then I can't access the arrays in the stepTwo() method. I would prefer not to pass the arrays as parameters to stepTwo() as I tried that before but came up with multiple errors. Any suggestions? See below for complete code:

    public class AssignmentIII
    {       
    public static int numProcesses; // Represents the number of processes
    public static int numResources; // Represents the number of different types of resources

    public static int[] available = new int[numResources]; // Create an emptry matrix for available processes
    public static int[][] allocation = new int[numProcesses][numResources]; // Create an empty allocation matrix nxm
    public static int[][] request = new int[numProcesses][numResources]; // Create an empty request matrix nxm
    public static int[] work = new int[numResources]; // Create an empty work matrix
    public static Boolean[] finish = new Boolean[numProcesses]; // Create an empty finish matrix

    public static void main(String[] args) throws FileNotFoundException
    {
        try
        {
            Scanner scan = new Scanner(System.in);
            Scanner fileScan = new Scanner(new File("input1.txt")); // Create file scanner

            System.out.println("Please enter the total number of processes: ");
            numProcesses = scan.nextInt();
            System.out.println("Please enter the number of different types of resources: ");
            numResources = scan.nextInt();

            // Initialize the available matrix
            for(int i = 0; i < numResources; i++)
            available[i]=fileScan.nextInt();

            // Initialize the allocation matrix
            for(int j = 0; j < numProcesses; j++)
                for(int k = 0; k < numResources; k++)
                    allocation[j][k]=fileScan.nextInt();

            // Initialize the request matrix
            for(int m = 0; m < numProcesses; m++)
                for(int n = 0; n < numResources; n++)
                    request[m][n]=fileScan.nextInt();

            // Print allocation matrix
            System.out.println();
            System.out.println("Allocated");
            for(int i = 0; i < numResources; i++)
            {
                System.out.print("\tR" + i);
            }
            System.out.println();
            for(int j = 0; j < numProcesses; j++)
            {
                System.out.print("P" + j);
                for(int k = 0; k < numResources; k++)
                {
                    System.out.print("\t" + allocation[j][k]);
                }
                System.out.println();
            }

            // Print available matrix
            System.out.println();
            System.out.println("Available");
            for(int i = 0; i < numResources; i++)
            {
                System.out.print("R" + i + "\t");
            }
            System.out.println();
            for(int i = 0; i < numResources; i++)
                System.out.print(available[i] + "\t");
            System.out.println();


            // Print request matrix
            System.out.println();
            System.out.println("Requested");
            for(int i = 0; i < numResources; i++)
                {
                    System.out.print("\tR" + i);
                }
            System.out.println();

            for(int m = 0; m < numProcesses; m++)
            {
                System.out.print("P" + m);
                for(int n = 0; n < numResources; n++)
                {
                    System.out.print("\t" + request[m][n]);
                }
                System.out.println();
            }
            System.out.println();

            // Begin deadlock detection algorithm               
            for(int i = 0; i < numResources; i++) // Intialize Work := Available
                work[i]=available[i];

            for(int j = 0; j < numProcesses; j++) // Check for Allocation != 0 and initialize Finish accordingly
            {
                int sumAllocation = 0;
                for(int i = 0; i < numResources; i++)
                {
                    sumAllocation += allocation[j][i];
                }

                if (sumAllocation != 0)
                    finish[j] = false;
                else finish[j] = true;
            }

            stepTwo();

            }
            catch(FileNotFoundException ex)
            {
            System.out.println("An error has occured. The file cannot be found.");
            }
    }

    public static void stepTwo()
    {
        // Step 2
        // Find an index i where Finish[i] = false & Request[i] <= Work         
        for(int i = 0; i < numProcesses; i++)
        {
            int sumRequests = 0;
            int sumWork = 0;

            // Sum the Request and Work vectors
            for(int k = 0; k < numResources; k++)
            {   
                sumRequests += request[i][k];
                sumWork += work[k];
            }

            if (finish[i] == false && sumRequests <= sumWork)
            {
                finish[i] = true;
                for(int m = 0; m < numResources; m++)
                {
                    work[m] = work[m] + allocation[i][m];
                }

                stepTwo();
            }
            else if (finish[i] == false)
            // Step 4: Print which processes are in a deadlock state
            // Print using P0, P1, ... , Pn format
                System.out.println("P" + i + " is in a deadlock state.");                           
        }
    }
 }

I thought about simply making the arrays 6x6 or with 6 elements, but I have pseudocode for a deadlock detection algorithm that I have to follow. There will be various sets of processes and resources, so the number of elements WILL change and MUST be exact in the arrays. — Morgan4568771
– Morgan4568771, Commented Mar 16, 2015 at 21:05
Note that you don't declare arrays; you declare variables (or fields) that hold references to arrays, create arrays and assign their references to the variables. — Stack Exchange Broke The Law
– Stack Exchange Broke The Law, Commented Mar 16, 2015 at 21:14
I knew it was going to be something simple like this. Yes, this completely solves the problem. — Morgan4568771
– Morgan4568771, Commented Mar 16, 2015 at 21:39

Michał Szynkiewicz · Accepted Answer · 2015-03-16 21:05:57Z

2

Declare the array as you do - "above main", but initialize it after reading in the appropriate size.

Declaration:

public static int[] available;

Initialization:

available = new int[numResources];

answered Mar 16, 2015 at 21:05

Michał Szynkiewicz

7973 silver badges12 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Community · Accepted Answer · 2017-05-23 12:14:22Z

you must initialize the array into de main block, something like this.

public class AssignmentIII
{       
public static int numProcesses; // Represents the number of processes
public static int numResources; // Represents the number of different types of resources


public static int[] available ;
public static int[][] allocation ;
public static int[][] request ;
public static int[] work ;
public static Boolean[] finish ;

public static void main(String[] args) throws FileNotFoundException
{
    try
    {
        Scanner scan = new Scanner(System.in);
        Scanner fileScan = new Scanner(new File("input1.txt")); // Create file scanner

        System.out.println("Please enter the total number of processes: ");
        numProcesses = scan.nextInt();
        System.out.println("Please enter the number of different types of resources: ");
        numResources = scan.nextInt();

      available = new int[numResources]; // Create an emptry matrix for available processes
      allocation = new int[numProcesses][numResources]; // Create an empty allocation matrix nxm
      request = new int[numProcesses][numResources]; // Create an empty request matrix nxm
      work = new int[numResources]; // Create an empty work matrix
      finish = new Boolean[numProcesses]; // Create an empty finish matrix

        // Initialize the available matrix
        for(int i = 0; i < numResources; i++)
        available[i]=fileScan.nextInt();

        // Initialize the allocation matrix
        for(int j = 0; j < numProcesses; j++)
            for(int k = 0; k < numResources; k++)
                allocation[j][k]=fileScan.nextInt();

        // Initialize the request matrix
        for(int m = 0; m < numProcesses; m++)
            for(int n = 0; n < numResources; n++)
                request[m][n]=fileScan.nextInt();

        // Print allocation matrix
        System.out.println();
        System.out.println("Allocated");
        for(int i = 0; i < numResources; i++)
        {
            System.out.print("\tR" + i);
        }
        System.out.println();
        for(int j = 0; j < numProcesses; j++)
        {
            System.out.print("P" + j);
            for(int k = 0; k < numResources; k++)
            {
                System.out.print("\t" + allocation[j][k]);
            }
            System.out.println();
        }

        // Print available matrix
        System.out.println();
        System.out.println("Available");
        for(int i = 0; i < numResources; i++)
        {
            System.out.print("R" + i + "\t");
        }
        System.out.println();
        for(int i = 0; i < numResources; i++)
            System.out.print(available[i] + "\t");
        System.out.println();


        // Print request matrix
        System.out.println();
        System.out.println("Requested");
        for(int i = 0; i < numResources; i++)
            {
                System.out.print("\tR" + i);
            }
        System.out.println();

        for(int m = 0; m < numProcesses; m++)
        {
            System.out.print("P" + m);
            for(int n = 0; n < numResources; n++)
            {
                System.out.print("\t" + request[m][n]);
            }
            System.out.println();
        }
        System.out.println();

        // Begin deadlock detection algorithm               
        for(int i = 0; i < numResources; i++) // Intialize Work := Available
            work[i]=available[i];

        for(int j = 0; j < numProcesses; j++) // Check for Allocation != 0 and initialize Finish accordingly
        {
            int sumAllocation = 0;
            for(int i = 0; i < numResources; i++)
            {
                sumAllocation += allocation[j][i];
            }

            if (sumAllocation != 0)
                finish[j] = false;
            else finish[j] = true;
        }

        stepTwo();

        }
        catch(FileNotFoundException ex)
        {
        System.out.println("An error has occured. The file cannot be found.");
        }
}

public static void stepTwo()
{
    // Step 2
    // Find an index i where Finish[i] = false & Request[i] <= Work         
    for(int i = 0; i < numProcesses; i++)
    {
        int sumRequests = 0;
        int sumWork = 0;

        // Sum the Request and Work vectors
        for(int k = 0; k < numResources; k++)
        {   
            sumRequests += request[i][k];
            sumWork += work[k];
        }

        if (finish[i] == false && sumRequests <= sumWork)
        {
            finish[i] = true;
            for(int m = 0; m < numResources; m++)
            {
                work[m] = work[m] + allocation[i][m];
            }

            stepTwo();
        }
        else if (finish[i] == false)
        // Step 4: Print which processes are in a deadlock state
        // Print using P0, P1, ... , Pn format
            System.out.println("P" + i + " is in a deadlock state.");                           
    }
}

}

but this, is not a recommended way. Because is not the right way for use the static method and static attribute. Furthermore you should use encapsulation. Using a better design and encapsulation method, your code can be improved something like this.

    public class AssignmentIII
{       
    int numProcesses; // Represents the number of processes
    int numResources; // Represents the number of different types of resources
    String filepath;

    int[] available = new int[numResources]; // Create an emptry matrix for available processes
    int[][] allocation = new int[numProcesses][numResources]; // Create an empty allocation matrix nxm
    int[][] request = new int[numProcesses][numResources]; // Create an empty request matrix nxm
    int[] work = new int[numResources]; // Create an empty work matrix
    Boolean[] finish = new Boolean[numProcesses]; // Create an empty finish matrix

    public AssignmentIII(int numResources,int numProcesses, String filepath){
        this.numProcesses = numProcesses;
        this.numResources = numResources;
        this.filepath = filepath;

        available = new int[numResources]; // Create an emptry matrix for available processes
        allocation = new int[numProcesses][numResources]; // Create an empty allocation matrix nxm
        request = new int[numProcesses][numResources]; // Create an empty request matrix nxm
        work = new int[numResources]; // Create an empty work matrix
        finish = new Boolean[numProcesses]; // Create an empty finish matrix
    }

    public void initilizeMatrix() throws FileNotFoundException{
        Scanner fileScan = new Scanner(new File(filepath)); // Create file scanner

        // Initialize the available matrix
        for(int i = 0; i < numResources; i++)
            available[i]=fileScan.nextInt();

        // Initialize the allocation matrix
        for(int j = 0; j < numProcesses; j++)
            for(int k = 0; k < numResources; k++)
                allocation[j][k]=fileScan.nextInt();

        // Initialize the request matrix
        for(int m = 0; m < numProcesses; m++)
            for(int n = 0; n < numResources; n++)
                request[m][n]=fileScan.nextInt();

        fileScan.close();

    }



    public void print(){
        // Print allocation matrix
        System.out.println();
        System.out.println("Allocated");
        for(int i = 0; i < numResources; i++)
        {
            System.out.print("\tR" + i);
        }
        System.out.println();
        for(int j = 0; j < numProcesses; j++)
        {
            System.out.print("P" + j);
            for(int k = 0; k < numResources; k++)
            {
                System.out.print("\t" + allocation[j][k]);
            }
            System.out.println();
        }

        // Print available matrix
        System.out.println();
        System.out.println("Available");
        for(int i = 0; i < numResources; i++)
        {
            System.out.print("R" + i + "\t");
        }
        System.out.println();
        for(int i = 0; i < numResources; i++)
            System.out.print(available[i] + "\t");
        System.out.println();


        // Print request matrix
        System.out.println();
        System.out.println("Requested");
        for(int i = 0; i < numResources; i++)
        {
            System.out.print("\tR" + i);
        }
        System.out.println();

        for(int m = 0; m < numProcesses; m++)
        {
            System.out.print("P" + m);
            for(int n = 0; n < numResources; n++)
            {
                System.out.print("\t" + request[m][n]);
            }
            System.out.println();
        }
        System.out.println();

    }

    // Begin deadlock detection algorithm               
    public void deadLockdetecter(){
        for(int i = 0; i < numResources; i++) // Intialize Work := Available
            work[i]=available[i];

        for(int j = 0; j < numProcesses; j++) // Check for Allocation != 0 and initialize Finish accordingly
        {
            int sumAllocation = 0;
            for(int i = 0; i < numResources; i++)
            {
                sumAllocation += allocation[j][i];
            }

            if (sumAllocation != 0)
                finish[j] = false;
            else finish[j] = true;
        }
    }

    public  void stepTwo()
    {
        // Step 2
        // Find an index i where Finish[i] = false & Request[i] <= Work         
        for(int i = 0; i < numProcesses; i++)
        {
            int sumRequests = 0;
            int sumWork = 0;

            // Sum the Request and Work vectors
            for(int k = 0; k < numResources; k++)
            {   
                sumRequests += request[i][k];
                sumWork += work[k];
            }

            if (finish[i] == false && sumRequests <= sumWork)
            {
                finish[i] = true;
                for(int m = 0; m < numResources; m++)
                {
                    work[m] = work[m] + allocation[i][m];
                }

                stepTwo();
            }
            else if (finish[i] == false)
                // Step 4: Print which processes are in a deadlock state
                // Print using P0, P1, ... , Pn format
                System.out.println("P" + i + " is in a deadlock state.");                           
        }
    }

    public static void main(String[] args) throws FileNotFoundException
    {

        AssignmentIII assignment; 

        String p_filepath;
        int p_numProcesses;
        int p_numResources;

        p_filepath = "inpu1t.txt";

        Scanner scan = new Scanner(System.in);
        System.out.println("Please enter the total number of processes: ");
        p_numProcesses = scan.nextInt();
        System.out.println("Please enter the number of different types of resources: ");
        p_numResources = scan.nextInt();
        scan.close();

        assignment = new AssignmentIII(p_numResources, p_numProcesses, p_filepath);

        try
        {
            assignment.initilizeMatrix();
        }
        catch(FileNotFoundException ex)
        {
            System.out.println("An error has occured. The file cannot be found.");
        }

        assignment.stepTwo();

    }

}

Collectives™ on Stack Overflow

How to create public array accessible by all methods, but have user input determine the size of it?

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related