java - 即使在使用全局静态数组之后，我的数组值在 java 中也在发生变化。如何克服呢？

Question

在这段代码中，我遇到了一些问题，因为我已经使用打印一些值的循环进行了标记。我将它们存储在如上所述的数组中，并尝试在另一个函数中打印这些值。但即使在使用全局数组之后，数组的值也会发生变化。

我无法找出问题所在。请帮帮我。

import java.io.*;
import java.util.*;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

// Java program to print all permutations of a
// given string.
public class test3
{

    static int[] val = new int[100]    ;            //array declaration as global


    public static void main(String[] args)
    {

        System.out.println("An incremented value");
        for(int i=2;i<=2;i++) {
            String p="";
            for(int j=0;j<=i;j++) {
                for(int m=0;m<j;m++) {
                    p=p+"&";
                        }
                for(int m=0;m<i-j;m++) {
                    p=p+"|";
                        }
                 printAllPermutations(p);
                p="";
            }
        }

         System.out.println();

    for(int xy=0;xy<32;xy++)
        System.out.print("["+xy+"]"+"="+val[xy]+"   ");      //trying to print the array
    }


    static void print(char[] temp) {

        String a="";
        System.out.println();
      for (int i = 0; i < temp.length; i++)
      { System.out.print(temp[i]);
            a=a+temp[i];}

      System.out.print(" "+"opr:"+temp.length+"   ");
      final int N = temp.length+1;  

      /*===================CODE PROBLEM PART START=======================*/


      for (int i = 0; i < (1 << N); i++) {                          
        // System.out.println(zeroPad(Integer.toBinaryString(i), N));
         String b=zeroPad(Integer.toBinaryString(i), N)+"";
        // System.out.println("a:  "+a+"  b:"+b);
         char[] arrayA = b.toCharArray();
         char[] arrayB = a.toCharArray();
         StringBuilder sb = new StringBuilder();

         int ii = 0;
         while( ii < arrayA.length && ii < arrayB.length){
             sb.append(arrayA[ii]).append(arrayB[ii]);
             ++ii;
         }

         for(int j = ii; j < arrayA.length; ++j){
             sb.append(arrayA[j]);
         }

         for(int j = ii; j < arrayB.length; ++j){
             sb.append(arrayB[j]);
         }

         //System.out.println(sb.toString());
         try {
            ScriptEngineManager sem = new ScriptEngineManager();
            ScriptEngine se = sem.getEngineByName("JavaScript");
            String myExpression = sb.toString();
           // System.out.print(se.eval(myExpression));

            val[i]=(int)(se.eval(myExpression));   //inserting array value
            System.out.print(val[i]);               //NEED TO HAVE THESE VALUES IN THE 1-D ARRAY


           // System.out.print(val[i]);

         } catch (ScriptException e) {
             System.out.println("Invalid Expression");
             e.printStackTrace();}
      }  
      /*===================CODE PROBLEM PART END========================*/
     //

    }




    //unchangable = rest of the function
    static int factorial(int n) {
      int f = 1;
      for (int i = 1; i <= n; i++)
        f = f * i;
      return f;
    }

    static int calculateTotal(char[] temp, int n) {
      int f = factorial(n);

      // Building HashMap to store frequencies of 
      // all characters.
      HashMap<Character, Integer> hm = 
                       new HashMap<Character, Integer>();
      for (int i = 0; i < temp.length; i++) {
        if (hm.containsKey(temp[i]))
          hm.put(temp[i], hm.get(temp[i]) + 1);
        else
          hm.put(temp[i], 1);
      }

      // Traversing hashmap and finding duplicate elements.
      for (Map.Entry e : hm.entrySet()) {
        Integer x = (Integer)e.getValue();
        if (x > 1) {
          int temp5 = factorial(x);
          f = f / temp5;
        }
      }
      return f;
    }

    static void nextPermutation(char[] temp) {

      // Start traversing from the end and
      // find position 'i-1' of the first character 
      // which is greater than its  successor. 
      int i;
      for (i = temp.length - 1; i > 0; i--)
        if (temp[i] > temp[i - 1])
          break;

      // Finding smallest character after 'i-1' and
      // greater than temp[i-1]
      int min = i;
      int j, x = temp[i - 1];
      for (j = i + 1; j < temp.length; j++)
        if ((temp[j] < temp[min]) && (temp[j] > x))
          min = j;

      // Swapping the above found characters.
      char temp_to_swap;
      temp_to_swap = temp[i - 1];
      temp[i - 1] = temp[min];
      temp[min] = temp_to_swap;

      // Sort all digits from position next to 'i-1'
      // to end of the string.
      Arrays.sort(temp, i, temp.length);

      // Print the String
      print(temp);
    }

    static void printAllPermutations(String s) {

      // Sorting String
      char temp[] = s.toCharArray();
      Arrays.sort(temp);

      // Print first permutation
      print(temp);

      // Finding the total permutations
      int total = calculateTotal(temp, temp.length);
      for (int i = 1; i < total; i++)
        nextPermutation(temp);
    }

    static String zero(int L) {                                      
          return (L <= 0 ? "" : String.format("%0" + L + "d", 0));      
       }                                                               
    static String zeroPad(String s, int L) {                        
          return zero(L - s.length()) + s;                              
       } 

}

我得到的输出是

 An incremented value

      || opr:2   01111111     //WANT TO STORE THESE 32 VALUES IN 1 D ARRAY 
      &| opr:2   01010111      // AND PRINT THEM OUT 
      |& opr:2   00011111     
      && opr:2   00000001      

[0]=0   [1]=0   [2]=0   [3]=0   [4]=0   [5]=0   [6]=0   [7]=1   [8]=0   [9]=0   [10]=0   [11]=0   [12]=0   [13]=0   [14]=0   [15]=0   [16]=0   [17]=0   [18]=0   [19]=0   [20]=0   [21]=0   [22]=0   [23]=0   [24]=0   [25]=0   [26]=0   [27]=0   [28]=0   [29]=0   [30]=0   [31]=0 

我需要做的是将这 32 个值存储在 1 D 数组中以供进一步操作，但在执行此操作时，除了 [7] 之外，所有数组值仅显示 0。我不知道这里发生了什么事。

Answer 1

引用类型不绑定(bind)到局部作用域，仅仅因为您的数组对于类来说是静态的，并不意味着更改一个函数中的值不会更改实际数组中的值。作为参数对数组的引用将是一个副本，但该引用仍然“指向”实际对象，该对象不是绑定(bind)到本地范围的副本。

如果你想保存数组的两​​种不同状态，你必须自己保存它们。