當前位置：首頁 » 編程語言 » java數組泛型

java數組泛型

發布時間: 2021-03-24 21:29:14

⑴ java為什麼不支持泛型數組

由於JVM泛型的擦除機制，在運行時JVM是不知道泛型信息的，所以可以給oa[1]賦上一個ArrayList<Integer>而不會出現ArrayStoreException，但是在取出數據的時候卻要做一次類型轉換，所以就會出現ClassCastException，如果可以進行泛型數組的聲明，上面說的這種情況在編譯期將不會出現任何的警告和錯誤，只有在運行時才會出錯。而對泛型數組的聲明進行限制，對於這樣的情況，可以在編譯期提示代碼有類型安全問題，比沒有任何提示要強很多。
基於以上的原因，Java不支持聲明泛型數組，更確切地表達是：數組的類型不可以是類型變數，除非是採用通配符的方式，

⑵ 關於java的泛型創建類型變數的數組對象

你好，在java中,不能通過直接通過T[] tarr=new T[3]的方式來創建數組,最簡單的方式便是通過Array.newInstance(Class<t>type,int size)的方式來創建數組 ,可以參考如下代碼，
public static <T> T[] newArrayByArrayClass(Class<T[]> clazz, int length) {
return (T[]) Array.newInstance(clazz.getComponentType(), length);
}

⑶ java 泛型數組



importjava.util.ArrayList;
importjava.util.List;

publicclassTest
{
	publicstaticvoidmain(Stringargs[])
	{
		List<?>[]lsa=newArrayList<?>[10];
		Object[]oa=(Object[])lsa;
		List<Integer>li=newArrayList<Integer>();
		li.add(newInteger(3));
		oa[1]=li;
		Objecttarget=lsa[1].get(0);
		if(targetinstanceofInteger)
		{
			Integers=(Integer)target;
			System.out.println(s);
		}
	}
}

⑷ java中怎麼把數組的值賦到arraylist泛型集合中

以String 數組舉例吧：
String[] s = {"a","b","c"};
List<String> list = new ArrayList <String> ();
for(int i = 0;i < s.length;i++){
list.add(s[i]);
}

⑸ 怎麼在java中用泛型介面實現數組的增刪改查

// 定義介面 public interface SyUsersService {

/***新增用戶*/
public void addSyUser(SyUsers syUsers);

/***根據用戶名得到用的注冊信息***/
public SyLeaguer isRightPasswordProtect(SyLeaguer syLeaguer);

/***更新用戶的密碼***/
public void updateSyUserPassword(SyUsers syUsers);

/***用戶登錄驗證***/
public boolean checkSyUserLogin(SyUsers syUsers);
/**
* 更新用戶狀態 * @param loginName 登錄名 * @param state 狀態號 0/1
* @return 是否更新成功 true/flase
*/
public boolean updateSyUserState(String loginName,Integer state);
/**
* 分頁查詢用戶信息
* @param pageNo 頁號
* @param pageSize 頁面大小
* @param hqlQueryRule 查詢規則
* @return Page 分頁查詢對象
*/
public Page querySyUserPage(int pageNo,int pageSize,HqlQueryRule hqlQueryRule);

/**
* 更新用戶密碼
* @param loginName 登錄名 * @param oldPassword 舊的密碼
* @param newPassword 新的密碼
*/
public void updateSyUserPassword(String loginName,String oldPassword,String newPassword);

/**
* 根據查詢規則查詢用戶
* @see HqlQueryRule
* @param hqlQueryRule 查詢規則
* @return 結果集列表 */
public List querySyUser(HqlQueryRule hqlQueryRule);

/**
* 根據登錄名獲取用戶信息 * @param loginName
* @return
*/
public SyUsers getSyUserByLoginName(String loginName);

/**
* 根據登錄名獲取用戶信息
* @param loginName
* @return
*/
public boolean isRepeatUser(String loginName);

/**
* 更新用戶
* @param loginName
* @return
*/
public void updateSyUsers(SyUsers syUsers);
}
// 實現介面 public class SyUsersServiceImp extends
org.springframework.orm.hibernate3.support.HibernateDaoSupport
implements SyUsersService {

protected static final Log logger = LogFactory.getLog(SyUsersServiceImp.class); public SyUsersServiceImp() {}

/***用戶注冊添加用戶***/
public void addSyUser(SyUsers syUsers) {
this.getHibernateTemplate().save(syUsers);
Set babySet=syUsers.getSyLeaguer().getSyLeaguerBabies();
if(babySet!=null&&babySet.size()>0){
SyLeaguerBaby baby=(SyLeaguerBaby)babySet.iterator().next();
this.getHibernateTemplate().save(baby);
}
}

/***用戶登錄***/
public boolean checkSyUserLogin(SyUsers syUsers){
String querySQL = "FROM SyUsers WHERE loginName=:username and loginPassword=:password and state=:state and isEmp=:isemp";
Query query = this.getSession().createQuery(querySQL);
query.setString("username", syUsers.getLoginName());
query.setString("password", syUsers.getLoginPassword());
query.setInteger("state", 1);
query.setInteger("isemp", 0);
List list = (List)query.list();
return list.size()>0?true:false;
}

/***密碼找回得到注冊密保信息***/
public SyLeaguer isRightPasswordProtect(SyLeaguer syLeaguer){
String querySQL = "FROM SyLeaguer WHERE loginName=:loginname";
Query query = this.getSession().createQuery(querySQL);
query.setString("loginname", syLeaguer.getLoginName());
return (SyLeaguer)query.uniqueResult();
}

public void updateSyUserPassword(String loginName,String newPassword){

} public Page querySyUserPage(int pageNo, int pageSize,
HqlQueryRule hqlQueryRule) {
// TODO Auto-generated method stub
// Criteria c=this.getSession().createCriteria(SyUsers.class);
// for(int i=0;restrictList!=null&&i<restrictList.size();i++){
// c=c.add((Criterion) restrictList.get(i));
// }
// for(int i=0;orderList!=null&&i<orderList.size();i++){
// c=c.addOrder((Order) orderList.get(i));
// }
// c.setFirstResult((int)page.getStart());
// c.setMaxResults(page.getPageSize());
// List resultList=c.list();

//HqlQueryRule hqr=new HqlQueryRule();
//hqr.addEqual("id", new Integer(1234));
Page p = new Page();
Page page = null;
String queryPageHQL = "select new map( su.loginName as loginName, su.loginPassword as loginPassword,su.isEmp as isEmp) from SY_RES su where 1=1";
String countHQL = "select count(*) from SyUsers where 1=1 ";// 總記錄數
queryPageHQL=queryPageHQL+hqlQueryRule.getHql();

Query query = this.getSession().createQuery(queryPageHQL);
List list = query.list();

PageTool pt=new PageTool(page);
page=pt.getHQLQueryPage(this.getSession(), queryPageHQL,countHQL, null);
return page;
} public boolean updateSyUserState(String loginName, Integer state) {
// TODO Auto-generated method stub
return false;
} public List querySyUser(HqlQueryRule hqlQueryRule) {
// TODO Auto-generated method stub
return null;
} public void updateSyUserPassword(String loginName, String oldPassword,
String newPassword) {
// TODO Auto-generated method stub

} public SyUsers getSyUserByLoginName(String loginName) {
return (SyUsers)this.getSession().get(SyUsers.class, loginName);
}

/***用戶名是否重復***/
public boolean isRepeatUser(String loginName){
String querySQL = "FROM SyUsers WHERE loginName=:username";
Query query = this.getSession().createQuery(querySQL);
query.setString("username", loginName);
List list = (List)query.list();
return list.size()>0?true:false;
}

public void updateSyUserPassword(SyUsers syUsers){
this.getSession().update(syUsers);
}

public void updateSyUsers(SyUsers syUsers){
this.getSession().update(syUsers);
}
}

⑹ 請問，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可能崩潰哦 *_*

⑺ 泛型和數組以及Java是如何實現泛型的

要區分數組和泛型容器的功能，這里先要理解三個概念：協變性（covariance）、逆變性（contravariance）和無關性（invariant）。
若類A是類B的子類，則記作A ≦ B。設有變換f()，若：
當A ≦ B時，有f(A)≦ f(B)，則稱變換f()具有協變性；

當A ≦ B時，有f(B)≦ f(A)，則稱變換f()具有逆變性；

如果以上兩者皆不成立，則稱變換f()具有無關性。

在Java中，數組具有協變性，而泛型具有無關性，示例代碼如下：
Object[] array = new String[10];

//編譯錯誤
ArrayList<Object> list=new ArrayList<String>();

這兩句代碼，數組正常編譯通過，而泛型拋出了編譯期錯誤，應用之前提出的概念對代碼進行分析，可知：
1、String ≦ Object
2、數組的變換可以表達為f(A)=A[]，通過之前的示例，可以得出下推論：

f(String) = String[] 以及 f(Object) = Object[];
4、通過代碼驗證，String[] ≦ Object[] 是成立的，由此可見，數組具有協變性。

⑻ 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。

⑼ Java程序，數組傳不過去，泛型的方法

public class Gtype {

public static<T> void out(int[] t){
for(int i=0;i<t.length;i++){
System.out.println(t[i]+" ");
}
}
public static void main(String[] args) {
int[] sh=new int[]{1,2,3};
out(sh);

}
}

你的sh數組類型是int類型，那麼你調用out方法，傳的參數數組類型就是int類型的

⑽ Java 中為什麼不能創建泛型數組

由於JVM泛型的擦除機制，在運行時JVM是不知道泛型信息的，所以可以給oa[1]賦上一個ArrayList<Integer>而不會出現ArrayStoreException，但專是在取出屬數據的時候卻要做一次類型轉換，所以就會出現ClassCastException，如果可以進行泛型數組的聲明，上面說的這種情況在編譯期將不會出現任何的警告和錯誤，只有在運行時才會出錯。而對泛型數組的聲明進行限制，對於這樣的情況，可以在編譯期提示代碼有類型安全問題，比沒有任何提示要強很多。

閱讀全文

java數組泛型

與java數組泛型相關的閱讀推薦