多维数组。

Question

class DynamicFieldsException extends Exception {}public class DynamicFields {
 
  private Object[][] fields;
  public DynamicFields(int initialSize) {
    fields = new Object[initialSize][2];
    for(int i = 0; i < initialSize; i++)
      fields[i] = new Object[] { null, null };
  }
  public String toString() {
    StringBuffer result = new StringBuffer();
    for(int i = 0; i < fields.length; i++) {
      result.append(fields[i][0]);
      result.append(": ");
      result.append(fields[i][1]);
      result.append("\n");
    }
    return result.toString();
  }
  private int hasField(String id) {
    for(int i = 0; i < fields.length; i++)
      if(id.equals(fields[i][0]))
        return i;
    return -1;
  }
  private int
  getFieldNumber(String id) throws NoSuchFieldException {
    int fieldNum = hasField(id);
    if(fieldNum == -1)
      throw new NoSuchFieldException();
    return fieldNum;
  }
  private int makeField(String id) {
    for(int i = 0; i < fields.length; i++)
      if(fields[i][0] == null) {
        fields[i][0] = id;
        return i;
      }
    // No empty fields. Add one:
    Object[][]tmp = new Object[fields.length + 1][2];
    for(int i = 0; i < fields.length; i++)
      tmp[i] = fields[i];
    for(int i = fields.length; i < tmp.length; i++)
      tmp[i] = new Object[] { null, null };
    fields = tmp;
    // Reursive call with expanded fields:
    return makeField(id);
  }
  public Object
  getField(String id) throws NoSuchFieldException {
    return fields[getFieldNumber(id)][1];
  }
  public Object setField(String id, Object value)
  throws DynamicFieldsException {
    if(value == null) {
      // Most exceptions don't have a "cause" constructor.
      // In these cases you must use initCause(),
      // available in all Throwable subclasses.
      DynamicFieldsException dfe =
        new DynamicFieldsException();
      dfe.initCause(new NullPointerException());
      throw dfe;
    }
    int fieldNumber = hasField(id);
    if(fieldNumber == -1)
      fieldNumber = makeField(id);
    Object result = null;
    try {
      result = getField(id); // Get old value
    } catch(NoSuchFieldException e) {
      // Use constructor that takes "cause":
      throw new RuntimeException(e);
    }
    fields[fieldNumber][1] = value;
    return result;
  }
  public static void main(String[] args) {
    DynamicFields df = new DynamicFields(3);
    System.out.println(df);
    try {
      df.setField("d", "A value for d");
      df.setField("number", new Integer(47));
      df.setField("number2", new Integer(48));
      System.out.println(df);
      df.setField("d", "A new value for d");
      df.setField("number3", new Integer(11));
      System.out.println(df);
      System.out.println(df.getField("d"));
      Object field = df.getField("a3"); // Exception
    } catch(NoSuchFieldException e) {
      throw new RuntimeException(e);
    } catch(DynamicFieldsException e) {
      throw new RuntimeException(e);
    }
   
  }
} ///:~
fields[i] = new Object[] { null, null };
 开头这段多维看不懂。。   希望达人帮我解释下。

Answer 1

多位数组嘛，首先要确立自己对类型的观念，要知道[[D是double [][]的是double[]的数组。第二，只有初学者和自以为这种用法经典的才用多位数组，真正的多维数组应该用数学+一维数组来代替。

Answer 2

大哥 你先明白的告诉我
那个NULL 给谁的呀。

Answer 3

我个人的理解是，Java 的所谓“多维数组”跟 C/C++ 的“多维数组”还是有本质区别的。在 C/C++ 里，多维数组只是一片连续的内存空间，当你用多维下标来访问某个元素的时候，编译器已经帮你安排好了如何得到具体元素的内存位置；而 Java 语言里，严格说来就没有“多维数组”的概念，只有“一维数组”，而多个一维数组叠用就形成了多维数组的效果。虽然从访问形式上，Java 也是使用多维下标来访问所谓“多维数组”里的一个特定元素，但至少有两个方面可以证明我上面说的“本质区别”：1. Java 中一个“多维数组”并不是一块连续的内存空间，实际上，第一维是一个对象数组，数组的每个元素又是一个“一维数组”对象，依此类推；2. Java 中的“多维数组”在同一维度中不同元素的次维数组长度可以是不同的。请看下面的例子：public class TestArray {    public static void main(String[] args) {
        int len1 = 3;
        Object[][] ar = new Object[len1][];
        for (int i=0; i<len1; i++) {
            int len2 = i + 2;
            ar[i] = new Object[i+2];
            for (int j=0; j<len2; j++) {
                ar[i][j] = null; // “那个NULL给谁的呀...”的答案就在这里
            }
        }
        System.out.println(ar);
    }}例子已经能说明问题了，我就不多说了，在 println() 那行设个断点，看一下变量 ar 的值，就都清楚了。再说个题外话：针对前面说的第 1 条，有一个所谓的“Java 语言高级问题”，问的是 byte[2][100] 和 byte[100][2] 哪种用法更好，标准答案当然是前者好一点。不过我觉得，除非用到“不等长维度的多维数组”，对于等长维度的数组来说，还是甘草兄的“数学+一维数组”最好  ^_^

Answer 4

给的是行。如int【i】【j】数组，int【i】=2；值对应的给第i行的数，第0列的数即int【i】【0】=2.。

Answer 5

fields[i] = new Object[] { null, null }; 
我就是想知道 这2个NULL 是什么意思？

Answer 6

他的意思是i行有2个NULL的值吗？

Answer 7

你声明的不就是2维数组吗？Object[][] fields   当然是两个值了。
fields[i] = new Object[] { null, null }; 和
field[i][0] = new Object[][0]{null,null}是等价的。