标签: generic-collections

System.Collections.Queueclass具有Queue.Synchronized返回线程安全的Queue实现的方法.

但是通用的,System.Collections.Generic.Queue 没有Synchronized方法.在这一点上,我有两个问题:

1. 为什么通用的没有这种方法？它是一个框架API设计决策吗？
2. 返回的队列 Queue.Synchronized与ConcurrentQueue<T>类不同？

谢谢.

我正在使用Spring RestTemplate来对REST Web服务进行调用.其中一个调用是返回某种类型的对象列表.这些RestTemplate方法要求提供类参数以指示预期的返回类型.

// restTemplate is type org.springframework.web.client.RestTemplate
URI restServiceURI = new URI("http://example.com/foo")
restTemplate.getForObject(restServiceURI, List<Foo>.class);

显然,这不编译..class当您提供类似的类型参数时,您无法获得静态属性.我删除type参数时会编译代码,但会生成rawtypes编译器警告.

我的问题很简单.我是坚持抑制编译器警告还是有更简洁的方法来代码？

我有一个解析数据流的类.每个数据块称为a Box.Boxes 有很多种.我希望Parser每种类型的盒子都有不同的颜色.所以基本上我需要一个Registry或类似的东西,让我为每个提取正确的解析器Box.这是我的问题的简化版本:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class GenericsTest {
    class Box {
        private String data;

        public String getData() {
            return data;
        }
    }

    class BoxA extends Box {
        private String adata;

        BoxA( String adata ) {
            this.adata = adata;
        }

        public String getAData() {
            return adata;
        }
    }

    class BoxB extends Box {
        private String bdata;

        BoxB( String bdata ) {
            this.bdata = bdata;
        } …

如果我理解正确(如果我错了请纠正我),列表是由.NET中的数组实现的,这意味着列表中每个项目的删除都会导致重新分配所有列表(这意味着O(n)).

我正在开发一款游戏,在游戏中我有许多子弹在任何给定时刻在空中飞行,让我们说100个子弹,每帧我移动几个像素并检查与游戏中物体的碰撞,我需要删除从列表中每个碰撞的子弹.

所以我在另一个临时列表中收集了碰撞的子弹,然后执行以下操作:

foreach (Bullet bullet in bulletsForDeletion)
    mBullets.Remove(bullet);

因为循环是O(n)和删除O(n),我花费O(n^2时间删除.

有没有更好的方法来删除它,或更合适的集合使用？

有没有办法在 C 中创建通用数据结构并根据存储的数据类型使用函数，该结构具有各种类型的数据，例如可以根据存储的数据进行打印。

例如，

假设我希望创建一个只存储 float 和 int 的二叉搜索树。自然的方法是创建一个包含 int 和 float 的枚举。它看起来像这样：

Typedef enum {INT, FLOAT} DataType;

Typedef struct node
{
    void *data;
    DataType t;
    struct node *left,
                *right;
}Node;

如果我想打印出来：

void printTree(Node *n)
{
    if (n != NULL)
    {
        if (n->t == INT)
        {
            int *a = (int *) n->data;
            printf("%d ", *a);
        }
        else
        {
            float *a = (float *) n->data;
            printf("%f ", *a);
        }

        printTree(n->left);
        printTree(n->right);
    }
}

没关系，但我想将另一种数据类型存储为堆栈、查询或其他内容。这就是为什么我创建了一个不依赖于特定数据类型的树，例如：

Typedef struct node
{
    void *data;
    struct …

当您使用LINQ来定义可枚举集合时,无论是使用LINQ扩展方法还是使用查询运算符,应用程序实际上都不会在执行LINQ扩展方法时构建集合.只有在迭代它时才会枚举该集合.这意味着原始集合中的数据可以在执行LINQ查询和检索查询标识的数据之间进行更改; 您将始终获取最新的数据.

Microsoft Visual C#2013一步一步由John Sharp编写

我写了以下代码:

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5 };
IEnumerable<int> res = numbers.FindAll(a => a > 0).Select(b => b).ToList();
numbers.Add(99);
foreach (int item in res)
    Console.Write(item + ", ");

以上代码的结果如下所示:

1,2,3,4,5,

为什么会这样？我知道Func,Action和Predicate,但我无法弄清楚这到底是怎么回事.基于上面的定义,代码是不合理的.

我用Java编写了这样的DTO类:

public class AnswersDto {
    private String uuid;
    private Set<AnswerDto> answers;
}

public class AnswerDto<T> {
    private String uuid;
    private AnswerType type;
    private T value;
}

class LocationAnswerDto extends AnswerDto<Location> {
}

class JobTitleAnswerDto extends AnswerDto<JobTitle> {
}

public enum AnswerType {
    LOCATION,
    JOB_TITLE,
}

class Location {
    String text;
    String placeId;
}

class JobTitle {
    String id;
    String name;
}

在我的项目中,Jackson库用于JSON的序列化和反序列化.

如何配置AnswersDto(使用特殊注释)或AnswerDto(注释)类,以便能够AnswersDto在其正文中正确地反序列化请求,例如:

{
    "uuid": "e82544ac-1cc7-4dbb-bd1d-bdbfe33dee73",
    "answers": [
        {
            "uuid": "e82544ac-1cc7-4dbb-bd1d-bdbfe33dee73",
            "type": "LOCATION",
            "value": …

我在将类作为方法的通用参数传递时遇到问题，我有一个简单的方法：

<T> T sendRequest(SomeRestApiRequest request, Class<T> responseClass)

它解析指定形式的响应。我以这种方式使用它们：

ItemListJSON itemList = new ItemListJSON();
itemList = someRestClient.sendRequest(req, ItemListJSON.class);

对于 ItemListJSON.class ，它看起来像这样：

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({"totalSize","items"})
public class ItemListJSON {

    @JsonProperty("items")
    private List<SalonJSON> items;

    @JsonProperty("totalSize")
    private int totalSize;

    //...getters, setters...
}

一切都很好。但我的问题是：

是否可以将泛型类作为sendRequest方法的参数传递？

我希望 ItemListJSON 类是通用的，就我而言：

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({"totalSize","items"})
public class ItemListJSON<T> {

    @JsonProperty("items")
    private List<T> items;

    @JsonProperty("totalSize")
    private int totalSize;

    //...getters, setters...
}

但是当我尝试以这种方式使用sendRequest方法时：

ItemListJSON<SalonJSON> itemList = new ItemListJSON<SalonJSON>();
itemList = someRestClient.sendRequest(req, ItemListJSON.class);

我在 Eclipse IDE 上收到警告

类型安全：ItemListJSON 类型的表达式需要未经检查的转换才能符合 ItemListJSON

当调用方法时，我在服务器控制台中收到错误：

SEVERE: …

我最近几天一直在与 Swift 上的泛型相关的一些问题作斗争，但我没有找到一种方法来弄清楚如何实现这一点：

• 我有一个类class Store<S: State>，其中State有一个扩展 Equatable 的简单协议protocol State: Equatable。
• 我有一个类Logger，我想在其中存储一个数组Stores以跟踪它们的每个更改并将它们State与旧值进行比较，从而能够检查每次迭代中的更改。

为此，我需要在我的记录器类中存储一个Any Kind of Store数组 。当我尝试使用 a 时出现问题val storeArray = [Store<Any>]，它不起作用，因为 Any 不是一种Equatable类型，我需要它们来扩展Equatable或NSObject能够比较它们之间的状态。

可以在 Swift 中实现吗？或者找出另一种方法来比较 2 个项目而不用通用扩展Equatable协议？

如果您想检查实现：

状态 ：

protocol State: Equatable {
}

店铺 ：

class Store<S: State> {

    private var _initialState: S
    private var _state: S
    private var processor = PublishSubject<S>()

    init(initialState: …

对于级别顺序遍历，为什么会发生此异常？发生以下异常：

无法将类型' System.Collections.Generic.List<System.Collections.Generic.List<int>>' 隐式转换为' System.Collections.Generic.IList<System.Collections.Generic.IList<int>>'。存在显式转换（您是否缺少演员表？）

public IList<IList<int>> LevelOrder(TreeNode root) 
{
    var result = new List<List<int>>();
    var que = new Queue<TreeNode>();

    //if(root==null) return result;

    que.Enqueue(root);
    while(que.Count!=0)
    {
        int n = que.Count;
        var subList = new List<int>();
        for(int i=0;i<n;i++)
        {
            if(que.Peek().left!=null) 
                que.Enqueue(que.Peek().left);
            if(que.Peek().right!=null)
                que.Enqueue(que.Peek().right);
            subList.Add(que.Dequeue().val);
        }
        result.Add(subList);
    }
    return  result;
}