精华内容
下载资源
问答
  • 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静态泛型方法

    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){
         }*/
      }
    }
    


     

    展开全文
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...

    泛型类定义的泛型,在整个类中有效。如果被方法是用,那么

    泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。

    为了让不同的方法可以操作不同类型,而且类型还不确定。那么

    可以将泛型定义在方法上。

    泛型类

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(T t)

    {

    System.out.println("show: "+t);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demod = new Demo();

    d.show(new Integer(4));

    Demod1 = new Demo();

    d1.print("haha");

    }

    }

    结果:

    show: 4

    show: haha

    泛型方法

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    同时定义泛型类和泛型方法

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    d.print(5);

    d.print("heiei");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    print:5

    print:heiei

    特殊之处:

    静态方法不可以访问类上定义的泛型

    如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。

    class Demo

    {

    public void show(T t)

    {

    System.out.println("show: "+t);

    }

    public void print(Q q)

    {

    System.out.println("print:"+q);

    }

    public static void method(W t)

    {

    System.out.println("method: "+t);

    }

    }

    class GenericDemo4

    {

    public static void main(String[] args)

    {

    Demo d = new Demo();

    d.show("hello boy!");

    d.print("Alex i love you !");

    d.print(5);

    d.print("heiei");

    Demo.method("hihi");

    }

    }

    结果:

    show: hello boy!

    print:Alex i love you !

    print:5

    print:heiei

    method: hihi

    泛型定义在接口上

    interface Inter

    {

    void show(T t);

    }

    //第一种

    class InterImpl implements Inter

    {

    public void show(String t)

    {

    System.out.println("show :"+t);

    }

    }

    /*第二种

    class InterImplimplements Inter

    {

    public void show(T t)

    {

    System.out.println("show :"+t);

    }

    }

    */

    class GenericDemo5

    {

    public static void main(String[] args)

    {

    /*

    InterImpl i = new InterImpl();

    i.show(4);

    */

    InterImpl i = new InterImpl();

    i.show("haha");

    }

    }

    结果:

    show :haha

    第一种相对来说就比较死,固定为String类型了。而第二种可以自己定义。

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


    更多文章请访问小胖轩

    展开全文
  • 众所周知,HttpClient我们通常会把他封装成一个工具类,工具类应保持开闭原则(虽然这里只是一个简单的工具类,没有使用设计模式,嘿嘿嘿),所以这就否定了在工具类中单独加一个方法来适应返回值为JSONArray....
  • java静态方法使用泛型

    2022-04-04 11:51:45
    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...
  • 静态泛型方法定义: public static <T> T deserialize(byte[] byteArray) { ObjectInputStream oip = null; try { oip = new ObjectInputStream(new ByteArrayInputStream(byteArray)); @...
  • Java泛型静态方法中的使用

    万次阅读 2017-08-17 21:39:23
    我们在静态方法中使用泛型的时候,我们需要在static 后面加上泛型标识
  • 泛型类中的静态方法不能使用类的泛型,而应该将该方法定义为泛型方法 1.错误示范: class demo&lt;T&gt;{ public static T show(T temp) { return temp; } } 2.正确示范: class demo&lt;T&...
  • JAVA泛型-泛型方法的定义和使用

    千次阅读 2021-10-23 19:56:34
    泛型方法 是在调用方法的时候指明泛型的具体类型。 【泛型方法 能够使方法独立于类的处理指定的类型。】 1.2 语法 修饰符 <T,E,…> 返回值类型 方法名(形参列表){ 。。。。。。 } 修饰符与返回值类型...
  • Java静态方法泛型

    2020-11-26 13:47:55
    泛型类中的静态方法不能使用类的泛型而应该将该方法定义为泛型方法。 在java泛型只是一个占位符,必须在传递类型后才能使用。就泛型而言,类实例化时才能正真的的传递类型参数,由于静态方法的加载先于类的实例化...
  • 泛型方法 泛型方法就是要在权限符和返回值之间声明泛型,通常用L、V、E、T、K等字母,然后就可以在这个方法的内部将其看作一种方法类型了 ...静态方法不能直接使用类定义的泛型,也就是说如果要在静态方法中使用
  • 想象一下,我们有以下泛型类:public class GenericClass {private U value;...}}和其他一些类MyClass中的以下泛型方法:public void genericMethod(T arg) {Object genericClass = new GenericCl...
  • 一般如果自定义的类要使用泛型, 那么需要在类定义的时候, 声明泛型, 如:public class MyClass {...}那么, 如果想在类的静态方法里上使用泛型, 以及如何在调用的时候, 传入泛型类型呢?静态方法上在 static 关键字...
  • 自定义泛型结构包括:泛型类,泛型接口;泛型方法 首先我们先自定义一个泛型类,该类里面也包括了泛型方法 自定义好泛型类跟泛型方法后,我们可以对其...5.因为泛型参数是在调用方法时确定的,并非在实例化类时确定的...
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型...泛型方法调用时,才指定具体类型 这样就解决了多个相似的类(方法、接口 )创建的问题,一个泛型类即可代替所
  • 个人观点而已,没有查资料考究过,有人说Java泛型无法写静态方法,也有说可以写,但是必须在static后加上< T >。 而我认为泛型是完全可以写静态方法,并且static后加上< T >并不是必须的 package hello...
  • 静态方法只能访问静态成员(包括成员变量和成员方法) 非静态方法可以访问静态也可以访问非静态 2.静态方法中不可以定义this,super关键字 因为静态优先于对象存在,所以静态方法中不可以出现this,super关键字 3....
  • Java自定义泛型方法

    万次阅读 2018-08-05 13:09:46
    我们可以写一个泛型方法,该方法调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。   以下是一个基本的指导原则: 无论何时,只要你能做到,你就应该尽量使用...
  • 不能用static修饰泛型成员变量 静态方法和变量 不用实例化类就能调用。 public void set(M key) { this.key = key; } public M fun4() {// 同样不是泛型方法,因为 方法中没有加<M> M是声明类的时候加的 ...
  • java泛型,以及为何泛型类不能写相同占位符的静态泛型方法 1.首先为什么要有泛型 先来看一段代码 public class Demo1 { public static void main(String[] args) { ArrayList list = new ArrayList();//不指定泛型...
  • 1. 概述泛型java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型?为什么要使用泛型泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用方法时传递...
  • Java泛型静态方法调用问题

    千次阅读 2010-07-10 16:40:00
    public class HibernateManageUtil<T> { ...请问怎么调用方法: User user = new User() ; HibernateManageUtil<User>.addObject(user) ; 这样调用好像不行,在myeclipse中没反应。
  • Java泛型的使用

    2021-08-22 13:05:08
    指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用类的泛型的位置, 都指定为实例化的泛型类型。比如:add(E e) --->实例化以后:add(Integer e) D.注意点:泛型的类型...
  • 我是否可以要求实现接口的类具有某个静态字段或方法,并通过泛型类型参数访问/调用该字段或方法?我有一个接口Arithmetical< T>,它指定了几个函数,如T plus(T o)和T times(T o).我也有一个Vector< N extends...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,748
精华内容 27,499
热门标签
关键字:

java静态泛型方法调用

java 订阅