精华内容
下载资源
问答
  • java – 具有泛型返回类型的棘手静态泛型方法,它本身可以是泛型
    2021-03-03 13:44:19

    我有一个课程如下:

    public class MyConverter {

    public T convert (Object o,String typeidentifier,T dummy)

    {

    ... do some conversions such as a java array to an ArrayList or vice versa

    ... based on a typeidentifier Syntax similar to Class.getName() but which

    ... embeds information about generic subtypes

    }

    }

    并希望能够像这样做一般的事情:

    int[] ar = {...};

    ArrayList dummy = null;

    Integer elem = MyConverter.convert(ar,"java.util.ArrayList",dummy)

    .get(15);

    也就是说,转换中的T本身可能是一个通用实例,我发现要实现这个目标,我必须传递一个完全类型的虚拟,因为ArrayList.class不会给java编译器足够的信息它是一个ArrayList如果我使用Class< T> dummycls而不是T dummy.

    我错过了什么吗?有没有办法在不需要虚拟的情况下编写和调用转换?

    更多相关内容
  • 主要介绍了Java静态泛型使用方法实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java静态泛型方法

    万次阅读 2016-09-12 23:48:52
    Java在JDK 5中引入了泛型,使用起来方便了很多,下面是一段很常见的泛型使用: ListString> list = new ArrayListString>(); 泛型方法使用 不仅集合中可以使用,在定义类和方法的时候也是经常使用的,但是关于...

    Java在JDK 5中引入了泛型,使用起来方便了很多,下面是一段很常见的泛型使用:

    List<String> list = new ArrayList<String>();

    泛型方法使用

    不仅集合中可以使用,在定义类、接口和方法的时候也是经常使用的,但是关于泛型方法使用的场景还是不太多。下面从求两个数的最大数的实现上来看一下泛型类和泛型方法的简单使用:

    泛型类(接口)

    package me.codeboy.test;
    
    /**
     * generic test
     * Created by yuedong on 9/12/16.
     */
    public class MathTest<T extends Comparable> {
    
        public static void main(String[] args) {
            MathTest<Integer> mathTest1 = new MathTest<Integer>();
            MathTest<Double> mathTest2 = new MathTest<Double>();
            System.out.println(mathTest1.max(1, 2));
            System.out.println(mathTest2.max(2.0, 3.0));
        }
    
        private T max(T t1, T t2) {
            return t1.compareTo(t2) > 0 ? t1 : t2;
        }
    }

    泛型方法

    /**
     * generic test
     * Created by yuedong on 9/12/16.
     */
    public class MathTest {
    
        public static void main(String[] args) {
            MathTest mathTest = new MathTest();
            System.out.println(mathTest.max(1, 2));
            System.out.println(mathTest.max(2.0, 3.0));
        }
    
        private <T extends Comparable> T max(T t1, T t2) {
            return t1.compareTo(t2) > 0 ? t1 : t2;
        }
    }

    静态泛型方法

    /**
     * generic test
     * Created by yuedong on 9/12/16.
     */
    public class MathTest {
    
        public static void main(String[] args) {
            System.out.println(max(1, 2));
            System.out.println(max(2.0, 3.0));
        }
    
        private static <T extends Comparable> T max(T t1, T t2) {
            return t1.compareTo(t2) > 0 ? t1 : t2;
        }
    }
    
    

    泛型方法优缺点

    优点很明显,代码简洁多了,或者可以说比普通的泛型泛型更为简洁,网上有一段关于Android中频繁使用 findViewById 方法的静态泛型方法实现,被称为见过最牛逼的Android代码,但是事物都有两面性,静态泛型方法也有相应的缺点,再看一段代码:

    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * test entry
     * Created by yuedong on 9/10/16.
     */
    public class Test {
    
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("test");
    
            //普通转换
            ArrayList<String> result1 = (ArrayList<String>) list;
    
            //静态泛型转换
            String result2 = convert(list);
        }
    
        private static <T> T convert(Object a) {
            return (T) a;
        }
    }

    上述代码是 编译通过,运行异常,为什么会出现这种现象呢?这是因为Java的泛型方法属于伪泛型,在编译的时候将进行类型擦除。普通的泛型方法在类构建时已经明确制定了对应的类型,而在静态泛型方法中,类型是无法直接推测的,缺少了明确的类型,最终造成类型转化异常。

    Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList cannot be cast to java.lang.String

    原理探索

    看到了上面的结果,不禁想了解下泛型方法在类型擦除后最终转换成了什么,反编译上述静态泛型方法编译后的class文件如下:

    Compiled from "Test.java"
    public class Test {
      public Test();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: new           #2                  // class java/util/ArrayList
           3: dup
           4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
           7: astore_1
           8: aload_1
           9: ldc           #4                  // String test
          11: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
          16: pop
          17: aload_1
          18: checkcast     #2                  // class java/util/ArrayList
          21: astore_2
          22: aload_1
          23: invokestatic  #6                  // Method convert:(Ljava/lang/Object;)Ljava/lang/Object;
          26: checkcast     #7                  // class java/lang/String
          29: astore_3
          30: return
    }

    可以看到convert函数最终转化后对应的字节码为 Method convert:(Ljava/lang/Object;)Ljava/lang/Object; 参数为Object类型,返回也为Object类型,而在接下来的 checkcast 操作中,由于 List 和 String 类型的不同,所以抛出了异常。

        private static <T extends List> T convert(Object a) {
            return (T) a;
        }

    对于上述的代码反编译后对应 Method convert:(Ljava/lang/Object;)Ljava/util/List; 中,可以看到此时参数为Object类型,返回为List类型。

    小结

    尽管Java中的泛型是伪泛型,但是泛型可以使代码更加的简洁,只是在使用 普通泛型方法 和 静态泛型方法 时需要特别注意类型转化。


    更多文章请访问小胖轩

    展开全文
  • I've read posts about why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class, but why can you then use static generic methods in...

    I've read posts about why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class, but why can you then use static generic methods in non generic classes? I don't see the why the second is allowed, but I kinda understand why the first isn't.

    解决方案

    why you can't have a (Edit -- generic) (which use that type parameter from the generic class) static method in a generic class

    The reason for this is simple: The type parameter is not associated with the class but with instances of the class.

    I.e., you can't do

    class Test {

    public static void sayHello(T t) { // T for which instance?!

    System.out.println("Hello");

    }

    }

    why can you then use static generic methods in non generic classes?

    Why wouldn't you? A generic method takes the type parameter, so it doesn't matter if it's static or not, or if the class it's in is generic or not etc.

    This for instance compiles fine:

    class Test {

    public static void sayHello(T t) {

    System.out.println("Hello " + t);

    }

    }

    And you'd call the method like this:

    Test.sayHello("some argument");

    ^^^^^^^^

    type parameter provided at the method-call: no instance required.

    展开全文
  • Java静态泛型方法

    2021-03-11 10:59:35
    下面代码演示了 静态泛型方法怎么写, 数组分割工具类,兼容任何数据类型 ```java package com.freestyle.common.utils; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java...

    下面代码演示了 静态泛型方法怎么写, 数组分割工具类,兼容任何数据类型```java

    一句话,就是在定义泛型方法的返回类型前面加泛型符号<T>或<E>

    package com.freestyle.common.utils;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Consumer;
    
    /**
     * 数组工具类
     * Created by rocklee on 2021/3/11 10:25
     */
    public class ArrayUtil {
      /**
       * 分隔数组 根据每段数量分段
       *
       * @param data  被分隔的数组
       * @param count 每段数量
       * @return
       */
      public static <T> List<List<T>> subListByCount(List<T> data, int count) {
        List<List<T>> result = new ArrayList<>();
        int size = data.size();// 数据长度
    
        if (size > 0 && count > 0) {
    
          int segments = size / count;// 商
          /**
           * 1.整除,  即分隔为segments     段
           * 2.除不尽,即分隔为segments + 1 段
           */
          segments = size % count == 0 ? segments : segments + 1; // 段数
    
          List<T> cutList = null;// 每段List
    
          for (int i = 0; i < segments; i++) {
            if (i == segments - 1) {
              cutList = data.subList(count * i, size);
            } else {
              cutList = data.subList(count * i, count * (i + 1));
            }
            result.add(cutList);
          }
        } else {
          result.add(data);
        }
        return result;
      }
      /**
       * 分隔数组 根据每段数量分段
       *
       * @param data  被分隔的数组
       * @param count 每段数量
       * @return
       */
      public   static <T> void   subListByCount(List<T> data, int count, Consumer<List<T>> output) {
        int size = data.size();// 数据长度
    
        if (size > 0 && count > 0) {
    
          int segments = size / count;// 商
          /**
           * 1.整除,  即分隔为segments     段
           * 2.除不尽,即分隔为segments + 1 段
           */
          segments = size % count == 0 ? segments : segments + 1; // 段数
    
          List<T> cutList = null;// 每段List
    
          for (int i = 0; i < segments; i++) {
            if (i == segments - 1) {
              cutList = data.subList(count * i, size);
            } else {
              cutList = data.subList(count * i, count * (i + 1));
            }
            output.accept(cutList);
          }
        } else {
          output.accept(data);
        }
      }
      public static void main(String[] args){
          List<String> data= Arrays.asList("1234","2345","abc","def","fhis","253aas","slkda");
          ArrayUtil.subListByCount(data,3,(s)->{
              System.out.println(s);
          });
         /*List<List<String>>subItems= ArrayUtil.subListByCount(data,3);
         if (subItems!=null){
         }*/
      }
    }
    


     

    展开全文
  • 泛型类定义的泛型,在整个类中有效。如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。...
  • 泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。 泛型类型 : 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ; 泛型类 : 类 也...
  • java静态方法使用泛型

    2022-03-21 18:36:14
    import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.HashMap; import java.util.List; public class StaticMethod { public static void main(String[] args...
  • 我是否可以要求实现接口的类具有某个静态字段或方法,并通过泛型类型参数访问/调用该字段或方法?我有一个接口Arithmetical< T>,它指定了几个函数,如T plus(T o)和T times(T o).我也有一个Vector< N extends...
  • 泛型类中的静态方法不能使用类的泛型,而应该将该方法定义为泛型方法 1.错误示范: class demo&lt;T&gt;{ public static T show(T temp) { return temp; } } 2.正确示范: class demo&lt;T&...
  • Java静态方法和泛型

    2020-11-26 13:47:55
    java泛型只是一个占位符,必须在传递类型后才能使用。就泛型而言,类实例化时才能正真的的传递类型参数,由于静态方法的加载先于类的实例化,也就是说类中的泛型还没有传递真正的类型参数静态的方法就已经加载...
  • 泛型方法 泛型方法就是要在权限符和返回值之间声明泛型,通常用L、V、E、T、K等字母,然后就可以在这个方法的内部将其看作一种方法类型了 ...静态方法不能直接使用类定义的泛型,也就是说如果要在静态方法中使用
  • 主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 泛型也可以僅定義在靜態方法上,舉例而言,在定義與使用泛型中自定義過支援泛型的ArrayList,如果現在想寫個asArrayList方法,可指定不定長度引數,將之轉換為ArrayList,則可以如下:packagecc.openhome;...
  • 解决思路:因为 JSONObject 与 JSONArray 本是一家子,都是 com.alibaba.fastjson 包下的,并且共同是 JSON的子类,所以可以使用泛型解决这个问题。 最终解决方案代码: @Test public void test2() throws ...
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7. 泛型类可以继承泛型类8. 泛型类可以实现泛型接口 泛型引入 如果我们需要...
  • 返回类型的静态方法中的泛型似乎与继承相处得不好.请看下面的代码:class ClassInfo {public ClassInfo(Class clazz) {this(clazz,null);}public ClassInfo(Class clazz, ClassInfo super C> superClassInfo) {}}...
  • Java泛型(类型擦除)

    2022-02-18 20:42:17
    Java泛型类型擦除
  • java静态泛型方法

    2017-10-24 21:51:27
    java静态泛型方法
  • 本文章用于运行时获取泛型的具体类型,有一些情况下可以获取到真实类型,有一些情况下获取不到的情况。 Class 类的两个方法 /** * Returns the {@code Class} representing the superclass of the entity * ...
  • 1、泛型是什么 首先告诉大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢?先看看下面这段代码: ArrayList<String> strList = new ArrayList<String>(); ArrayList<Integer> int...
  • 静态泛型方法定义: public static <T> T deserialize(byte[] byteArray) { ObjectInputStream oip = null; try { oip = new ObjectInputStream(new ByteArrayInputStream(byteArray)); @...
  • // 如果你在静态部分引用的泛型,那么毫无疑问虚拟机根本不知道是什么东西, // 因为这个时候类还没有初始化。因此在静态方法、数据域或初始化语句中,为了类而引用class F3声明的泛型类型参数是非法的 // } ...
  • Java泛型静态方法中的使用

    万次阅读 2017-08-17 21:39:23
    我们在静态方法中使用泛型的时候,我们需要在static 后面加上泛型标识

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,496
精华内容 33,798
关键字:

java静态泛型

java 订阅