blocks|key|1339672|text|Ye+olde+(引用)数组不能很好地处理泛型。在这种情况下，数组也可能是低效的。您正在创建数组的数组，因此存在不必要的间接和边界检查。最好是创建一个Matrix<T>类。您可能还希望向Matrix添加一个对表示零的T实例的引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1339673|entityMap^0|23|9|2L|6|30|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

Ye olde (reference) arrays do not play well with generics. In this case arrays are also likely to be inefficient. You are creating an array of arrays, so there is unnecessary indirection and bounds checking. Better to make a class <code>Matrix&lt;T&gt;</code>. You may also want to add to the <code>Matrix</code> an reference to an instance of <code>T</code> that represents a zero.

blocks|key|1339768|text|泛型和数组不能很好地匹配。不允许创建泛型数组，因为它不是类型安全的。这源于这样一个事实:如果Sub是Super的子类型，那么Sub[]就是Super[]的子类型，这与泛型类型不同；对于任何两个不同的类型Type1和Type2，List既不是List的子类型，也不是List的超类型。(Effective+Java在第5章第25项中介绍了这一点)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1339769|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Generics and arrays don't match very well. Creating a generic array is not allowed since it would not be typesafe. It stems from the fact that if Sub is a subtype of Super, then Sub[] is a subtype of Super[], which is not the case of generic types; for any two distinct types Type1 and Type2, List is neither a subtype or a supertype of List. (Effective Java covers this in chapter 5, item 25).

blocks|key|1339829|text|Java使用擦除来实现泛型意味着您在创建泛型类型时会遇到麻烦。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1339830|使用null来表示0怎么样？|1339831|retVal[i][j]+=+null;|code-block|syntax|javascript|1339832|然后，您可以在以后将所需的任何类型分配给数组。|1339833|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Java's use of erasure to implement generics means that you're going to have trouble new'ing a generic type.

How about using null to represent 0

<pre><code>retVal[i][j] = null;
</code></pre>

You can then assign any type you want to the array later on.

blocks|key|1339916|text|在Java中，该类型在运行时被擦除，因此您需要传入另一个参数来在运行时获取该类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1339917|它可以是初始化数组的值，也可以是要使用的类。|1339918|如果您选择传入类，那么使用一个类到值的映射来为每个类型存储一个零值。|1339919|然后，您可以使用java.util.Arrays.fill填充数组：|offset|length|style|CODE|1339920|private+static+HashMap<Class<?>,+Object>+ZEROS+=+new+HashMap<Class<?>,Object>();

static+{
++++ZEROS.put(+Integer.class,+Integer.valueOf(0)+);
++++...
}

private+static+<T+extends+Number>+T[][]+zeroMatrix+(+Class<T>+type,+int+rows,+int+cols+)+{
++++@SuppressWarnings("unchecked")
++++T[][]+++matrix++=+(T[][])+java.lang.reflect.Array.newInstance(type,+rows,+cols);
++++Object++zero++++=+ZEROS.get(type);

++++for+(+T[]+row+:+matrix+)+
++++++++java.util.Arrays.fill(row,zero);

++++return+matrix;
}

Integer[][]+matrix+=+zeroMatrix+(Integer.class,+10,+10);|code-block|syntax|javascript|1339921|但是，如果性能是一个远程问题，您就不希望对数值代码使用盒装的值。|1339922|你真的不想尝试用null代替零-这会使你代码中所有其他路径的复杂度增加三倍。尽管您可以使用一个数字支持类来提供各种盒装数字类型的加法和乘法，但与提供两个或三个原始矩阵和几个大数字矩阵相比，您节省的复杂性将非常小，特别是如果您使用模板系统(例如ant的replace任务或XSLT)来生成源代码。|1339923|entityMap^0|0|0|0|8|L|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@$H|10|I|11|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

In Java the type is erased at runtime, so you need to pass in another argument to get the type at runtime.

That could either be the value to initialise the arrays with, or the class to use.

If you choose to pass in the class, then have a Map of class to value to store a zero value for each type.

You then can use <code>java.util.Arrays.fill</code> to fill the array:

<pre><code>private static HashMap&lt;Class&lt;?&gt;, Object&gt; ZEROS = new HashMap&lt;Class&lt;?&gt;,Object&gt;();

static {
 ZEROS.put( Integer.class, Integer.valueOf(0) );
 ...
}

private static &lt;T extends Number&gt; T[][] zeroMatrix ( Class&lt;T&gt; type, int rows, int cols ) {
 @SuppressWarnings("unchecked")
 T[][] matrix = (T[][]) java.lang.reflect.Array.newInstance(type, rows, cols);
 Object zero = ZEROS.get(type);

 for ( T[] row : matrix ) 
 java.util.Arrays.fill(row,zero);

 return matrix;
}

Integer[][] matrix = zeroMatrix (Integer.class, 10, 10);
</code></pre>

However, if performance is remotely a concern you don't want to be using boxed values for numeric code.

You really don't want to try and use null for zero - it will treble the complexity of all other paths in your code. Although you might get away with a numeric support class which would provide addition and multiplication of the various boxed number types, the amount of complexity you save will be very little compared with providing two or three primitive matrices and a couple of big-number ones, particularly if you use a templating system (eg ant's replace task or XSLT) to generate the source code.

blocks|key|1339955|text|我认为你在打一场失败的战争。即使你解决了这个问题，你打算如何解决加法、减法等问题呢？number类不是一个非常有用的超类，唯一有用的方法是doubleValue()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1339956|零可以被定义为加法中的恒等式或乘法中的零，但如果没有加法或乘法的通用定义，则不太可能有零的通用定义。|1339957|如果你想要这样，那么你可能会更好地坚持使用BigDecimal，但当然，这会带来相关的性能损失。|1339958|另一个显而易见的选择是让数组初始化为null，然后更改您的其他代码，将null视为零。|1339959|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I think you are fighting a losing battle. Even if you solve this, how are you planning on solving addition, subtraction etc? The number class is not a very useful superclass, and about the only useful method is doubleValue().

Zero can be defined as the identity in addition or a zero in multiplication, but without a generic definition of addition or multiplication, a generic definition of zero is unlikely.

If you want this then you might be better just sticking with BigDecimal for everything, but of course that will have associated performance penalties.

The other obvious option would be to leave the array with null initialisation, and then change your other code to treat null as zero.

blocks|key|1555599|text|它应该是null而不是零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1555600|如果你想为对象T放入等价的0，你需要提供一个T的工厂。类似这样：|1555601|interface+Factory<T>+{
+++T+getZero();+++++
}|code-block|syntax|javascript|1555602|你应该把这个方法写成这样：|1555603|private+<T>+T[][]+zeroMatrix(int+row,+int+col,+Factory<T>+factory)+{
++++T[][]+retVal+=+(T[][])new+Object[row][col];
++++for(int+i+=+row;+i+<+row;+i%2B%2B)+{
++++++++for(int+j+=+col;+j+<+col;+j%2B%2B)+{
++++++++++++retVal[i][j]+=+factory.getZero();
++++++++}
++++}

++++return+retVal;
}|1555604|您还应该为工厂提供适当的实现：|1555605|+class+IntegerFactory+implements+Factory<Integer>+{
++++Integer+getZero()+{
+++++++return+new+Integer(0);
++++}
}|1555606|通常，您也会将getMatrix(int+row,+int+column)放在工厂实现中，以便实际返回正确的类型化数组。|offset|length|style|CODE|1555607|entityMap^0|0|0|0|0|0|0|0|7|U|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@$S|16|T|17|U|V]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

it should be null instead of zero. 

If you want to actually put in there the equivalent 0 for object T you will need to provide a factory of T. Something like this:

<pre><code>interface Factory&lt;T&gt; {
 T getZero(); 
}
</code></pre>

and you should make the method like this:

<pre><code>private &lt;T&gt; T[][] zeroMatrix(int row, int col, Factory&lt;T&gt; factory) {
 T[][] retVal = (T[][])new Object[row][col];
 for(int i = row; i &lt; row; i++) {
 for(int j = col; j &lt; col; j++) {
 retVal[i][j] = factory.getZero();
 }
 }

 return retVal;
}
</code></pre>

You should also have proper implementations for the factory:

<pre><code> class IntegerFactory implements Factory&lt;Integer&gt; {
 Integer getZero() {
 return new Integer(0);
 }
}
</code></pre>

Normally you would put the <code>getMatrix(int row, int column)</code> in the factory implementation too in order to actually return a proper typed array.

blocks|key|1555674|text|需要考虑的是，泛型只在编译时用于类型安全检查。这些信息会在运行时丢失，因此您不能在retVali+=0上使用自动装箱；因为Java不能自动装箱来输入数字或对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1555675|如果你传入你想要设置的值，它将会工作。下面是一个快速示例：|1555676|private+<T>+T[][]+fillMatrix(int+row,+int+col,+T+value)+{
++++T[][]+retVal+=+(T[][])new+Object[row][col];
++++for(int+i+=+0;+i+<+row;+i%2B%2B)+{
+++++++for(int+j+=+0;+j+<+col;+j%2B%2B)+{
++++++++++retVal[i][j]+=+value;
+++++++}
++++}
++++return+retVal;
}|code-block|syntax|javascript|1555677|顺便说一句，for(int+=+row；i<+row；i%2B%2B)和for(int+j=+col；j<+col；j%2B%2B)永远不会循环，所以你的代码有另一个问题。|1555678|编辑:您不能将结果转换为Object以外的其他类型，因为这是实际的数组类型。|1555679|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You need to consider that generics are only used at compile-time for type safety checking. This information is lost at runtime so you can't use auto-boxing on retVal[i][j] = 0; since Java can't auto-box to type Number or Object.

If you pass in the value you want to set, it will work. Here's a quick sample:

<pre><code>private &lt;T&gt; T[][] fillMatrix(int row, int col, T value) {
 T[][] retVal = (T[][])new Object[row][col];
 for(int i = 0; i &lt; row; i++) {
 for(int j = 0; j &lt; col; j++) {
 retVal[i][j] = value;
 }
 }
 return retVal;
}
</code></pre>

Btw, for(int i = row; i &lt; row; i++) and for(int j = col; j &lt; col; j++) will never loop so there's another problem with your code.

edit:
You won't be able to cast the result to something other than Object[][] though because that's the actual array type.

blocks|key|1340895|text|如果你真的想使用泛型，你可以这样做|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340896|private+<T+extends+Number>+T[][]+zeroMatrix(int+row,+int+col,+Class<T>+clazz)+throws+InstantiationException,+IllegalAccessException,
++++++++IllegalArgumentException,+InvocationTargetException
{
++++T[][]+retVal+=+(T[][])+Array.newInstance(clazz,+new+int[]+{+row,+col+});
++++for+(int+i+=+0;+i+<+row;+i%2B%2B)
++++{
++++++++for+(int+j+=+0;+j+<+col;+j%2B%2B)
++++++++{
++++++++++++Constructor<T>+c+=+clazz.getDeclaredConstructors()[0];
++++++++++++retVal[i][j]+=+c.newInstance("0");
++++++++}
++++}

++++return+retVal;
}|code-block|syntax|javascript|1340897|示例：|1340898|zeroMatrix(12,+12,+Integer.class);|1340899|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you really want to use generics, you could do something like this

<pre><code>private &lt;T extends Number&gt; T[][] zeroMatrix(int row, int col, Class&lt;T&gt; clazz) throws InstantiationException, IllegalAccessException,
 IllegalArgumentException, InvocationTargetException
{
 T[][] retVal = (T[][]) Array.newInstance(clazz, new int[] { row, col });
 for (int i = 0; i &lt; row; i++)
 {
 for (int j = 0; j &lt; col; j++)
 {
 Constructor&lt;T&gt; c = clazz.getDeclaredConstructors()[0];
 retVal[i][j] = c.newInstance("0");
 }
 }

 return retVal;
}
</code></pre>

Example:

<pre><code>zeroMatrix(12, 12, Integer.class);
</code></pre>

blocks|key|1556511|text|我提出了一个related+question+which+also+asked+about+performance+issues，它引用了您的问题。大家的共识是，重构到泛型会对性能造成相当大的影响，所以如果这很重要，你应该坚持使用原生类型(对我来说确实如此)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1556512|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1409432/refactoring-java-arrays-and-primitives-double-to-collections-and-generics/1409505#1409505^0|6|1M|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I raised a <a href="https://stackoverflow.com/questions/1409432/refactoring-java-arrays-and-primitives-double-to-collections-and-generics/1409505#1409505">related question which also asked about performance issues</a> which referenced your question. The consensus was clear that refactoring to Generics had a considerable performance hit and so you should stick with primitives if this matters (for me it does).

In an attempt to see if I can clean up some of my math code, mostly matrix stuff, I am trying to use some Java Generics. I have the following method:

<pre><code>private &lt;T&gt; T[][] zeroMatrix(int row, int col) {
 T[][] retVal = (T[][])new Object[row][col];
 for(int i = row; i &lt; row; i++) {
 for(int j = col; j &lt; col; j++) {
 retVal[i][j] = 0;
 }
 }
 return retVal;
}
</code></pre>

The line retVal[i][j] = 0 is the one causing me headaches. The goal of the line is to initialize the array with the T representation of 0. I've attempted to do all sorts of things with it: (T is defined in the class as T extends Number)

<pre><code>retVal[i][j] = (T)0;
retVal[i][j] = new T(0);
</code></pre>

The only thing that works is 

<pre><code>retVal[i][j] = (T)new Object(0);
</code></pre>

Which is not what I want.

Is this possible? Is there an easier way to represent an NxM matrix of any type of Number(including potentially BigDecimal), or am I stuck?

Java Generics and numbers

Java

为了看看我是否可以清理一些数学代码，主要是矩阵方面的东西，我尝试使用一些Java泛型。我有以下方法：private <T> T[][] zeroMatrix(int row, int col) { T[][] retVal = (T[][])new Object[row][col]; for(int i =...

问Java泛型和数字
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java泛型和数字EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java泛型和数字
EN