是否有一种类型XXX<T>可以使用for-each迭代,并同时包含T[]和Iterable<T>,以便编译以下代码(假设类上下文和兼容的方法do_something)?
public void iterate(XXX<T> items)
{
for (T t : items)
do_something(t);
}
public void iterate_array(T[] items)
{
iterate(items);
}
public void iterate_iterable(Iterable<T> it
考虑以下代码示例:
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = new ArrayList<Integer>();
String response = getProducer(list).get();
}
static Producer<String> getProducer(List<Integer>
我有一个这样简单的程序:
package test;
public class TestGenericsInheritance {
public static void main(String[] args) {}
public static abstract class A<Q>{
public void foo2(Q obj){}
public abstract <T> void foo(T obj);
}
public static class C extends A<Object&g
如果在Java中将泛型类的实例声明为原始类型,那么编译器是否为所有类成员方法假定参数化的Object类型?这是否扩展到那些返回具体参数化类型的某种形式(例如Collection)的方法?
我错误地声明了一个没有参数化类型的泛型类的实例,这导致了非常有趣的下游效应。我提供了一个简单的场景示例,它产生了一个“不兼容类型”编译错误。我的基本问题是:为什么javac会产生一个“不兼容类型”错误,抱怨下面所示的行?
import java.util.*;
public class Main {
public static void main(String[] args) {
fi
public void run(){
setFont("Courier-24");
//Define list as ArrayList<Integer>
ArrayList<Integer> list = new ArrayList<Integer>();
readList(list);
}
private void readList(ArrayList list){
list.add("Hello");
list.add(2);
println("list
以下代码没有问题地编译和运行:
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Set<List<Integer>> res = new HashSet<>();
if(nums.length==0) return new ArrayList<>(res);
Arrays.sort(nums);
for(int i=0; i<nums.length-2;i+
在过去的几个小时里,为了插入Java和C++代码,我一直在玩弄CNI。
当我正在寻找使用Java集合来替换丢失libstd的旧团队的可能性时,我尝试创建一个java.util.Stack对象并对其进行操作。
然而,编译器(gcc和gcj,可能也是如此)似乎在我天真的头脑中玩弄他的廉价伎俩:
# gcc -g -I. test.cc
test.cc: In function ‘int main(int, char**)’:
test.cc:24:3: error: ‘java::util::Stack’ is not a template
Stack<Person> *stac
我已经面对过这个问题了。我已经成功地从JBoss中查找了我的远程bean,但是当我尝试调用它的任何方法时,下一个异常即将出现:
java.lang.Class cannot be cast to java.lang.String.
完整堆栈跟踪是:
java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.String
at org.jboss.ejb.client.remoting.ProtocolMessageHandler.readAttachments(ProtocolMessageHandler
我有一个通用的Item-interface和一个具有date属性的实现,如下所示:
public interface Item<T extends Temporal> {
T getDate();
}
public class SpecialItem implements Item<LocalDateTime> {
private final LocalDateTime localDateTime;
public SpecialItem(LocalDateTime localDateTime) {
this.localDate
当我今天使用类泛型时,我发现了一个奇怪的问题:设置一些破坏了一个完全独立的方法。
这里有一个小的示例类来说明这个问题。这段代码运行得很好
public class Sandbox {
public interface ListenerManagerTest {
public Set<Listener> getListeners();
}
public void setListenerManager(ListenerManagerTest listenerManager) {
for (Listener curListener
我调查一般的行为
我注意到:
public class Hohol1 {
public class My<T> {
public <E> void test(Collection<E> es) { System.out.println("Collection<E>");
}
public void test(List<Integer> integerList) {
System.out.println("List<Integ
在学习Java泛型时,我想知道是否可以声明一个接收两个参数的方法,第一个参数是泛型类型T,第二个参数是泛型类型S,它是T的扩展(或与T相同的类型)。因此,我开始对此进行实验,并编写了以下方法声明:
public static <T, S extends T> void testMethod(T t, S s)
{
System.out.println("We are inside testMethod.");
}
然后,我以两种方式调用此方法,如下所示:
java.lang.Integer num1 = new java.lang.Integer(0);
j
调用C-函数时,可以通过传递可以转换/提升为更宽类型的窄类型来调用更宽的类型。
例如:
void FooBar(uint32_t alpha); // Function takes a 32-bit unsigned value
int main(void)
{
uint16_t foo = 232; // Variable foo is 16-bit unsigned
FooBar(foo); // 16-bit value gets auto-promoted to 32-bit value for the function call.
}
然而,当我
我试图使用泛型在Java中执行以下操作:
public class MyType {
public void printBase(Collection<Base> bases) {
for (Base base : bases) {
System.out.println(base.toString());
}
}
public <A extends Base> void myMethod(Collection<A> things) {
// ...
我读到了Java的类型擦除。
类型擦除何时发生?在编译时还是运行时发生?当类加载的时候?当类被实例化时?
很多站点(包括上面提到的官方教程)都说类型擦除发生在编译时。如果类型信息在编译时被完全删除,那么当使用泛型的方法被调用时没有类型信息或错误类型信息时,JDK如何检查类型兼容性?
考虑以下示例:假设类A有一个方法,empty(Box<? extends Number> b)。我们编译A.java并获得类文件A.class。
public class A {
public static void empty(Box<? extends Number> b) {}
我有这段代码,它无法编译:
import java.util.ArrayList;
import java.util.List;
public class TypeSafetyTest {
public static void main(String[] args) {
TypeSafetyTest test = new TypeSafetyTest();
test.run();
}
private void run() {
Car car = new Car();
List<String>
请有人解释一下,为什么需要为ForEachLoop实例指定泛型类型?
编译器抱怨的原因:类型不匹配:不能从元素类型对象转换为字符串
JDK 1.5.0_09
import java.util.ArrayList;
import java.util.Collection;
public class ForEachLoop<T> {
public static void main(String[] args) {
// Non functional version
ForEachLoop f = new ForEachLoop();
// Functi
今天,我偶然发现了一些我根本不希望编译的工作Java代码。如果降到最低限度,它看起来如下:
import java.util.List;
interface A {
<T> List<String> foo();
}
interface B {
<T> List<Integer> foo();
}
class C implements A, B {
@Override
public List<?> foo()
{
return null;
}
}
乍一看,<T
class A<E>{
}
class B<E> extends A{
}
public class WildInDeclare<E>{
public static void main(String[] args){
A<Integer> obj = new B<Integer>();
}
}
当我编译上面的程序时,我得到了这个错误。
Note: WildInDeclare.java uses unchecked or unsafe operations.
Note: Recompile with
听着,我们有密码:
public class Test2 {
public static void main(String... args) {
ArrayList<Exception> a = new ArrayListFactory().create(new RuntimeException());
ArrayList<Exception> b = new ArrayListFactory().create("Z");
}
}
class ArrayListFactory {
publ
class Bouncy<T> extends Throwable {
}
// Error: the generic class Bouncy<T> may not subclass java.lang.Throwable
为什么Java不支持通用Throwable?
我意识到类型擦除会使某些事情变得复杂,但是很明显,Java已经通过了很多操作,那么为什么不把它再推一步,允许泛型Throwable,并对潜在的问题进行全面的编译时检查呢?
我觉得那种擦除式的论点很弱。目前,我们无法做到:
void process(List<String> lis
我想添加一个泛型类型方法DoSomething<T>,但为了向后兼容,我希望它只传递来自同名现有方法的泛型类型的类型参数。
public void DoSomething<T>(Data data)
{
//do something with Data, it depends on the type of T
}
public void DoSomething(Data data, Type dataType)
{
DoSomething<dataType>(group);
}
但是,新DoSomething中的<dataType&g
给定声明如下的AGenericClass:
public class AGenericClass<T> {
T subject;
public void setSubject(T subject) {
this.subject = subject;
}
}
变量a b和c之间有什么区别?
AGenericClass<String> a = new AGenericClass<>();
AGenericClass<?> b = new AGenericClass<String>();
AGenericClass c
我正在编写一个程序,它从文件中读取数字并计算它们的平均值。但是,在运行时,我会得到下面显示的错误。我试图修复它,使用转换成双倍,如代码所示,但它没有帮助。
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Double
at ReadFile.main(ReadFile.java:34)
at __SHELL40.run(__SHELL40.java:6)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Met
在学习的过程中,我陷入了困境。
它被写成"Java只工作于对象,而不是原始类型“。
e.g
Gen<Integer> gen=new Gen<Integer>(88); // Works Fine ..
但是,对于原始类型如int,char等..。
Gen<int> gen=new Gen<int>(88) ; // Why this results in compile time error
我的意思是,既然java泛型确实具有自动装箱和取消装箱功能,那么为什么当我们为类声明特定类型时不能应用这个特性呢?
我的
public class ExplicitTypeSpecification {
static void f(Map<Integer, String> map){}
public static void main(String[] args){
New c = new New();
f(c.map());
}
}
class New <K, V>{
Map<K, V> map(){
return new HashMap<K, V>();
}
}
此代码编
当我编译代码时,它会报告编译错误。我想它会运行,但报告错误!当map()阶段包含泛型字段并设置值时,
**错误消息: java:不兼容类型: java.lang.Object不能转换为java.util.List<normal.BaseWork.B>**
public class B {
private Long id;
private Map<String, Long> wk;
public Long getId() {
return id;
}
publ