当前位置：首页 » 编程语言 » 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数组泛型相关的阅读推荐