• 关于 T方法 的搜索结果

问题

Java泛型通配符-协变与逆变:报错

kun坤 2020-06-09 22:18:08 0 浏览量 回答数 1

回答

使用通用方法的解决方案 将通用方法定义为 public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) 也就是说,第一个参数是您的对象集合,第二个参数是您提供从Object到目标类的转换函数。该方法返回一个List 。(请注意, 之后static需要声明一个通用方法。 该方法的实现可以是 List<T> result = new ArrayList<>(); for (List<Object> objects : dataframe) { for (Object object : objects) { T t = converter.apply(object); result.add(t); } } return result; } 或使用流的另一个: public static <T> List<T> convertGeneric(List<List<Object>> dataframe, Function<Object, T> converter) { return dataframe.stream() .flatMap(Collection::stream) // get the objects from the inner list .map(converter) // convert object to T .collect(Collectors.toList()); // put everything in a new list } 转换功能可以实现为lambda,例如 Function<Object, Foo> fooLambda = object -> { Foo foo = new Foo(); // logic for mapping obj to foo return foo; }; 和转换List<List<Object>>到List<Foo>变为: List<Foo> fooList = GenericMethodConverter.convertGeneric(dataFrame, fooLambda); 我认为您为这个问题而苦苦挣扎的原因是,您试图在通用方法中进行所有操作(抽象和具体部分)。您已经知道,泛型方法随后需要其他信息才能使用哪种具体实现(在您的版本中,将转换的目标类型作为第二个参数传递)。在上述解决方案中,通用方法需要转换函数Function<Object,T>,即将对象映射到目标类型T的函数。通用方法将此函数应用于所有对象,并将结果放入返回的列表中。用于映射的具体实现object为Foo作为从而reifying通用lambda表达式被供给T到Foo。可以根据需要添加其他转换功能。 另一种方法 这是使用面向对象/类而不是静态方法的解决方案: 定义一个抽象基类GenericConverter,其中包含要遍历列表的迭代,并声明一个抽象方法如何将an转换Object为目标类型: public abstract class GenericConverter<T> { public List<T> convertGenerically(List<List<Object>> dataFrame) { List<T> tList = new ArrayList<>(); for (List<Object> objectList : dataFrame) { for (Object obj : objectList) { T t = convert(obj); tList.add(t); } } return tList; } protected abstract T convert(Object obj); } 为每个目标类添加一个实现,例如,转换Object为Foo: public class FooConverter extends GenericConverter<Foo> { @Override protected Foo convert(Object obj) { Foo foo = new Foo(); // logic for mapping obj to foo return foo; } } 然后Objects通过调用实现类的方法来转换: List<Foo> foos = fooConverter.convertGenerically(dataFrame); 回答来源:Stack Overflow

montos 2020-03-24 17:52:36 0 浏览量 回答数 0

问题

Runnable接口多线程问题

蛮大人123 2019-12-01 20:02:18 1012 浏览量 回答数 1

新用户福利专场,云服务器ECS低至102元/年

新用户专场,1核2G 102元/年起,2核4G 699.8元/年起

回答

诸如List<T>等泛型集合类,直接提供了sort()方法用于将集合中的元素进行排序。 但是,其前提是集合中存放的是可直接排序的基本类型,如List<int>, List<double>,如果 我们定义了一个自定义类型 Class MyClass,并创建一个自定义类型的集合如List<MyClass>, 那么无参的sort()方法就不可用了,因为不知道如何排序了。这时就需要借助: IComparer 和 IComparable 首先,我们来看一下c#泛型List提供的Sort方法: 泛型List类的Sort方法有四种形式,分别是 1,不带有任何参数的Sort方法----Sort(); 2,带有比较器参数的Sort方法 ----Sort(IComparer<T>) 3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>)) 4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T)) 【解析:】第一种方法 使用这种方法不是对List中的任何元素对象都可以进行排序,List中的元素对象必须继承IComparable接口,并且要实现IComparable接口中的CompareTo()方法,在CompareTo()方法中要自己实现对象的比较规则。 例如,Int32和Double都是实现了IComparable接口并重载了CompareTo方法的结构。(注:int和double都是Int32和Double的别名(alias)) 【解析:】第二种方法 2,带有比较器参数的Sort方法 ----Sort(IComparer<T>), 1)创建一个额外的比较器类:其实就相当于将排序功能中的比较操作,留个使用者来完成。这个比较操作必须在实现了IComparer接口的自定义比较类中完成;如: class myComparer:IComparer<MyClass> 2)制定比较规则实现比较方法:因为接口中有一个用于比较的重载函数Compare,所在在比较器类中我们必须实现它,完成自己希望的比较。所谓自己希望的比较就是说自己实现自定义对象的比较规则,例如你知道自定义类MyClass中哪个属性适合用来排序,那么就选择这个属性作为整个自定义类对象的排序属性,如该类中有年龄,学号,入学日期等属性,你可以选择年龄属性作为排序属性。如: public class myComparer:IComparer<MyClass> { //实现按年龄升序排列 public int Compare(MyClass x, MyClass y) { return (x.age.CompareTo(y.age)); //age代表年龄属性是整型,即其已支持CompareTo方法 } } 3)使用比较器的排序方法调用:然后,在自定义类型的集合如List<MyClass> myList,上就可以进行sort排序了,如 myList.Sort(new myComparer()); 【解析:】第三种方法 3,带有比较代理方法参数的Sort方法----Sort(Comparison<(Of <(T>)>)) Comparison<(Of <(T>)>是一种泛型委托。所以,需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比较方法中需要实现 对象比较规则,这个方法实现后,就可以把这方名字作为参数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较 需要编写一个对象排序比较的方法,对List中的元素对象没有特殊的要求,但在比较方法中需要实现对象比较规则,这个方法实现后,就可以把这方名字作为参 数委托给List的Sort方法,Sort方法在排序时会执行这个方法对List中的对象进行比较 【解析:】第四种方法 4,带有比较器参数,可以指定排序范围的Sort方法----Sort(Int32, Int32 IComparer(T)) 对于第四排序方法,实际是第二种比较器排序的一个扩展,在指定排序比较器的同时,指定排序范围,即List中准备排序的开始元素索引和结束元素索引

行者武松 2019-12-02 01:17:43 0 浏览量 回答数 0

回答

定义泛型方法或者泛型类格式是固定的,跟其它无关。不会因为你输入的是啥而改变它的定义格式: 泛型方法: public <T> T do_something(T t){ return t;//返回值也是泛型 } public <T> String do_something(T t, int num){ return "";//返回值是字符串 } 泛型类: public class Test<T> { } 如果你想通过字符串type的内容来限制输入类型的话,你可以通过反射获取type字符串对应的类型,跟我们传到方法中的类型相比对,一致的话就说明是我们type允许传入的类型,不一致的话,就说明不是我们允许传入的值。

蛮大人123 2019-12-02 02:19:48 0 浏览量 回答数 0

回答

1. 继承 Thread 类,然后调用 start 方法。 class SampleThread extends Thread {     //重写run方法,线程运行后,跑的就是run方法     public void run(){        //System.out.println("");     }       public static void main(String[] args){        Thread t1 = new SampleThread();        Thread t2 = new SampleThread();        t1.start();  //线程运行,调用的 run()方法.        t2.start(); //线程运行,调用的 run()方法..      } } 2. 实现 Runnable 接口的 run 方法, 然后再用 Thread 类包裹后,调用 start 方法。   class A implements Runnable{     @Override     public void run() {         // implement run method here     }       public static void main() {         final A obj = new A();           Thread t1 = new Thread(new A());           t1.start();     }   }  

问问小秘 2020-01-03 13:54:44 0 浏览量 回答数 0

回答

" 探究 public static void main(String[] args) throws Exception { Thread.currentThread().join(); System.out.println("main thread exit."); } 为了了解问题本质,我们跟进去代码看看,线程的join方法如下: public final void join() throws InterruptedException { join(0); } 再继续跟: public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } } 根据代码,其实join方法最终是待用了wait(0);这行代码,而wait方法是本地方法. 根据wait的方法定义,有以下几点逐一说明: wait()方法在Object类定义,调用时会获取该对象上的监视器,因此必须在同步代码块上调用.从代码来看`public final synchronized void join(long millis)throws InterruptedException`,因此调用wait方法后,实际上是获取了当前对象(根据调试查看到是main线程)的监视器.根据wait方法的定义,它只在在如下几种情况才会被唤醒,否则将一直等待: <ul> <li>Some other thread invokes the {@code notify} method for this object and thread <var>T</var> happens to be arbitrarily chosen as the thread to be awakened. <li>Some other thread invokes the {@code notifyAll} method for this object. <li>Some other thread {@linkplain Thread#interrupt() interrupts} thread <var>T</var>. <li>The specified amount of real time has elapsed, more or less. If {@code timeout} is zero, however, then real time is not taken into consideration and the thread simply waits until notified. </ul> 总结 因此,回答你的问题就是,join方法实质是调用了wait方法.wait方法调用后阻塞(我不认为这是阻塞)在当前线程(main线程上),根据wait的定义,不调用notify,notifyAll,interrupt以及超时机制(本例调用的是wait(0),故不存在这种情况),那么线程将一直处于等待状态,故一直不会退出。###### main线程阻塞自己###### 大致的说下吧,Thread中,join()方法的作用是调用线程等待该线程完成后,才能继续用下运行。 public static void main(String[] args) throws InterruptedException { System.out.println("main start"); Thread t1 = new Thread(new Worker("thread-1")); t1.start(); t1.join(); System.out.println("main end"); } 在上面的例子中,main线程要等到t1线程运行结束后,才会输出“main end”。如果不加t1.join(),main线程和t1线程是并行的。而加上t1.join(),程序就变成是顺序执行了。 我们在用到join()的时候,通常都是main线程等到其他多个线程执行完毕后再继续执行。其他多个线程之间并不需要互相等待。 下面这段代码并没有实现让其他线程并发执行,线程是顺序执行的。 public static void main(String[] args) throws InterruptedException { System.out.println("main start"); Thread t1 = new Thread(new Worker("thread-1")); Thread t2 = new Thread(new Worker("thread-2")); t1.start(); //等待t1结束,这时候t2线程并未启动 t1.join(); //t1结束后,启动t2线程 t2.start(); //等待t2结束 t2.join(); System.out.println("main end"); } 所以就会是这个结果"

因为相信,所以看见。 2020-05-27 17:36:15 0 浏览量 回答数 0

问题

C基础系列:扩展方法的使用

通天技术 2019-12-01 21:25:27 2201 浏览量 回答数 0

问题

DIYRubyCPU分析PartII

sunny夏筱 2019-12-01 21:55:41 7801 浏览量 回答数 2

回答

interface Info24<T> { // 在接口上定义泛型 public T getVar(); // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImp24<T> implements Info24<T> { // 定义泛型接口的子类 private T var; // 定义属性 public InfoImp24(T var) { // 通过构造方法设置属性内容 this.setVar(var); } public void setVar(T var) { this.var = var; } public T getVar() { return this.var; } } public class GenericsDemo24 { public static void main(String arsg[]) { Info24<String> i = null; // 声明接口对象 i = new InfoImp24<String>("it"); // 通过子类实例化对象 System.out.println("Length Of String : " + i.getVar().length()); } } // Java泛型接口 interface Info25<T> { // 在接口上定义泛型 public T getVar(); // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImp25 implements Info25<String> { // 定义泛型接口的子类 private String var; // 定义属性 public InfoImp25(String var) { // 通过构造方法设置属性内容 this.setVar(var); } public void setVar(String var) { this.var = var; } public String getVar() { return this.var; } } public class GenericsDemo25 { // 该批注的作用是给编译器一条指令,告诉它对被批注的代码元素内部的某些警告保持静默。 /* * @description "deprecation" 使用了不赞成使用的类或方法时的警告 * * @description "unchecked" 执行了未检查的转换时的警告,例如当使用集合时没有用泛型 (Generics) * 来指定集合保存的类型。 * * @description "fallthrough" 当 Switch 程序块直接通往下一种情况而没有 Break 时的警告。 * * @description "path" 在类路径、源文件路径等中有不存在的路径时的警告。 * * @description "serial" 当在可序列化的类上缺少 serialVersionUID 定义时的警告。 * * @description "finally" 任何 finally 子句不能正常完成时的警告。 * * @description "all" 关于以上所有情况的警告。 */ @SuppressWarnings("unchecked") public static void main(String arsg[]) { Info25 i = null; // 声明接口对象 i = new InfoImp25("it"); // 通过子类实例化对象 System.out.println("Length Of String : " + i.getVar().toString().length()); } }

蛮大人123 2019-12-02 01:52:34 0 浏览量 回答数 0

回答

类型擦除会出现在泛型方法中,程序员通常认为下述的泛型方法 public static <T extends Comparable> T min(T[] a) 是一个完整的方法族,而擦除类型之后,只剩下一个方法: public static Comparable min(Comparable[] a) 这个时候类型参数T已经被擦除了,只留下了限定类型Comparable。 但是方法的擦除会带来一些问题: class Coupling extends Couple<People> { public void setTwo(People people) { super.setTwo(people); } } 擦除后: class Coupling extends Couple { public void setTwo(People People) {...} } 这时,问题出现了,存在另一个从Couple类继承的setTwo方法,即: public void setTwo(Object two) 这显然是一个不同的方法,因为它有一个不同类型的参数(Object),而不是People。 Coupling coupling = new Coupling(...); Couple<People> cp = interval; cp.setTwo(people); 这里,希望对setTwo的调用具有多态性,并调用最合适的那个方法。由于cp引用Coupling对象,所以应该调用Coupling.setTwo。问题在于类型擦除与多态发生了冲突。要解决这个问题,就需要编译器在Coupling类中生成一个桥方法: public void setTwo(Object second) { setTwo((People)second); } 变量cp已经声明为类型Couple,并且这个类型只有一个简单的方法叫setTwo,即setTwo(Object)。虚拟机用cp引用的对象调用这个方法。这个对象是Coupling类型的,所以会调用Coupling.setTwo(Object)方法。这个方法是合成的桥方法。它会调用Coupling.setTwo(Date),这也正是我们所期望的结果。

问问小秘 2020-06-23 14:47:34 0 浏览量 回答数 0

回答

大概原因是安装了SELINUX策略后,无论APACHE或MYSQL都要更改目录的权限,如果是APACHE,方法为:# chcon -R -h -t httpd_sys_content_t /www/web/ 如果是mysql,方法为: # chcon -R -t mysqld_db_t /mysql然后重新启动服务,搞定

蛮大人123 2019-12-02 01:42:44 0 浏览量 回答数 0

回答

为了实现多个构造器,你需要使用到类方法。例如: import time class Date: """方法一:使用类方法""" # Primary constructor def __init__(self, year, month, day): self.year = year self.month = month self.day = day # Alternate constructor @classmethod def today(cls): t = time.localtime() return cls(t.tm_year, t.tm_mon, t.tm_mday) 直接调用类方法即可,下面是使用示例: a = Date(2012, 12, 21) # Primary b = Date.today() # Alternate

哦哦喔 2020-04-17 15:06:57 0 浏览量 回答数 0

问题

请教一个Hibernate数据库查询方法

爵霸 2019-12-01 20:06:28 928 浏览量 回答数 1

问题

Java异步转同步的实现方法

蛮大人123 2019-12-01 20:02:09 2507 浏览量 回答数 1

回答

因为你的getSeq是成员方法,synchronized锁住的是实例对象,而你在运行的时候,new出来了两个,所以就没有效果了,解决办法有两个1.修改 getSeq() 方法,增加static修饰符2.启动部分代码按如下修改: public static void main(String[] args) { ThreadTest tt = new ThreadTest(); Thread t1 = new Thread(tt,"t1"); Thread t2 = new Thread(tt,"t2"); t1.start(); t2.start(); }

蛮大人123 2019-12-02 01:55:21 0 浏览量 回答数 0

问题

如何在Swift中扩展类型化数组?

保持可爱mmm 2020-01-16 16:46:38 0 浏览量 回答数 1

回答

先来看下方法重载(Overloading)的定义:如果有两个方法的方法名相同,但参数不一致,哪么可以说一个方法是另一个方法的重载。 具体说明如下: 方法名相同 方法的参数类型,参数个不一样 方法的返回类型可以不相同 方法的修饰符可以不相同 main 方法也可以被重载 class MyClass { int height; MyClass() { System.out.println("无参数构造函数"); height = 4; } MyClass(int i) { System.out.println("房子高度为 " + i + " 米"); height = i; } void info() { System.out.println("房子高度为 " + height + " 米"); } void info(String s) { System.out.println(s + ": 房子高度为 " + height + " 米"); } } public class MainClass { public static void main(String[] args) { MyClass t = new MyClass(3); t.info(); t.info("重载方法"); //重载构造函数 new MyClass(); } } 以上代码运行输出结果为: 房子高度为 3 米 房子高度为 3 米 重载方法: 房子高度为 3 米 无参数构造函数

珍宝珠 2020-02-12 19:48:22 0 浏览量 回答数 0

回答

以上代码本质上启动了两个线程一个是线程t,它的循环体里面根据stop标志执行休眠操作,当stop=true时,该线程run方法运行完成,线程结束。main方法所在的是另外一个线程,它启动线程t后,休眠三秒后将stop标志设置true,此时线程t则也会停止。通常线程的run方法都是循环轮询某个标识,这个标志是用来控制线程结束的,通常这个标识是由其它主控线程操作。所以不会死循环的。

蛮大人123 2019-12-02 02:07:42 0 浏览量 回答数 0

回答

百度了一下方法 一、修改 /etc/httpd/conf/httpd.conf 文件中的监听端口号 Listen 80 把 80 修改成需要的号,如 8000 ,即 Listen 8000 二、查看 SELinux 下 http 相关端口 # semanage port -l|grep http http_cache_port_t tcp 3128, 8080, 8118, 10001-10010 http_cache_port_t udp 3130 http_port_t tcp 80, 443, 488, 8008, 8009, 8443 pegasus_http_port_t tcp 5988 pegasus_https_port_t tcp 5989 发现 8000 不在其范围之内,所以需要另外添加,方法如下: # semanage port -a -t http_port_t -p tcp 8000 再次查看, # semanage port -l|grep http http_cache_port_t tcp 3128, 8080, 8118, 10001-10010 http_cache_port_t udp 3130 http_port_t tcp 8000, 80, 443, 488, 8008, 8009, 8443 pegasus_http_port_t tcp 5988 pegasus_https_port_t tcp 5989

51干警网 2019-12-02 00:24:14 0 浏览量 回答数 0

问题

阿里Java技术规范-集合处理toArray(T[] arr)

1907741823559501 2020-03-21 11:57:49 19 浏览量 回答数 1

问题

java内置锁的问题

蛮大人123 2019-12-01 20:17:26 704 浏览量 回答数 1

回答

1、该方法等待Factory 作为输入参数: public static TestBuilder create(Factory f) 并且Factory是只有一种方法的接口: interface Factory { T create(String s); } 这有效地使其成为一个功能性接口,可以通过简单地传递lambda:(Function<String, T>一个创建Tfrom 类型的实例的函数String)来实现。Test_Child::new是lambda,因为它消耗String和产生T。 2、如前所述Factory是一个函数,需要一个String并创建一个T。通过调用方法create,我们正在调用该函数。 答案来源:stackoverflow

游客5ltrhvc3ievgs 2020-03-28 11:10:18 0 浏览量 回答数 0

回答

class_rw_t:代表的是可读写的内存区,这块区域中存储的数据是可以更改的。 class_ro_t:代表的是只读的内存区,这块区域中存储的数据是不可以更改的。 OC对象中存储的属性、方法、遵循的协议数据其实被存储在这两块儿内存区域的,而我们通过runtime动态修改类的方法时,是修改在class_rw_t区域中存储的方法列表。

游客bnlxddh3fwntw 2020-04-13 15:05:34 0 浏览量 回答数 0

回答

一个简单而有效的方法是相关子查询: select t.* from t where t.createdon = (select min(t2.createdon) from t t2 where t2.userid = t.userid );

祖安文状元 2020-01-05 14:12:37 0 浏览量 回答数 0

回答

泛型方法可以定义在普通类中,也可以定义在泛型类中,类型变量是放在修饰符的后面,返回类型的前面。 我们来看一个泛型方法的实例: class ArrayUtil { public static <T> T getMiddle(T...a){ return a[a.length / 2]; } } 当调用一个泛型方法时,在方法名前的尖括号中放入具体的类型: String middle = ArrayUtil.<String>getMiddle("a","b","c"); 在这种情况下,方法调用中可以省略``类型参数,编译器会使用类型推断来推断出所调用的方法,也就是说可以这么写: String middle = ArrayAlg.getMiddle("a","b","c");

问问小秘 2020-06-23 14:32:18 0 浏览量 回答数 0

回答

excepTest方法中抛出异常,然后该方法上抛了异常该异常被抛给了run方法,应该在run方法内处理该问题但是代码中的查找捕获却在main方法中,肯定捕获不到异常 class Test22_05 implements Runnable{ public void run() { for(int i = 0; i < 10; i++){ try{ this.excepTest(i); }catch(Exception e){ System.out.println(Thread.currentThread().getName() + "出现异常:" + e); } System.out.println(Thread.currentThread().getName() + ":i = " + i); } } public void excepTest(int i)throws Exception{ if(i == 8){ throw new Exception("这是手动抛出异常!"); } } } public class JavaTest22_05{ public static void main(String args[]){ Test22_05 t1 = new Test22_05(); Thread tt1 = new Thread(t1); Thread tt2 = new Thread(t1); Thread tt3 = new Thread(t1); tt1.setName("线程1"); tt2.setName("线程2"); tt3.setName("线程3"); tt1.start(); tt2.start(); tt3.start(); tt1.start(); } }

蛮大人123 2019-12-02 01:52:21 0 浏览量 回答数 0

回答

您可以创建采用通用列表的通用方法,以Predicate在过滤后获取第一个匹配项 private <T> T findFeature(List<T> list, Predicate<T> predicate) { return list.stream().filter(predicate).findFirst().orElse(null); } 然后Predicate使用所需的类型创建并调用该方法 Predicate< Feature > filter = f->f.getName().equalsIgnoreCase(name); findFeature(list,filter); 另一方面,也可以返回Optional 而不是null找不到元素时返回: private <T> Optional<T> findFeature(List<T> list, Predicate<T> predicate) { return list.stream().filter(predicate).findFirst(); } 回答来源:Stack Overflow

montos 2020-03-22 14:18:11 0 浏览量 回答数 0

问题

A P T安全解决方案有哪些

网时 2019-12-01 19:24:13 1657 浏览量 回答数 0

问题

Java泛型方法来过滤和查找列表中的第一个元素

montos 2020-03-22 14:17:12 1 浏览量 回答数 1
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 SQL审核 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 人工智能 阿里云云栖号 云栖号案例 云栖号直播