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類型,這樣會報錯