精华内容
下载资源
问答
  • 这差不多是一个关于数组设计的风格指南,但是把它添加到对象设计...使用数组作为列表所有元素都应该具有相同的类型当使用一个数组作为一个列表(一个具有特定顺序的值的集合)时,每个值应该是 z 类型:$goodList = [...

    7c60eb369b68d0cd6f81abd65475c432.png

    这差不多是一个关于数组设计的风格指南,但是把它添加到对象设计风格指南感觉不太对,因为不是所有的面向对象语言都有动态数组。本文中的示例是用 PHP 编写的,因为 PHP 很像 Java(可能比较熟悉),但是使用的是动态数组而不是内置的集合类和接口。

    使用数组作为列表

    所有元素都应该具有相同的类型

    当使用一个数组作为一个列表(一个具有特定顺序的值的集合)时,每个值应该是 z 类型:$goodList = [

    'a',

    'b'

    ];

    $badList = [

    'a',

    1

    ];

    一个被普遍接受的注释列表类型的风格是:@var array。 确保不添加索引的类型(它总是int)。

    应该忽略每个元素的索引

    PHP 将自动为列表中的每个元素(0、1、2等)创建新索引。然而,你不应该依赖这些索引,也不应该直接使用它们。客户端应该依赖的列表的唯一属性是可迭代的和可计数的。

    因此,可以随意使用foreach和count(),但不要使用for循环遍历列表中的元素:// 好的循环:

    foreach ($list as $element) {

    }

    // 不好的循环 (公开每个元素的索引):

    foreach ($list as $index => $element) {

    }

    // 也是不好的循环 (不应该使用每个元素的索引):

    for ($i = 0; $i < count($list); $i++) {

    }

    (在 PHP 中,for循环甚至可能不起作用,因为列表中可能缺少索引,而且索引可能比列表中的元素数量还要多。)

    使用过滤器而不是删除元素

    你可能希望通过索引从列表中删除元素(unset()),但是,你应该使用array_filter()来创建一个新列表(没有不需要的元素),而不是删除元素。

    同样,你不应该依赖于元素的索引,因此,在使用array_filter()时,不应该使用flag 参数去根据索引过滤元素,甚至根据元素和索引过滤元素。// 好的过滤:

    array_filter(

    $list,

    function (string $element): bool {

    return strlen($element) > 2;

    }

    );

    // 不好的过滤器(也使用索引来过滤元素)

    array_filter(

    $list,

    function (int $index): bool {

    return $index > 3;

    },

    ARRAY_FILTER_USE_KEY

    );

    // 不好的过滤器(同时使用索引和元素来过滤元素)

    array_filter(

    $list,

    function (string $element, int $index): bool {

    return $index > 3 || $element === 'Include';

    },

    ARRAY_FILTER_USE_BOTH

    );

    使用数组作为映射

    当键是相关的,而不是索引(0,1,2,等等)。你可以随意使用数组作为映射(可以通过其唯一的键从其中检索值)。

    所有的键应该是相同的类型

    使用数组作为映射的第一个规则是,数组中的所有键都应该具有相同的类型(最常见的是string类型的键)。$goodMap = [

    'foo' => 'bar',

    'bar' => 'baz'

    ];

    // 不好(使用不同类型的键)

    $badMap = [

    'foo' => 'bar',

    1 => 'baz'

    ];

    所有的值都应该是相同的类型

    映射中的值也是如此:它们应该具有相同的类型。$goodMap = [

    'foo' => 'bar',

    'bar' => 'baz'

    ];

    // 不好(使用不同类型的值)

    $badMap = [

    'foo' => 'bar',

    'bar' => 1

    ];

    一种普遍接受的映射类型注释样式是: @var array。

    映射应该保持私有

    列表可以安全地在对象之间传递,因为它们具有简单的特征。任何客户端都可以使用它来循环其元素,或计数其元素,即使列表是空的。映射则更难处理,因为客户端可能依赖于没有对应值的键。这意味着在一般情况下,它们应该对管理它们的对象保持私有。不允许客户端直接访问内部映射,而是提供 getter (可能还有 setter )来检索值。如果请求的键不存在值,则抛出异常。但是,如果您可以保持映射及其值完全私有,那么就这样做。// 公开一个列表是可以的

    /**

    * @return array

    */

    public function allUsers(): array

    {

    // ...

    }

    // 公开地图可能很麻烦

    /**

    * @return array

    */

    public function usersById(): array

    {

    // ...

    }

    // 相反,提供一种方法来根据其键检索值

    /**

    * @throws UserNotFound

    */

    public function userById(string $id): User

    {

    // ...

    }

    对具有多个值类型的映射使用对象

    当你想要在一个映射中存储不同类型的值时,请使用一个对象。定义一个类,并向其添加公共的类型化属性,或添加构造函数和 getter。像这样的对象的例子是配置对象,或者命令对象:final class SillyRegisterUserCommand

    {

    public string $username;

    public string $plainTextPassword;

    public bool $wantsToReceiveSpam;

    public int $answerToIAmNotARobotQuestion;

    }

    这些规则的例外

    有时,库或框架需要以更动态的方式使用数组。在这些情况下,不可能(也不希望)遵循前面的规则。例如数组数据,它将被存储在一个数据库表中,或者Symfony 表单配置。

    自定义集合类

    自定义集合类是一种非常酷的方法,最后可以和Iterator、ArrayAccess和其朋友一起使用,但是我发现大多数生成的代码令人很困惑。第一次查看代码的人必须在 PHP 手册中查找详细信息,即使他们是有经验的开发人员。另外,你需要编写更多的代码,你必须维护这些代码(测试、调试等)。所以在大多数情况下,我发现一个简单的数组,加上一些适当的类型注释,就足够了。到底什么是需要将数组封装到自定义集合对象中的强信号?如果你发现与那个数组相关的逻辑被复制了。

    如果你发现客户端必须处理太多关于数组内部内容的细节。

    使用自定义集合类来防止重复逻辑

    如果使用相同数组的多个客户端执行相同的任务(例如过滤、映射、减少、计数),则可以通过引入自定义集合类来消除重复。将重复的逻辑移到集合类的一个方法上,允许任何客户端使用对集合的简单方法调用来执行相同的任务:$names = [/* ... */];

    // 在几个地方发现:

    $shortNames = array_filter(

    $names,

    function (string $element): bool {

    return strlen($element) < 5;

    }

    );

    // 变成一个自定义集合类:

    use Assert\Assert;

    final class Names

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function shortNames(): self

    {

    return new self(

    array_filter(

    $this->names,

    function (string $element): bool {

    return strlen($element) < 5;

    }

    )

    );

    }

    }

    $names = new Names([/* ... */]);

    $shortNames = $names->shortNames();

    在集合的转换上使用方法的好处就是获得了一个名称。这使你能够向看起来相当复杂的array_filter()调用添加一个简短而有意义的标签。

    使用自定义集合类来解耦客户端

    如果一个客户端使用特定的数组并循环,从选定的元素中取出一段数据,并对该数据进行处理,那么该客户端就与所有涉及的类型紧密耦合: 数组本身、数组中元素的类型、它从所选元素中检索的值的类型、选择器方法的类型,等等。这种深度耦合的问题是,在不破坏依赖于它们的客户端的情况下,很难更改所涉及类型的任何内容。因此,在这种情况下,你也可以将数组包装在一个自定义 的集合类中,让它一次性给出正确的答案,在内部进行必要的计算,让客户端与集合更加松散地耦合。$lines = [];

    $sum = 0;

    foreach ($lines as $line) {

    if ($line->isComment()) {

    continue;

    }

    $sum += $line->quantity();

    }

    // Turned into a custom collection class:

    final class Lines

    {

    public function totalQuantity(): int

    {

    $sum = 0;

    foreach ($lines as $line) {

    if ($line->isComment()) {

    continue;

    }

    $sum += $line->quantity();

    }

    return $sum;

    }

    }

    自定义集合类的一些规则

    让我们看看在使用自定义集合类时应用的一些规则。

    让它们不可变

    对集合实例的现有引用在运行某种转换时不应受到影响。因此,任何执行转换的方法都应该返回类的一个新实例,就像我们在上面的例子中看到的那样:final class Names

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function shortNames(): self

    {

    return new self(

    /* ... */

    );

    }

    }

    当然,如果要映射内部数组,则可能要映射到另一种类型的集合或简单数组。与往常一样,请确保提供适当的返回类型。

    只提供实际客户需要和使用的行为

    你不必扩展泛型集合库类,也不必自己在每个自定义集合类上实现泛型筛选器、映射和缩减方法,只实现真正需要的。如果某个方法在某一时刻不被使用,那么就删除它。

    使用 IteratorAggregate 和 ArrayIterator 来支持迭代

    如果你使用 PHP,不用实现所有的Iterator接口的方法(并保持一个内部指针,等等),只是实现IteratorAggregate接口,让它返回一个ArrayIterator实例基于内部数组:final class Names implements IteratorAggregate

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function getIterator(): Iterator

    {

    return new ArrayIterator($this->names);

    }

    }

    $names = new Names([/* ... */]);

    foreach ($names as $name) {

    // ...

    }

    权衡考虑

    为你的自定义集合类编写更多代码的好处是使客户端更容易地使用该集合(而不是仅仅使用一个数组)。如果客户端代码变得更容易理解,如果集合提供了有用的行为,那么维护自定义集合类的额外成本就是合理的。但是,因为使用动态数组非常容易(主要是因为你不必写出所涉及的类型),所以我不经常介绍自己的集合类。尽管如此,我知道有些人是它们的伟大支持者,所以我将确保继续寻找潜在的用例。

    推荐教程:《PHP》

    展开全文
  • C# 自定义集合

    2021-01-31 21:07:29
    C#自定义集合 集合 //自定义集合 public class Myset<T> { private const int defualtSize = 4; private T[] items; private int _size; private T[] emptyArray = new T[0]; public int Count { ...

    C#自定义集合

    集合

    
        //自定义集合
        public class Myset<T>
        {
            private const int defualtSize = 4;
            private T[] items;
            private int _size;
            private T[] emptyArray = new T[0];
    
    
            public int Count
            {
                get
                {
                    return _size;
                }
            }
    
            public T this[int index]
            {
                get
                { 
                    if (items == null)
                    {
                        return default(T);
    
                    }
    
                    if (index < 0 || index >= items.Length)
                    {
                        throw new Exception("数组下标异常!");
                    }
                    return items[index];
                }
    
                set
                {
                    if (items == null)
                    {
                        return ;
    
                    }
    
                    if (index < 0 || index >= items.Length)
                    {
                        throw new Exception("数组下标异常!");
                    }
                    items[index] = value;
                }
            }
    
            public Myset()
            {
                items = emptyArray;
            }
    
            public Myset(int size)
            {
                items = new T[size];
            }
    
            //添加数据
    
            public void Add(T item)
            {
                if (item == null)
                {
                    throw new Exception("添加的元素不能为空!");
                }
    
                if (_size == items.Length)
                {
                    //说明我们的数组放满了
                    //扩容之后的长度
                    int num = (items.Length == 0) ? defualtSize : items.Length * 2;
                    SetCapacity(num);
                }
    
                items[_size] = item;
                _size++;
                //TODO
    
            }
    
            //移除数据
            public bool Remove(T item)
            {
                if (item == null)
                {
                    throw new Exception("移除的元素不能为空!");
                }
    
                //找到要移除元素的下标
                int index = IndexOf(item);
                //把后面的元素往前挪一位
                if (index >= 0)
                {
                    Array.Copy(items, index + 1, items, index, _size - index - 1);
                    //把最后的元素设置为空
                    items[_size - 1] = default(T);
                    //把长度--
                    _size--;
                    return true;
    
                }
    
                return false;
            }
    
            //清空的方法
            public void Clear()
            {
    
                if(_size > 0)
                {
                    Array.Clear(items, 0, _size);
                    _size = 0;
                }
            }
    
            //扩容的方法
            public void SetCapacity(int length)
            {
                if (length <= _size)
                {
                    throw new Exception("扩容的长度不能比当前的长度小!");
                }
    
                T[] array = new T[length];
                if (_size > 0)
                {
                    Array.Copy(items, array, _size);
    
                }
                items = array;
            }
    
            public int IndexOf(T item)
            {
                for (int i = 0; i < _size; i++)
                {
                    if (items[i].Equals(item)) { return i; }
                }
    
                return -1;
    
            }
        }
    
    
    

    测试

    class TestMyset
        {
            static void Main(string[] args)
            {
                Myset<int> myset = new Myset<int>();
                myset.Add(1);
                myset.Add(2);
                myset.Add(3);
                myset.Add(4);
    
                myset.Remove(4);
    
                for (int i = 0; i < myset.Count; i++)
                {
                    Console.WriteLine(" i : {0} v : {1} ",i,myset[1]);
                }
    
                myset.Clear();
    
                for (int i = 0; i < myset.Count; i++)
                {
                    Console.WriteLine(" i : {0} v : {1} ", i, myset[1]);
                }
    
                Console.ReadLine();
            }
        }
    
    展开全文
  • 我试图json序列化一个类MyRootClass与一个属性,该属性是第二个类MyClass的元素的集合:public class MyRootClass {private List list = new ArrayList();// getter / setter}public class MyClass implements ...

    我试图json序列化一个类MyRootClass与一个属性,该属性是第二个类MyClass的元素的集合:

    public class MyRootClass {

    private List list = new ArrayList();

    // getter / setter

    }

    public class MyClass implements MyInterface {

    private String value = "test";

    // getter / setter

    }

    以下代码:

    MyRootClass root = new MyRootClass();

    root.getList().add(new MyClass());

    ObjectMapper mapper = new ObjectMapper();

    mapper.writeValue(System.out, root);

    生成此JSON输出:

    {"list": [ {"value":"test"} ] }

    而不是我需要的,集合中的每个对象都用一个名称序列化:

    {"list": [ {"myclass": {"value":"test"}} ] }

    有没有办法用Jackson实现它?我考虑过编写一个自定义序列化程序,但是我找不到任何与对象集合相关的东西.

    展开全文
  • 下面是我使用处理动态数组的一些规则。这差不多是一个关于数组设计的风格指南,但是把它...使用数组作为列表所有元素都应该具有相同的类型当使用一个数组作为一个列表(一个具有特定顺序的值的集合)时,每个值应该是 ...

    729fc9e1895c9eb967d431aab0e9bbd6.png

    下面是我使用处理动态数组的一些规则。这差不多是一个关于数组设计的风格指南,但是把它添加到对象设计风格指南感觉不太对,因为不是所有的面向对象语言都有动态数组。本文中的示例是用 PHP 编写的,因为 PHP 很像 Java(可能比较熟悉),但是使用的是动态数组而不是内置的集合类和接口。

    使用数组作为列表

    所有元素都应该具有相同的类型

    当使用一个数组作为一个列表(一个具有特定顺序的值的集合)时,每个值应该是 z 类型:

    $goodList = [

    'a',

    'b'

    ];

    $badList = [

    'a',

    1

    ];

    一个被普遍接受的注释列表类型的风格是:@var array。 确保不添加索引的类型(它总是int)。

    应该忽略每个元素的索引

    PHP 将自动为列表中的每个元素(0、1、2等)创建新索引。然而,你不应该依赖这些索引,也不应该直接使用它们。客户端应该依赖的列表的唯一属性是可迭代的和可计数的。

    因此,可以随意使用foreach和count(),但不要使用for循环遍历列表中的元素:

    // 好的循环:

    foreach ($list as $element) {

    }

    // 不好的循环 (公开每个元素的索引):

    foreach ($list as $index => $element) {

    }

    // 也是不好的循环 (不应该使用每个元素的索引):

    for ($i = 0; $i < count($list); $i++) {

    }

    (在 PHP 中,for循环甚至可能不起作用,因为列表中可能缺少索引,而且索引可能比列表中的元素数量还要多。)

    使用过滤器而不是删除元素

    你可能希望通过索引从列表中删除元素(unset()),但是,你应该使用array_filter()来创建一个新列表(没有不需要的元素),而不是删除元素。

    同样,你不应该依赖于元素的索引,因此,在使用array_filter()时,不应该使用flag 参数去根据索引过滤元素,甚至根据元素和索引过滤元素。

    // 好的过滤:

    array_filter(

    $list,

    function (string $element): bool {

    return strlen($element) > 2;

    }

    );

    // 不好的过滤器(也使用索引来过滤元素)

    array_filter(

    $list,

    function (int $index): bool {

    return $index > 3;

    },

    ARRAY_FILTER_USE_KEY

    );

    // 不好的过滤器(同时使用索引和元素来过滤元素)

    array_filter(

    $list,

    function (string $element, int $index): bool {

    return $index > 3 || $element === 'Include';

    },

    ARRAY_FILTER_USE_BOTH

    );

    使用数组作为映射

    当键是相关的,而不是索引(0,1,2,等等)。你可以随意使用数组作为映射(可以通过其唯一的键从其中检索值)。

    所有的键应该是相同的类型

    使用数组作为映射的第一个规则是,数组中的所有键都应该具有相同的类型(最常见的是string类型的键)。

    $goodMap = [

    'foo' => 'bar',

    'bar' => 'baz'

    ];

    // 不好(使用不同类型的键)

    $badMap = [

    'foo' => 'bar',

    1 => 'baz'

    ];

    所有的值都应该是相同的类型

    映射中的值也是如此:它们应该具有相同的类型。

    $goodMap = [

    'foo' => 'bar',

    'bar' => 'baz'

    ];

    // 不好(使用不同类型的值)

    $badMap = [

    'foo' => 'bar',

    'bar' => 1

    ];

    一种普遍接受的映射类型注释样式是: @var array。

    映射应该保持私有

    列表可以安全地在对象之间传递,因为它们具有简单的特征。任何客户端都可以使用它来循环其元素,或计数其元素,即使列表是空的。映射则更难处理,因为客户端可能依赖于没有对应值的键。这意味着在一般情况下,它们应该对管理它们的对象保持私有。不允许客户端直接访问内部映射,而是提供 getter (可能还有 setter )来检索值。如果请求的键不存在值,则抛出异常。但是,如果您可以保持映射及其值完全私有,那么就这样做。

    // 公开一个列表是可以的

    /**

    * @return array

    */

    public function allUsers(): array

    {

    // ...

    }

    // 公开地图可能很麻烦

    /**

    * @return array

    */

    public function usersById(): array

    {

    // ...

    }

    // 相反,提供一种方法来根据其键检索值

    /**

    * @throws UserNotFound

    */

    public function userById(string $id): User

    {

    // ...

    }

    对具有多个值类型的映射使用对象

    当你想要在一个映射中存储不同类型的值时,请使用一个对象。定义一个类,并向其添加公共的类型化属性,或添加构造函数和 getter。像这样的对象的例子是配置对象,或者命令对象:

    final class SillyRegisterUserCommand

    {

    public string $username;

    public string $plainTextPassword;

    public bool $wantsToReceiveSpam;

    public int $answerToIAmNotARobotQuestion;

    }

    这些规则的例外

    有时,库或框架需要以更动态的方式使用数组。在这些情况下,不可能(也不希望)遵循前面的规则。例如数组数据,它将被存储在一个数据库表中,或者Symfony 表单配置。

    自定义集合类

    自定义集合类是一种非常酷的方法,最后可以和Iterator、ArrayAccess和其朋友一起使用,但是我发现大多数生成的代码令人很困惑。第一次查看代码的人必须在 PHP 手册中查找详细信息,即使他们是有经验的开发人员。另外,你需要编写更多的代码,你必须维护这些代码(测试、调试等)。所以在大多数情况下,我发现一个简单的数组,加上一些适当的类型注释,就足够了。到底什么是需要将数组封装到自定义集合对象中的强信号?

    如果你发现与那个数组相关的逻辑被复制了。

    如果你发现客户端必须处理太多关于数组内部内容的细节。

    使用自定义集合类来防止重复逻辑

    如果使用相同数组的多个客户端执行相同的任务(例如过滤、映射、减少、计数),则可以通过引入自定义集合类来消除重复。将重复的逻辑移到集合类的一个方法上,允许任何客户端使用对集合的简单方法调用来执行相同的任务:

    $names = [/* ... */];

    // 在几个地方发现:

    $shortNames = array_filter(

    $names,

    function (string $element): bool {

    return strlen($element) < 5;

    }

    );

    // 变成一个自定义集合类:

    use Assert\Assert;

    final class Names

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function shortNames(): self

    {

    return new self(

    array_filter(

    $this->names,

    function (string $element): bool {

    return strlen($element) < 5;

    }

    )

    );

    }

    }

    $names = new Names([/* ... */]);

    $shortNames = $names->shortNames();

    在集合的转换上使用方法的好处就是获得了一个名称。这使你能够向看起来相当复杂的array_filter()调用添加一个简短而有意义的标签。

    使用自定义集合类来解耦客户端

    如果一个客户端使用特定的数组并循环,从选定的元素中取出一段数据,并对该数据进行处理,那么该客户端就与所有涉及的类型紧密耦合: 数组本身、数组中元素的类型、它从所选元素中检索的值的类型、选择器方法的类型,等等。这种深度耦合的问题是,在不破坏依赖于它们的客户端的情况下,很难更改所涉及类型的任何内容。因此,在这种情况下,你也可以将数组包装在一个自定义 的集合类中,让它一次性给出正确的答案,在内部进行必要的计算,让客户端与集合更加松散地耦合。

    $lines = [];

    $sum = 0;

    foreach ($lines as $line) {

    if ($line->isComment()) {

    continue;

    }

    $sum += $line->quantity();

    }

    // Turned into a custom collection class:

    final class Lines

    {

    public function totalQuantity(): int

    {

    $sum = 0;

    foreach ($lines as $line) {

    if ($line->isComment()) {

    continue;

    }

    $sum += $line->quantity();

    }

    return $sum;

    }

    }

    自定义集合类的一些规则

    让我们看看在使用自定义集合类时应用的一些规则。

    让它们不可变

    对集合实例的现有引用在运行某种转换时不应受到影响。因此,任何执行转换的方法都应该返回类的一个新实例,就像我们在上面的例子中看到的那样:

    final class Names

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function shortNames(): self

    {

    return new self(

    /* ... */

    );

    }

    }

    当然,如果要映射内部数组,则可能要映射到另一种类型的集合或简单数组。与往常一样,请确保提供适当的返回类型。

    只提供实际客户需要和使用的行为

    你不必扩展泛型集合库类,也不必自己在每个自定义集合类上实现泛型筛选器、映射和缩减方法,只实现真正需要的。如果某个方法在某一时刻不被使用,那么就删除它。

    使用 IteratorAggregate 和 ArrayIterator 来支持迭代

    如果你使用 PHP,不用实现所有的Iterator接口的方法(并保持一个内部指针,等等),只是实现IteratorAggregate接口,让它返回一个ArrayIterator实例基于内部数组:

    final class Names implements IteratorAggregate

    {

    /**

    * @var array

    */

    private array $names;

    public function __construct(array $names)

    {

    Assert::that()->allIsString($names);

    $this->names = $names;

    }

    public function getIterator(): Iterator

    {

    return new ArrayIterator($this->names);

    }

    }

    $names = new Names([/* ... */]);

    foreach ($names as $name) {

    // ...

    }

    权衡考虑

    为你的自定义集合类编写更多代码的好处是使客户端更容易地使用该集合(而不是仅仅使用一个数组)。如果客户端代码变得更容易理解,如果集合提供了有用的行为,那么维护自定义集合类的额外成本就是合理的。但是,因为使用动态数组非常容易(主要是因为你不必写出所涉及的类型),所以我不经常介绍自己的集合类。尽管如此,我知道有些人是它们的伟大支持者,所以我将确保继续寻找潜在的用例。

    本文中的所有译文仅用于学习和交流目的,转载请务必注明文章译者、出处、和本文链接

    我们的翻译工作遵照 CC 协议,如果我们的工作有侵犯到您的权益,请及时联系我们。

    展开全文
  • 话不多说,看代码:1、封装的自定义集合工具类:CollectionsCustompackage com.test.util;import java.util.Collection;import org.apache.commons.collections.CollectionUtils;/*** 自定义...
  • 基于自定义集合 //迭代器 public class MysetIEnumerator <T> : IEnumerator //具体的迭代器 { private int position; //当前迭代器所指向的位置 private Myset<T> myset; public ...
  • 自定义Java集合

    2021-03-01 06:49:06
    packagecom.collection.linkedList;public class MyLinkedList{private Node header;//链表的节点头private Node tail;//链表的结尾private int size;//记录当前元素的大小publicMyLinkedList() {}/*** 在某个位置...
  • public class Person { private string _name; private int _age; public Person(string name, int age) { this._name = name; this._age = age; } public string Name { get { return this._... set { th
  • 我有一个嵌入式表单的集合.我想自定义嵌入的表单.我希望嵌入式表单的每个条目都在1行中,类似于:field1field2但在我看来,symfony的doc对此很不利.我有一个表单ApplicationType:public function buildForm...
  • I come from a Matlab background. In matlab I can create a class definition and then create an array of objects. I can easily dereference each object with an index. In addition, when I call a method...
  • 有点懒,说几个点吧,一个是自定义排序的时候,百度一写1和-1返回值表达的意思,这关系到升序还是降序; 比较元素大小时,如果返回正数(比如1),则表示排序靠后; 如果返回复数(比如-1),则表示排序靠前。 下面是一...
  • √ C# - 23.怎么自定义集合(P496)

    万次阅读 2021-03-31 15:13:53
    集合的本质是一个类,它至少实现了IEnumerable接口,因此,IEnumerable接口使类成为集合。 为了使集合更加规范,通常也会实现ICollection接口和索引器。 实现方法时注意异常判断,以下只是基本功能实现。 using ...
  • 参数List 里面是自定义对象 collection 这里对应 mapper里面@Param的名称 item 这里对应每个迭代元素的别名, #{ user.name} 是item的一个属性
  • //集合是具有共同属性(共性)而又能互相区别(个性)的...自定义集合运算包括以下操作: // 1) 判断元素elem是否为集合set的元素。 // 2) 为集合添加一个元素elem。 // 3) 从集合中删除一个元素elem。 // 4) 复制一个.
  • 是否有java 8方式执行以下操作?for(int i;i<=100;i++){Person person=new Person();person.setId(i);person.setName("name"+i);list.add(person)}解决方法:是:IntStream.rangeClosed(0, 100).forEach(i ->...
  • mybatis提供的构造器可以很简单的实现,这里主要说一下关于自定义sql的处理。 注解方式和xml其实差不多,大伙看个核心就好。 @Select({"<script>" + " select * from 表 where id in <foreach ...
  • 在创建集合的时候最好是使用泛型,这样可以避免转型异常/** --|Set: 主要用来存储无序和不能重复的对象* --| HashSet** 特点:不会记录保存对象时候的顺序,但是执行的结果是唯一,不像线程那样* 原理:底层是用的是...
  • Java 自定义工具类实现List分页Java 自定义工具类实现List分页业务接口/*** 订购实例查询接口** @param input* @return*/@ApiOperation(value = "订购实例查询接口", notes = "入参:userId、pageSize(分页数据条数)...
  • [java]代码库1.package s0223排序比较器_推荐使用comparator;//排序比较的2种实现方法//1. 实体类 java.lang.Comparable ...自定义比较器,implements java.util.Comparator,然后重写compare()方法public class ...
  • 结果: {name=思思博士, age=25} 2 思思博士 java.util.HashMap String 转成我们的自定义类 UserBean.java packagejson;public classUserBean {privateString name;privateString age;publicString getName() {...
  • 自定义聚合函数,分析函数--from GTA Aaron最近做一数据项目要用到连乘的功能,而Oracle数据库里没有这样的预定义聚合函数,当然利用数据库已有的函数进行数学运算也可以达到这个功能,如:selectexp(sum(ln(field_...
  • 自定义对象作为元素存到ArrayList集合中,并去除重复元素。比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。思路:1,对人描述,将数据封装进人对象。2,定义容器,将人存入。3,取出。List集合判断元素...
  • 1. 集合的定义什么是集合呢?定义:集合是一个存放对象的引用的容器。在Java中,集合位于java.util包下。2. 集合和数组的区别(面试常问)提到容器,就会想起数组,那么集合和数组的区别是什么呢?(这里是重点,面试...
  • 所以需要我们自定义注解. 废话不多说, 直接上代码实现 (其它校验方式, 同理) 代码实现 自定义注解 /** * 使用方式: * @IncludeValid(value = {"0","1"}, message = "状态值必须为0,1") * private Integer ...
  • 集合(collection)

    2021-02-07 20:11:29
    使用数组存放数据的弊端:长度不可变,而集合可以动态的添加值java集合类不仅可以存储数量不等的多个对象,还可以保存具有映射关系的关联数组/** 1.存储对象可以考虑:①数组 ②集合* 2.数组存储对象的特点:Student...
  • Java集合框架针对不同的数据结构提供了多种排序的方法,虽然很多时候我们可以自己实现排序,比如数组等,但是灵活的使用JDK提供的排序方法,可以提高开发效率,而且通常JDK的实现要比自己造的轮子性能更优化。...
  • 1、拥有自定义对象 MyUser @Data public class MyUser { private String userName; private String passWord; } 2、编写自定义去重方法实现 /** * 根据list中对象某些字段去重 * @param list 需要去重的list...
  • json字符串转换为java自定义对象(我选择的是ArrayList,因为可能我转出来的java类有几个) /* * 调用ObjectMapper 对象的readValue即可,传入的两个参数: * 第一个为json字符串,第二个为你所需的java对象的类 **...
  • 说明: 提示:这篇文章仅是记录自己成长路上的愚笨,不喜勿喷,同时也希望各路大神提出优秀的观点。谢谢!! 问题需求: 项目中想通过mybatis查询后直接返回DataFrame数据结构的数据,但是mybatis的ResultType又不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 511,264
精华内容 204,505
关键字:

自定义集合