精华内容
下载资源
问答
  • java泛型数组

    2017-03-17 15:42:48
    泛型数组的创建
  • Java 泛型数组

    2020-03-03 12:41:05
    泛型数组的创建 一、可以声明带泛型的数组引用,但是不能直接创建带泛型的数组对象 public static void main(String[] args) { // 可以声明泛型数组引用ArrayList<String>[] listArr = new ArrayList[5] //...

    泛型数组的创建

    一、可以声明带泛型的数组引用,但是不能直接创建带泛型的数组对象

    	public static void main(String[] args) {
    	// 可以声明泛型数组引用ArrayList<String>[] listArr = new ArrayList[5]
    	// 不能直接创建带泛型的数组对象ArrayList<String>[] listArr = new ArrayList<>[5]
    	
    	ArrayList<String>[] listArr = new ArrayList[5];
    	ArrayList<String> strList = new ArrayList<>();
    	strList.add("abc");
    		
    	listArr[0] = strList;
    	String s = listArr[0].get(0);
    	System.out.println(s);
    }
    

    二、 通过java.lang.reflect.Array的newInstance (Class, int)创建T[ ]数组

     java.lang.reflect.Array 的 newInstance (Class<T>, int)
    创建T[ ]数组
    

    泛型类

    public class Fruit<T> {
    //	private T[] array = new T[3]; 错误
    	private T[] array;
    	//构造方法
    	public Fruit(Class<T> clz, int length) {
    		// 通过Array.newInstance创建泛型数组
    		array = (T[]) Array.newInstance(clz, length);
    	}
    
    	//	填充数组
    	public void put(int index, T item) {
    		array[index] = item;
    	}
    
    	//返回数组元素
    	public T get(int index) {
    		return array[index];
    	}
    
    	//得到整个数组
    	public T[] getArray() {
    		return array;
    	}
    } 
    

    测试类

    	public static void main(String[] args) {
    		Fruit<String> fruit = new Fruit<>(String.class, 3);
    		fruit.put(0, "Apple");
    		fruit.put(1, "malo");
    		fruit.put(2, "banlala");
    		
    		System.out.println(fruit.get(0));
    		System.out.println(fruit.get(1));
    		System.out.println(fruit.get(2));
    		
    		System.out.println("---------------------");
    		
    		String[] array = fruit.getArray();
    		
    		for(String a:array) {
    			System.out.println(a);
    		}
    		
    		System.out.println("---------------------");
    		
    		String s = Arrays.toString(fruit.getArray());
    		System.out.println(s);
    
    	}
    
    展开全文
  • java 泛型数组

    2014-08-13 20:11:49
    java 泛型数组的一个例子:

    java 泛型数组的一个例子:

    <pre name="code" class="java">@SuppressWarnings("unchecked")
    public class FanxingShuzu{
    	public static void main(String[] args){
    		Integer i[] = fun1(1,2,2,3,4);
    		fun2(i);
    	}
    	public static <T> T[] fun1(T...arg){//接受可变参数,<T>起的是一个定义一作用
    		return arg;//返回泛型数组
    	}
    	public static <T> void fun2(T param[]){
    		System.out.println("接受泛型数组:");
    		for(T t:param){
    			System.out.print(t);
    		}
    	}
    }

    
    
    这里用到了Java可变参数,<p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;"><span style="margin: 0px; padding: 0px; line-height: 1.8; color: rgb(0, 128, 0);"><span style="margin: 0px; padding: 0px;">可变参数:适用于参数个数不确定,类型确定的情况,java把可变参数当做数组处理。</span></span>注意:可变参数必须位于最后一项。当可变参数个数多余一个时,必将有一个不是最后一项,所以只支持有一个可变参数。因为参数个数不定,所以当其后边还有相同类型参数时,java无法区分传入的参数属于前一个可变参数还是后边的参数,所以只能让可变参数位于最后一项。</p><p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;">可变参数的特点:</p><p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;">(1)、只能出现在参数列表的最后; </p><p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;">(2)、...位于变量类型和变量名之间,前后有无空格都可以;</p><p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;">(3)、调用可变参数的方法时,编译器为该可变参数隐含创建一个数组,在方法体中一数组的形式访问可变参数。</p><p style="margin: 10px auto; padding-top: 0px; padding-bottom: 0px; color: rgb(51, 51, 51); font-family: verdana, Arial, Helvetica, sans-serif; font-size: 14px; line-height: 25.200000762939453px;"><pre name="code" class="java">public class Kebiancanshu{
    	public static void main(String[] args){
    		int a = add(1,2);
    		int b= add(1,2,3);
    		System.out.println(a);
    		System.out.println(b);
    	}
    	public static int add(int x,int...arg){//把可变参数看成数组形式,来进行访问。
    		int sum=x;
    		for(int i=0;i<arg.length;i++){
    			sum+=arg[i];
    		}
    		return sum;
    	}
    }


    
    

    展开全文
  • java泛型数组的误区

    2020-09-15 11:37:53
    java泛型数组的误区结论Java泛型描述:原因分析:底层原理:解决方案: 结论 不能(直接)创建泛型数组,但可以参数化数组本身的类型(即是将数组应该存储的对象进行参数化)。 泛型数组实际的运行时对象数组只能是...


    结论

    1. 不能(直接)创建泛型数组,但可以参数化数组本身的类型(即是将数组应该存储的对象进行参数化)。
    2. 泛型数组实际的运行时对象数组只能是原始类型

    # 项目场景:

    实例化泛型数组时,编译器直接报错
    在这里插入图片描述


    Java泛型描述:

    首先理解Java泛型的定义:泛型,即“参数化类型”,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

    例如:List中,String是类型实参,也就是说,相应的List接口中肯定含有类型形参。List接口中采用泛型化定义之后,< E >中的E表示类型形参,可以接收具体的类型实参,并且此接口定义中,凡是出现E的地方均表示相同的接受自外部的类型实参

    泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型。


    原因分析:

    底层原理:

    由于泛型具有擦除机制,在运行时的类型参数会被擦除,Java只知道存储的对象是一个Object而已,而对于Java的数组来说,他必须知道它持有的所有对象的具体类型,而泛型的这种运行时擦除机制违反了数组安全检查的原则。

    由于擦除,运行期的数组类型只能是 Object[]


    解决方案:

    所以不能实例化java泛型数组,其本身就和泛型机制冲突。


    可以这样理解,

    在这里插入图片描述

    arr数组中存的是String,而s数组中存的是List,List本身就是数组,数组不能存数组。


    https://www.cnblogs.com/MrJR/p/10463479.html
    https://www.cnblogs.com/ixenos/p/5648519.html
    https://www.cnblogs.com/lwbqqyumidi/p/3837629.html

    展开全文
  • Java泛型数组

    2014-10-12 21:22:00
    文章来自... Java 不支持泛型数组。也就是说, List<String>[] ls = new ArrayList<String>[10]; 是不支持的,而 List<String>[] ls = new ArrayList[10] ...

    文章来自http://blog.csdn.net/orzlzro/article/details/7017435

    Java 不支持泛型数组。也就是说,

    List<String>[] ls = new ArrayList<String>[10];
    


    是不支持的,而

    List<String>[] ls = new ArrayList[10]
    

    却可以。

     

    是我一直不清楚为什么不能够声明泛型的数组,指定类型可以让编译的时候不会出现类型安全的提示。

    直到今天我看到Sun的一篇文档才清楚,里面提到了一种情况:

     

    List<String>[] lsa = new List<String>[10]; // Not really allowed.
    Object o = lsa;
    Object[] oa = (Object[]) o;
    List<Integer> li = new ArrayList<Integer>();
    li.add(new Integer(3));
    oa[1] = li; // Unsound, but passes run time store check
    String s = lsa[1].get(0); // Run-time error: ClassCastException.
    

    这种情况下,由于JVM泛型的擦除机制,在运行时JVM是不知道泛型信息的,所以可以给oa[1]赋上一个ArrayList<Integer>而不会出现ArrayStoreException,但是在取出数据的时候却要做一次类型转换,所以就会出现ClassCastException,如果可以进行泛型数组的声明,上面说的这种情况在编译期将不会出现任何的警告和错误,只有在运行时才会出错。而对泛型数组的声明进行限制,对于这样的情况,可以在编译期提示代码有类型安全问题,比没有任何提示要强很多。

    基于以上的原因,Java不支持声明泛型数组,更确切地表达是:数组的类型不可以是类型变量,除非是采用通配符的方式,看下面这个例子:

    List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
    Object o = lsa;
    Object[] oa = (Object[]) o;
    List<Integer> li = new ArrayList<Integer>();
    li.add(new Integer(3));
    oa[1] = li; // Correct.
    String s = (String) lsa[1].get(0); // Run time error, but cast is explicit.
    

    因为对于通配符的方式,最后取出数据是要做显式的类型转换的,所以并不会存在上一个例子的问题。



    转载于:https://www.cnblogs.com/wxisme/p/4363789.html

    展开全文
  • Java 泛型数组列表 ArrayList (动态数组)的使用 https://www.jianshu.com/p/a4974f3f4393
  • scala 与 java泛型数组

    2017-04-16 22:31:00
    java 泛型数组初始化 public class GenericArray<T> { private T[] arr; public GenericArray(){ arr = new T[10]; //编译错误 } } 使用这样的方式初始化jav...
  • JAVA泛型数组ArrayList详解

    千次阅读 2018-11-20 17:13:48
    下面来解释一下泛型数组ArrayList(泛型数组来解释一下这个原理): java没有增加泛型类之前: 在java增加泛型类之前,泛型设计是通过继承实现的。ArrayList类只维护一个Object引用的数组: public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 92,050
精华内容 36,820
关键字:

java泛型数组

java 订阅