自定义的Troop<T>泛型类（ c++, java和c#）的实现代码

2024-09-28 06:06:00

Troop<T>是一个泛型列表操作类，适用于非高性能和非大数据量的要求。包括了：取值get，赋值set，追加append，插入insert，清除remove，进队enqueue，出队dequeue，交换swap，滚动roll，进栈push，出栈pop等日常操作。

//for more information, please access http://www.one-lab.net

using System;
using System.Collections.Generic;
using System.Text;

namespace onelab
{
  public interface ISortable
  {
    void sort(bool decending);
  }

  public interface IStringable
  {
    int fromString(String input);
    String toString();
  }

  public class Troop<T> : ICloneable
  {
    public override int GetHashCode()
    {
      return base.GetHashCode();
    }
    public override bool Equals(object obj) { return this == (Troop<T>)obj; }
    public object Clone()
    {
      Troop<T> oValue = new Troop<T>();
      oValue.cloneFrom(this);
      return oValue;
    }
    protected bool equalsTo(Troop<T> aValue)
    {
      int len = aValue.length();
      if (len == this.length())
      {
        for (int n = 0; n < len; n++)
        {
          if (!aValue.data[n].Equals(data[n]))
            return false;
        }
        return true;
      }
      return false;
    }
    protected void cloneFrom(Troop<T> aValue)
    {
      data.Clear();
      data.AddRange(aValue.data);
    }
    public static bool operator ==(Troop<T> a0, Troop<T> a1) { object o1 = (object)a0; object o2 = (object)a1; if (o1 == null && o2 == null) return true; return (o1 == null || o2 == null) ? false : a0.equalsTo(a1); }
    public static bool operator !=(Troop<T> a0, Troop<T> a1) { object o1 = (object)a0; object o2 = (object)a1; if (o1 == null && o2 == null) return false; return (o1 == null || o2 == null) ? true : !a0.equalsTo(a1); }
    private bool mHasError = false;
    public bool hasError() { return mHasError; }
    public List<T> data = new List<T>();
    public T get(int index)
    {
      mHasError = false;
      if (index >= 0 && index < data.Count)
        return data[index];
      mHasError = true;
      return default(T);
    }
    public bool set(int index, T value)
    {
      if (index >= 0 && index < data.Count)
      {
        data[index] = value;
        return true;
      }
      return false;
    }
    public void append(T value)
    {
      data.Add(value);
    }
    public bool insert(int index, T value)
    {
      if (index >= 0 && index < data.Count)
      {
        data.Insert(index, value);
        return true;
      }
      return false;
    }
    public void appendRange(ref List<T> range)
    {
      data.AddRange(range);
    }
    public bool insertRange(int index, ref List<T> range)
    {
      if (index >= 0 && index < data.Count)
      {
        data.InsertRange(index, range);
        return true;
      }
      return false;
    }
    public void clear()
    {
      data.Clear();
    }
    public bool remove(int index)
    {
      if (index >= 0 && index < data.Count)
      {
        data.RemoveAt(index);
        return true;
      }
      return false;
    }
    public bool removeRange(int index, int count)
    {
      if (count > 0 && index >= 0 && ((index + count) <= data.Count))
      {
        data.RemoveRange(index, count);
        return true;
      }
      return false;
    }
    public int length()
    {
      return data.Count;
    }
    public void enqueue(T value)
    {
      data.Insert(0, value);
    }
    public T dequeue()
    {
      mHasError = false;
      int length = data.Count;
      if (length > 0)
      {
        T b = data[length - 1];
        data.RemoveAt(length - 1);
        return b;
      }
      mHasError = true;
      return default(T);
    }
    public void push(T value)
    {
      data.Add(value);
    }
    public T pop()
    {
      return dequeue();
    }
    public Troop<T> getRange(int index, int count)
    {
      Troop<T> output = new Troop<T>();
      mHasError = true;
      if (count > 0 && index >= 0 && ((index + count) <= data.Count))
      {
        output.data = data.GetRange(index, count);
        mHasError = false;
      }
      return output;
    }
    public void reverse()
    {
      data.Reverse();
    }
    public bool swap(int index0, int index1)
    {
      int length = data.Count;
      if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
      {
        T v = data[index0];
        data[index0] = data[index1];
        data[index1] = v;
        return true;
      }
      return false;

    }
    public T take(int index)
    {
      mHasError = false;
      if (index >= 0 && index < data.Count)
      {
        T v = data[index];
        data.RemoveAt(index);
        return v;
      }
      mHasError = true;
      return default(T);
    }
    public void rollForward(int offset)
    {
      if (offset >= data.Count) return;
      List<T> left = data.GetRange(offset - 1, data.Count - offset + 1);
      List<T> right = data.GetRange(0, offset - 1);
      data.Clear();
      data.AddRange(left);
      data.AddRange(right);
    }
    public void rollBackward(int offset)
    {
      if (offset >= data.Count) return;
      List<T> left = data.GetRange(offset, data.Count - offset);
      List<T> right = data.GetRange(0, offset);
      data.Clear();
      data.AddRange(left);
      data.AddRange(right);
    }
  }
}

//for more information, please access http://www.one-lab.net

#ifndef VALUES_H
#define VALUES_H

#include <QList>
#include <QDebug>

namespace onelab
{
  class ISortable
  {
  public:
    virtual void sort(bool decending) = 0;
  };

  template <typename T>
  class Troop
  {
  private:
    bool mHasError;
    static bool equals(const Troop<T> &from, const Troop<T> &to);

  public:
    QList<T> data;
    Troop();
    T get(int index);
    bool set(int index, T value);
    void append(T value);
    bool insert(int index, T value);
    void appendRange(const QList<T>& range);
    bool insertRange(int index, const QList<T>& range);
    void clear();
    bool remove(int index);
    bool removeRange(int index, int count);
    int length() const;
    void enqueue(T value);
    T dequeue();
    void push(T value);
    T pop();
    bool getRange(int index, int count, Troop<T>& output);
    void reverse();
    bool swap(int index0, int index1);
    T take(int index);
    void rollForward(int offset);
    void rollBackward(int offset);
    bool operator==(const Troop& input) const;
    bool operator!=(const Troop& input) const;
    bool hasError() const;
    virtual QString toString();
    virtual int fromString(const QString& input);
  };
}

#endif // VALUES_H

//for more information, please access http://www.one-lab.net

#include "values.h"
#include <QStringList>
#include <QDateTime>

namespace onelab
{
template <typename T>
bool Troop<T>::equals(const Troop<T> &from, const Troop<T> &to)
{
  int len = from.length();
  if (len == to.length())
  {
    for (int n = 0; n < len; n++)
    {
      if (from.data[n] != to.data[n])
        return false;
    }
    return true;
  }
  return false;
}

template <typename T>
Troop<T>::Troop()
{
  mHasError = false;
}

template <typename T>
T Troop<T>::get(int index)
{
  mHasError = false;
  if (index >= 0 && index < data.length())
    return data[index];
  mHasError = true;
  return (T)0;
}

template <typename T>
bool Troop<T>::set(int index, T value)
{
  if (index >= 0 && index < data.length())
  {
    data[index] = value;
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::append(T value)
{
  data.append(value);
}

template <typename T>
bool Troop<T>::insert(int index, T value)
{
  if (index >= 0 && index < data.length())
  {
    data.insert(index, value);
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::appendRange(const QList<T> &range)
{
  data.append(range);
}

template <typename T>
bool Troop<T>::insertRange(int index, const QList<T> &range)
{
  int length = data.length();
  if (index >= 0 && index < length)
  {
    QList<T> left = data.mid(0, index);
    QList<T> right = data.mid(index, -1);
    left.append(range);
    data.clear();
    data.append(left);
    data.append(right);
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::clear()
{
  data.clear();
}

template <typename T>
bool Troop<T>::remove(int index)
{
  if (index >= 0 && index < data.length())
  {
    data.removeAt(index);
    return true;
  }
  return false;
}

template <typename T>
bool Troop<T>::removeRange(int index, int count)
{
  if (count > 0 && index >= 0 && ((index + count) <= data.length()))
  {
    for (int n = 0; n < count; n++)
      data.removeAt(index);
    return true;
  }
  return false;
}

template <typename T>
int Troop<T>::length() const
{
  return data.length();
}

template <typename T>
void Troop<T>::enqueue(T value)
{
  data.insert(0, value);
}

template <typename T>
T Troop<T>::dequeue()
{
  mHasError = false;
  int length = data.length();
  if (length > 0)
  {
    T b = data[length - 1];
    data.removeAt(length - 1);
    return b;
  }
  mHasError = true;
  return (T)0;
}

template <typename T>
void Troop<T>::push(T value)
{
  data.append(value);
}

template <typename T>
T Troop<T>::pop()
{
  return dequeue();
}

template <typename T>
bool Troop<T>::getRange(int index, int count, Troop<T>& output)
{
  mHasError = true;
  if (count > 0 && index >= 0 && ((index + count) <= data.length()))
  {
    output.data = data.mid(index, count);
    mHasError = false;
  }
  return mHasError;
}

template <typename T>
void Troop<T>::reverse()
{
  int length = data.length();
  QList<T> newData;
  for (int n = length - 1; n >= 0; n--)
    newData.append(data[n]);

  data.clear();
  data = newData;
}

template <typename T>
bool Troop<T>::swap(int index0, int index1)
{
  int length = data.length();
  if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
  {
    T v = data[index0];
    data[index0] = data[index1];
    data[index1] = v;
    return true;
  }
  return false;
}

template <typename T>
T Troop<T>::take(int index)
{
  mHasError = false;
  if (index >= 0 && index < data.length())
  {
    T v = data[index];
    data.removeAt(index);
    return v;
  }
  mHasError = true;
  return (T)0;
}

template <typename T>
void Troop<T>::rollForward(int offset)
{
  if (offset >= data.length()) return;
  QList<T> left = data.mid(offset - 1, -1);
  QList<T> right = data.mid(0, offset - 1);
  data.clear();
  data.append(left);
  data.append(right);
}

template <typename T>
void Troop<T>::rollBackward(int offset)
{
  if (offset >= data.length()) return;
  QList<T> left = data.mid(offset, -1);
  QList<T> right = data.mid(0, offset);
  data.clear();
  data.append(left);
  data.append(right);
}

template <typename T>
bool Troop<T>::operator!=(const Troop& input) const
{
  return !equals(input, *this);
}

template<typename T>
bool Troop<T>::hasError() const
{
  return mHasError;
}

template<typename T>
QString Troop<T>::toString()
{
  return QString();
}

template<typename T>
int Troop<T>::fromString(const QString&)
{
  return 0;
}

template <typename T>
bool Troop<T>::operator==(const Troop& input) const
{
  return equals(input, *this);
}

}
//for more information, please access http://www.one-lab.net

package net.onelab;

import java.util.ArrayList;

public class Troop<T> implements Cloneable {
 public Object clone() {
 Troop<T> obj = new Troop<T>();
 obj.data.addAll(data);
 return obj;
 }

 private boolean mHasError = false;
 public boolean hasError() { return mHasError; }
 public ArrayList<T> data = new ArrayList<T>();
 public T get(int index) {
 mHasError = false;
 if (index >= 0 && index < data.size())
  return data.get(index);
 mHasError = true;
 return null;

 }
 public boolean set(int index, T value) {
 if (index >= 0 && index < data.size())
 {
  data.set(index, value);
  return true;
 }
 return false;
 }
  public void append(T value) {
    data.add(value);
  }
  public boolean insert(int index, T value) {
    if (index >= 0 && index < data.size())
    {
      data.add(index, value);
      return true;
    }
    return false;
  }
  public void appendRange(ArrayList<T> range) {
    data.addAll(range);
  }
  public boolean insertRange(int index, ArrayList<T> range) {
    if (index >= 0 && index < data.size())
    {
      data.addAll(index, range);
      return true;
    }
    return false;
  }
  public void clear() {
    data.clear();
  }
  public boolean remove(int index) {
    if (index >= 0 && index < data.size())
    {
      data.remove(index);
      return true;
    }
    return false;
  }
  public boolean removeRange(int index, int count) {
    if (count > 0 && index >= 0 && ((index + count) <= data.size()))
    {
      for (int n = 0; n < count; n++)
       data.remove(index);

      return true;
    }
    return false;
  }
  public int length() {
    return data.size();
  }
  public void enqueue(T value) {
    data.add(0, value);
  }
  public T dequeue() {
    mHasError = false;
    int length = data.size();
    if (length > 0)
    {
      T b = data.get(length - 1);
      data.remove(length - 1);
      return b;
    }
    mHasError = true;
    return null;
  }
  public void push(T value) {
    data.add(value);
  }
  public T pop() {
    return dequeue();
  }
  public Troop<T> getRange(int index, int count) {
    mHasError = true;
    Troop<T> output = new Troop<T>();
    if (count > 0 && index >= 0 && ((index + count) <= data.size()))
    {
     output.data.addAll(data.subList(index, index + count));
      mHasError = false;
    }
    return output;
  }
  public void reverse() {
   int length = data.size();
   ArrayList<T> newData = new ArrayList<T>();
   for (int n = length - 1; n >= 0; n--)
   newData.add(data.get(n));

   data.clear();
   data = newData;
  }

  boolean swap(int index0, int index1) {
    int length = data.size();
    if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
    {
      T v = data.get(index0);
      data.set(index0, data.get(index1));
      data.set(index1, v);
      return true;
    }
    return false;
  }
  T take(int index)
  {
    mHasError = false;
    if (index >= 0 && index < data.size())
    {
      T v = data.get(index);
      data.remove(index);
      return v;
    }
    mHasError = true;
    return null;
  }
  void rollForward(int offset)
  {
    if (offset >= data.size()) return;
    ArrayList<T> left = new ArrayList<T>();
    left.addAll(data.subList(offset - 1, data.size()));
    ArrayList<T> right = new ArrayList<T>();
    right.addAll(data.subList(0, offset - 1));
    data.clear();
    data.addAll(left);
    data.addAll(right);
  }
  void rollBackward(int offset)
  {
    if (offset >= data.size()) return;
    ArrayList<T> left = new ArrayList<T>();
    left.addAll(data.subList(offset, data.size()));
    ArrayList<T> right = new ArrayList<T>();
    right.addAll(data.subList(0, offset));
    data.clear();
    data.addAll(left);
    data.addAll(right);
  }
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

C#泛型类创建与使用的方法

本文实例为大家分享了C#泛型类创建与使用的具体代码,供大家参考,具体内容如下 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication13 { class Program { static void Main(string[] args) { Test<string,int> t = new Test<string,i
Java泛型类型通配符和C#对比分析

c#的泛型没有类型通配符,原因是.net的泛型是CLR支持的泛型,而Java的JVM并不支持泛型,只是语法糖,在编译器编译的时候都转换成object类型类型通配符在java中表示的是泛型类型的父类 public void test(List<Object> c) { for(int i = 0;i < c.size();i++) { System.out.println(c.get(i)); } } //创建一个List<String>对象 List<String&g
c#自定义泛型类的实现

闲来无事,自己研究了泛型类的简单的使用,where表示泛型约束,表示泛型类型中的参数只能是car类型,IEnumerable是一个接口,一个集合要支持FOREAch遍历,必须实现IEnumerable接口复制代码代码如下: public class Car { public string PetName; public int Speed; public Car(string name, int currentSpeed) {
深入解析C#中的泛型类与泛型接口

泛型类泛型类封装不是特定于具体数据类型的操作.泛型类最常用于集合,如链接列表.哈希表.堆栈.队列.树等.像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关. 对于大多数需要集合类的方案,推荐的方法是使用 .NET Framework 类库中所提供的类. 一般情况下,创建泛型类的过程为:从一个现有的具体类开始,逐一将每个类型更改为类型参数,直至达到通用化和可用性的最佳平衡.创建您自己的泛型类时,需要特别注意以下事项: 将哪些类型通用化为类型参数. 通常,能够参数化的
深入浅析C#泛型类型

上篇文章给大家介绍了浅析C# 中的类型系统(值类型和引用类型),接下来通过本文给大家介绍下c# 泛型类型, 说下C#中的泛型,熟练地使用泛型能提高代码的重用性,使用我们代码瞬间就高大上了,当然只有一点点,真的只有一点点,因为后面要学习和掌握的知识还有很多.先来看下一个使用Dictionary<TKey,TValue>的例子. static void Main(string[] args) { Dictionary<int, string> result = GetAll(); }
介绍C# 泛型类在使用中约束

首先看一下泛型的基本语法访问修饰符返回类型泛型方法名 <T>(T 参数) 1):无法在泛型方法内部给任何 T 类型创建实例的对象,因为在泛型方法内部不知道传进来的对象有哪些构造函数2):约束是对内部的!(对于泛型方法)约束也是会被继承的! 3):给泛型类加类型(引用类型,值类型)的约束:where T:class,new ( ) 遇到的问题:在写MongodbHelper类的时候,为了能处理多种类别,所以如下定义了该类: 复制代码代码如下: public class MongodbH
C# 泛型类(函数)的实例化小例子

泛型可以用于类,也可以用于函数.如泛型类: 复制代码代码如下: public class MyClass<T> { public T MyElement { get; set; } } 泛型函数: 复制代码代码如下: public T ReturnElement<T>() { throw new NotImplementedException(); } 但是当需要对MyElement进行实例化的时候,却不能使用new(),只要添加如下代码即可进行实例化了: 泛
浅谈c# 泛型类的应用

泛型类泛型类封装不是特定于具体数据类型的操作. 泛型类最常用于集合,如链接列表.哈希表.堆栈.队列.树等. 像从集合中添加和移除项这样的操作都以大体上相同的方式执行,与所存储数据的类型无关.对大多集合类的操作,推荐使用 .NET Framework 类库中所提供的类.(1)泛型类可以继承具体类.封闭式构造.开放式构造基类. 复制代码代码如下: class BaseNode { }class BaseNodeGeneric<T> { }// 继承具体类class NodeConcrete<
c# 泛型类型参数与约束的深入分析

泛型类型参数简介在定义泛型类型和泛型方法时,常用到泛型类型参数,泛型类型参数是在实例化泛型时指定类型的占位符.泛型类型参数放在"<>"内.泛型类型参数命名建议:(1)当泛型类型参数为单个字母时,建议用T表示.(2)当泛型类型参数用单词定义时,建议在单词前加T. 复制代码代码如下: private void PromptName<T>(T t) {}private void PromptName<Tuser>(Tuser user){} 泛型类型参数
自定义的Troop<T>泛型类（ c++, java和c#）的实现代码

Troop<T>是一个泛型列表操作类,适用于非高性能和非大数据量的要求.包括了:取值get,赋值set,追加append,插入insert,清除remove,进队enqueue,出队dequeue,交换swap,滚动roll,进栈push,出栈pop等日常操作. //for more information, please access http://www.one-lab.net using System; using System.Collections.Generic; using Sy
Android 自定义 HorizontalScrollView 打造多图片OOM 的横向滑动效果(实例代码)

自从Gallery被谷歌废弃以后,Google推荐使用ViewPager和HorizontalScrollView来实现Gallery的效果.的确HorizontalScrollView可以实现Gallery的效果,但是HorizontalScrollView存在一个很大的问题,如果你仅是用来展示少量的图片,应该是没问题的,但是如果我希望HorizontalScrollView可以想ViewPager一样,既可以绑定数据集(动态改变图片),还能做到,不管多少图片都不会OOM(ViewPager内
Java编程实现获取当前代码行行号的方法示例

本文实例讲述了Java编程实现获取当前代码行行号的方法.分享给大家供大家参考,具体如下: 最近的项目中,为了实现自定义的log类,能够输出具体的代码行行号,我通过使用StackTraceElement对象实现了. 具体内容请参考下面的Demo代码.这里指出需要注意的几个问题: 1. 程序中返回的代码行行号,是新建StackTrackElement对象的那一行. 2. 可以通过传参的方法实现输出特定行行号. 具体实现代码: /** * */ package leo.demo.training; /
java并发编程之同步器代码示例

同步器是一些使线程能够等待另一个线程的对象,允许它们协调动作.最常用的同步器是CountDownLatch和Semaphore,不常用的是Barrier和Exchanger 队列同步器AbstractQueuedSynchronizer是用来构建锁或者其他同步组件的基础框架,它内部使用了一个volatiole修饰的int类型的成员变量state来表示同步状态,通过内置的FIFO队列来完成资源获取线程的排队工作. 同步器的主要使用方式是继承,子类通过继承同步器并实现它的抽象方法来管理同步状态,在抽
自定义实现 PyQt5 下拉复选框 ComboCheckBox的完整代码

自定义实现 PyQt5 下拉复选框 ComboCheckBox 一.前言由于最近的项目需要具有复选功能,但过多的复选框会影响界面布局和美观,因而想到把 PyQt5 的下拉列表和复选框结合起来,但在 PyQt5 中并没有这样的组件供我们使用,所以想要自己实现一个下拉复选框,主要就是继承 QComboBox 类,然后将复选框 QCheckBox 加入其中,并实现相应的功能. 最终实现的下拉复选框效果如下: 二.代码实现 1.主要方法在 PyQt5 中,有几个主要的方法需要了解一下,方法名称和对应
Java实现屏幕截图工具的代码分享

目录效果展示程序结构核心代码效果展示程序运行后的截图: 先测试一下功能: 截图过程对界面的捕捉: 双击保存后的显示界面: 后续的步骤就自己去尝试吧,这里给出了简单的测试过程. 程序结构核心代码 CaptureScreen.java类 /** * CaptureScreen.java */ import java.awt.*; import java.awt.datatransfer.DataFlavor; import java.awt.datatransfer.Transferab
Java ClassLoader虚拟类实现代码热替换的示例代码

目录总结 ClassLoader 虚拟类方法实现代码热替换实现改进思考总结类加载器是负责加载类的对象.类ClassLoader是一个抽象类.给定类的全限定类名,类加载器应尝试查找或生成构成该类定义的数据Class文件.典型的策略是将名称转换为文件名,然后从文件系统中读取该名称的类文件每个Class对象都包含一个Class.getClassLoader()方法可以获取到定义它的ClassLoader 数组类的Class对象不是由类加载器创建的,而是根据Java运行时的要求自动创建的.
Java语言实现反转链表代码示例

问题描述定义一个函数,输入一个链表的头结点,反转该链表并输出反转后的链表的头结点.链表结点如下: public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 思路1: 要想反转链表,对于结点i,我们要把它的next指向它的前趋,因此我们需要保存前趋结点,同时,如果我们已经把i的next重新赋值,会无法找到i的后继,因此,在重新赋值之前,我们要保存i的后继. 代码:
Java创建与结束线程代码示例

本文讲述了在Java中如何创建和结束线程的最基本方法,只针对于Java初学者.一些高级知识如线程同步.调度.线程池等内容将会在后续章节中逐步深入. 创建线程创建普通线程有两种方式,继承Thread类或实现Runnable接口.示例如下. 方法1:继承Thread类创建方法示例: public class MyThread1 extends Thread { @Override public void run() { //TODO Auto-generated method stub supe
java中synchronized（同步代码块和同步方法）详解及区别

java中synchronized(同步代码块和同步方法)详解及区别问题的由来: 看到这样一个面试题: //下列两个方法有什么区别 public synchronized void method1(){} public void method2(){ synchronized (obj){} } synchronized用于解决同步问题,当有多条线程同时访问共享数据时,如果进行同步,就会发生错误,Java提供的解决方案是:只要将操作共享数据的语句在某一时段让一个线程执行完,在执行过程中,其他

自定义的Troop<T>泛型类（ c++, java和c#）的实现代码

相关推荐

随机推荐