精华内容
下载资源
问答
  • 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静态泛型使用方法实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 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静态泛型方法

    万次阅读 2016-09-12 23:48:52
    泛型方法使用 不仅集合中可以使用,在定义类和方法的时候也是经常使用的,但是关于泛型的静态方法使用的场景还是不太多。下面从求两个数的最大数的实现上来看一下它们的简单使用: 普通泛型方法 package me.

    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中的泛型是伪泛型,但是泛型可以使代码更加的简洁,只是在使用 普通泛型方法 和 静态泛型方法 时需要特别注意类型转化。


    更多文章请访问小胖轩

    展开全文
  • 静态泛型方法

    2017-04-23 15:19:12
    静态方法不可以访问类上定义的泛型 如果静态方法操作的应用数据类型不确定,可以讲泛型定义在方法上*/ import java.util.*; class demo { public static T show(T t ) { return t; } } class GenericDemo { ...
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...
  • java泛型,以及为何泛型类不能写相同占位符的静态泛型方法 1.首先为什么要有泛型 先来看一段代码 public class Demo1 { public static void main(String[] args) { ArrayList list = new ArrayList();//不指定泛型...
  • private void DeleteById(HttpContext context) { string method = context.Request.Params["method"].ToString(); string entityName = method.Substring("Delete".Length); Assembly assembly = As...
  • 泛型 泛型简介 泛型可以理解为参数化类型,主要作用在类,方法和接口上。...泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ; 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ; 泛
  • 泛型类中的静态方法不能使用类的泛型,而应该将该方法定义为泛型方法 1.错误示范: class demo&lt;T&gt;{ public static T show(T temp) { return temp; } } 2.正确示范: class demo&lt;T&...
  • JAVA(二十一)——泛型的概述 不知不觉JAVA之旅已经写到21篇了,不得不感叹当初自己坚持要重学一遍JAVA的信念,中途也算是非常的痛苦吧,不过熬到现在,已经算是有点效果了,继续加油,估计三十来篇就能结束自己的...
  • 静态方法中使用泛型时有一种情况需要注意一下,那就是静态方法无法访问类上定义的 泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。 2 语法结构 public static <泛型表示符号>...
  • 泛型方法 泛型类中所定义的泛型,在方法中也可以使用。但是,我们经常需要仅仅在某一个方法 上使用泛型,这时候可以使用泛型方法泛型方法是指将方法的参数类型定义成泛型,以便在调用时接收不同类型的参数。...
  • java 之 静态泛型方法

    2017-10-24 21:51:27
    java 之 静态泛型方法
  • 静态方法泛型

    千次阅读 2019-10-24 16:21:55
    静态方法有一种情况需要注意一下,那就是在类中的静态方法使用泛型...即:如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法。 public class StaticGenerator<T> { .... .... /** * 如果在...
  • java静态方法使用泛型

    2022-04-04 11:51:45
    //可以看出与句柄无关,是静态方法自动做出的判断 //在方法中自动进行强制类型转换,语法很特别。 //(这个语句毫无疑问会报错,只是subList这个ArrayList有,而HashSet没有的方法能更明确的展示这个语法) test2...
  • 万能设置值 public void setValue<t>(t value) where t : JToken { this.jObject[fieldName] = value;...万能创建不同泛型的对象。 public static JObjectTarget<t> createJObjectTarget<...
  • 泛型and静态方法

    2021-11-22 10:23:20
    泛型类的静态方法 v.s. 静态泛型方法
  • 静态方法泛型

    2021-03-01 16:49:41
    泛型存在的意义就是为了动态指定具体类型,增强灵活性和通用性 静态和非静态之分就在于静态是编译时类型,动态是运行时类型。 Java中的静态变量和静态代码块是在类加载的时候就执行的 实例化对象时,先声明并实例化...
  • 给类添加上泛型即可正常编译
  • 问题遇到的现象和发生背景 为什么静态变量和静态方法中无法使用泛型,但却可以通过定义泛型方法来使用 问题相关代码,请勿粘贴截图 public class GenericTest1 { // 静态方法与静态成员变量无法使用泛型 static E ...
  • 泛型也可以僅定義在靜態方法上,舉例而言,在定義與使用泛型中自定義過支援泛型的ArrayList,如果現在想寫個asArrayList方法,可指定不定長度引數,將之轉換為ArrayList,則可以如下:packagecc.openhome;...
  • 众所周知,HttpClient我们通常会把他封装成一个工具类,工具类应保持开闭原则(虽然这里只是一个简单的工具类,没有使用设计模式,嘿嘿嘿),所以这就否定了在工具类中单独加一个方法来适应返回值为JSONArray....
  • 泛型类中的静态方法不能使用类的泛型,而应该将该方法定义为泛型方法 原因: 在java中泛型只是一个占位符,必须在传递类型后才能使用,就泛型而言,类实例化时才能正真的的传递类型参数,由于静态方法的加载先于类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,707
精华内容 44,682
关键字:

静态泛型方法

友情链接: 心电图滤波.rar