A. java泛型类求数组最小值最大值和平均值
应该能给你带来帮助
public class NumFunc<T extends Number> {
T[] a;
NumFunc(T[] a) {
this.a = a;
}
/**
* 最小值
* @return 最小值
*/
public T minValue() {
T min = this.a[0];
for (int i = 1; i < this.a.length; i++){
if (a[i].toString().compareTo(min.toString())<0){
min = a[i]; // 未对参数类型 T, T 定义运算符 <
}
}
return min;
}
/**
* 最大值
* @return 最大值
*/
public T maxValue() {
T max = this.a[0];
for (int i = 1; i < this.a.length; i++)
if (a[i].toString().compareTo(max.toString())>0){
max = a[i]; // 未对参数类型 T, T 定义运算符 <
}
return max;
}
/**
* 平均值
* @return 平均值
*/
@SuppressWarnings("unchecked")
public T aveValue() {
//没有特别好的方法，你先用这个方法逐一些吧：Byte、Double、Float、Integer、Long、Short
if (this.a instanceof Double[]) {
Double ave=0.0;
for (int i = 0; i < this.a.length; i++)
ave+=Double.valueOf(a[i].toString());
ave=ave/this.a.length;
return (T)ave;
}
if (this.a instanceof Integer[]) {
Double ave=0.0;
for (int i = 0; i < this.a.length; i++)
ave+=Integer.valueOf(a[i].toString());
ave=ave/this.a.length;
return (T)ave;
}
//.....
return null;
}
public static void main(String[] args) {
Integer[] i = { 9, 1, 2, 5, };
Double[] d = { 1.0, 1.1111 };
NumFunc<Integer> v = new NumFunc<Integer>(i);
NumFunc<Double> vs = new NumFunc<Double>(d);
System.out.println("最小值：" + vs.minValue());
System.out.println("最大值：" + vs.maxValue());
System.out.println("平均值：" + v.aveValue());
System.out.println("平均值：" + vs.aveValue());
}
}
B. 请问，Java中，泛型数组的数组怎么初始化（就是ArrayList数组）
既然你暗示就是ArrayList了，
首选就从Arraylist想了
可以试试:
import java.util.ArrayList;
public class Test{
public static void main(String[]args){
ArrayList<ArrayList<Integer>> als = new ArrayList<ArrayList<Integer>> ();
ArrayList<Integer> a1 = new ArrayList<Integer>();
ArrayList<Integer> a2 = new ArrayList<Integer>();
ArrayList<Integer> a3 = new ArrayList<Integer>();
ArrayList<Integer> a4 = new ArrayList<Integer>();
//下面是添加行，你可以用循环添加固定的行
//每一列就是一个ArrayList<Integer>，你可以任意添加，长度不固定吧
als.add(a1);
als.add(a2);
als.add(a3);
als.add(a4);
System.out.println(als.size());
}
}
tao_3000的方法可行，只是Integer[]创建时要指定维数
可以自己写个算法自动增加维数
对于你说的数据量问题，个人理解是这样的：
达到了几十万几百万的数据量的时候，我想大概就是从数据库中吧数据读取出来，进行批量的处理或者更新之类的操作。
你说得很对，如此庞大的数据量肯定会使效率降低，
但是我们完全可以一次从数据库中读取几百条记录，进行操作
关于如何从数据库中一次读取很少的记录，jdbc和hibernate都有相应的实现
在者，数据量过大，呵呵，JVM可能崩溃哦 *_*
C. java 如何用泛型表示继承了Comparable接口的类的数组
数组没有泛型，直接Comparable[] aaa; 就可以了
D. java中什么叫泛型
泛型。规定了此集合中元素的类型。例如：
ArrayList<Integer> arr = new ArrayList<Integer> ();
这样就创建了一个包含整数的 ArrayList 对象。
如果要自己定义泛型类，就用如下形式：
class MyCollection<E> {...}
尖括号中的类型可以有限制，例如你需要让 MyCollection 中的类型都具有可比性，可以用如下格式：
class MyCollection<E extends Comparable> {...}
此外，要注意泛型的一些特性：
1. 不能直接创建泛型数组。如 new ArrayList<Integer>[5] 之类的是错的。只能用如下方法：new ArrayList[5] 或者 (ArrayList<Integer>[])new ArrayList[5];
2. 静态方法中需要小心，因为 E 一般是非静态类型，如果你这样写：
class MyCollection<E> {
public static MyCollection<E> abc() {
......
}
}
是错的。你只能把 <E> 去掉。
E. java的类型参数是什么意思
楼上说得不错，我补充一下参数 方法 类型
static void array(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
static String clearProperty(String key)
移除指定键指示的系统属性。
static long currentTimeMillis()
返回以毫秒为单位的当前时间。
static void exit(int status)
终止当前正在运行的 Java 虚拟机。
static void gc()
运行垃圾回收器。
static Map<String,String> getenv()
返回一个不能修改的当前系统环境的字符串映射视图。
static String getenv(String name)
获得指定的环境变量值。
static Properties getProperties()
确定当前的系统属性。
static String getProperty(String key)
获得指定键指示的系统属性。
static String getProperty(String key, String def)
获得用指定键描述的系统属性。
static SecurityManager getSecurityManager()
获得系统安全接口。
static int identityHashCode(Object x)
返回给定对象的哈希码，该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()。
static Channel inheritedChannel()
返回从创建此 Java 虚拟机的实体中继承的信道。
static void load(String filename)
从作为动态库的本地文件系统中以指定的文件名加载代码文件。
static void loadLibrary(String libname)
加载由 libname 参数指定的系统库。
static String mapLibraryName(String libname)
将一个库名称映射到特定于平台的、表示本机库的字符串中。
static long nanoTime()
返回最准确的可用系统计时器的当前值，以毫微秒为单位。
static void runFinalization()
运行处于挂起终止状态的所有对象的终止方法。
static void runFinalizersOnExit(boolean value)
已过时。 该方法具有固有的不安全性。它可能对正在使用的对象调用终结方法，而其他线程同时正在操作这些对象，从而导致不正确的行为或死锁。
static void setErr(PrintStream err)
重新分配“标准”错误输出流。
static void setIn(InputStream in)
重新分配“标准”输入流。
static void setOut(PrintStream out)
重新分配“标准”输出流。
static void setProperties(Properties props)
将系统属性设置为 Properties 参数。
static String setProperty(String key, String value)
设置指定键指示的系统属性。
static void setSecurityManager(SecurityManager s)
设置系统安全性。
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
F. JAVA怎么初始化泛型数组
首先由于Java泛型的实现，不可以使用如下的代码：
public class GenSet<E> {
private E a[];
public GenSet() {
a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
}
}
那么我们如何在保持类型安全的同时实现这一点？
我在Java论坛上看到了这样的解决方案：
import java.lang.reflect.Array;
class Stack<T> {
public Stack(Class<T> clazz, int capacity) {
array = (T[])Array.newInstance(clazz, capacity);
}
private final T[] array;
}
在这里，我们需要讨论"checked" and "unchecked"。
Checked：strong typing。GenSet明确知道它包含的对象类型（即它的构造函数是使用Class <E>参数显式调用的，当方法传递非类型E的参数时，方法将抛出异常。请参阅Collections.checkedCollection。
在这种情况，我们需要这样写：
public class GenSet<E> {
private E[] a;
public GenSet(Class<E> c, int s) {
// Use Array native method to create array
// of a type only known at run time
@SuppressWarnings("unchecked")
final E[] a = (E[]) Array.newInstance(c, s);
this.a = a;
}
E get(int i) {
return a[i];
}
}
Unchecked: weak typing。实际上没有对作为参数传递的任何对象进行类型检查。
在这种情况，我们需要这样写：
public class GenSet<E> {
private Object[] a;
public GenSet(int s) {
a = new Object[s];
}
E get(int i) {
@SuppressWarnings("unchecked")
final E e = (E) a[i];
return e;
}
}
请注意，数组的组件类型应该是类型参数的擦除：
public class GenSet<E extends Foo> { // E has an upper bound of Foo
private Foo[] a; // E erases to Foo, so use Foo[]
public GenSet(int s) {
a = new Foo[s];
}
...
}
所有的这些都源于Java中泛型一个的特性但也是一个weakness：它是使用擦除实现的，因此除非实施一些显式机制（type-checking），否则“泛型”类不知道它们在运行时创建的类型参数，故无法提供 type-safety。
G. 请教关于java的泛型方法
编译器判断泛型方法的实际类型参数的过程叫做类型推断,类型推断的实现方法是一种非常复杂的过程.
根据调用泛型方法时实际传递的参数类型或返回值类型来推断,具体规则如下:
如果某类型变量只在方法参数列表或返回值的一处被调用了,那根据调用该方法时该处的实际类型来确定,即直接根据调用方法时传递的实际类型或方法返 回值的类型来确定泛型方法的参数类型.例如: swap(new String[3],3,4) --->static <E> void swap(E[] a,int i,int t)
当某个类型变量在方法的参数列表和返回值中被多次利用了,而且在调用方法时这多处的实际类型又是一样的,那么这也可以很明显的知道此泛型方法的参数类型.例如: add(3,5) --> static <T> T add(T a,T b)
当 某个类型变量在方法的参数列表和返回值中被多次利用了,而且在调用方法时这多处的实际类型又对应不同的类型,且返回值是void,那么这时取多处实际变量 类型的最大交集.例如: fill(new Integer[3],3.5f) --> static <T> void fill(T[] a,T i) ,此时T为Number,编译不会报错,但运行有问题.
当某个类型变量在方法的参数列表和返回值中被 多次利用了,且返回值不为空,在调用方法时这多处的实际类型又对应不同的类型,那么优先考虑返回值的类型.int x = add(3,3.5f) --> static <T> T add(T a,T b)
参数类型的类型推断具有传递性,
(new Integer[5],new String[5]) --> static <T> void (T[] a, T[] b) T为Object类型,没有问题
(new Vector<String>(),new Integer[5]) --> static <T> void (Collection<T> a, T[] b) 在new Vector<String>()时决定了T为String类型,而new Integer[5]不是String类型,这样会报错