Java 实现 ADO.NET DataTable

最新推荐文章于 2021-02-17 00:08:54 发布
最新推荐文章于 2021-02-17 00:08:54 发布
阅读量163 收藏
点赞数
分类专栏： 原创 文章标签： .net Java Netbeans 数据结构 J#
Java 没有 DataTable（有吗？这个应该有,这个真没有）,.net 的 System.Data 名字空间基本实现了一个内存数据库的功能，功能的却很强，
他们的实现我反编译源代码看了，不过没看太懂好像是用的数据库的索引原理不是我这样循环实现的查询。

现在只有.net 移植 java 的开源项目象NHibernate NUnit log4n , 为什么java 就不能移植 .net 的优秀功能呢，java 社区的人也应该谦虚些啊。

我这个实现的不好，希望能抛砖引玉激发 java 高手开始移植 .net 的优秀功能。请高手提出意见，如果没有人愿意做我想自己实现一个 java 的 System.Data

附件是 DataTable 的部分代码 ， NetBeans 项目 



package system.data;

import java.util.HashMap;
import java.util.ArrayList;
import java.util.ListIterator;
import system.Convert;

/***
 * DataTable 是 DataRow 的列表集合，并且其中包含了一个列名和列索引的哈希表
 * @author Fred
 */
public class DataTable extends ArrayList<DataRow>
{
    public HashMap<Object,Integer> column_index_map;
    public int column_count;

    public DataTable()
    {
        this.column_index_map = new HashMap<Object,Integer>();
        this.column_count = 0;
    }

    /***
     * 将一列的所有记录转化为一个数组
     * @param field 投影的列名
     * @return
     */
    public Object[] collect(String field)
    {
        if(this.size()==0)
            return null;

        HashMap map = new HashMap();
        ListIterator<DataRow> iter = this.listIterator();

        while(iter.hasNext())
            map.put(iter.next().get(field), null);

        return map.keySet().toArray();
    }

    /***
     * 将当前表的每一行与FieldHashDataRow用foreign_key关联
     *  fDataRow 必须是以foreign_key为键的Hashtable
     *  用这个方法有一个限制是两个表中同名的字段必须具有同样的含义，不同名的字段具有不同的含义。
     * @param fDataRow
     * @param foreign_key
     */
    public void join(FieldHashDataRow fDataRow,String foreign_key)
    {
        if(fDataRow==null)
            return;

        int size = this.size();

        for(int i=0;i<size;i++)
        {
            DataRow dr = this.get(i);
            DataRow pdr = fDataRow.get(dr.get(foreign_key));
            dr.join(pdr);
        }
    }

    public void addColumn(String name)
    {
        this.column_index_map.put(name, this.column_count++);
    }

    public DataRow newRow()
    {
        return new DataRow(this);
    }

    /***
         * 实现简单的内存 SQL 表达式
         * @param expression
         * @return
         */
    public ArrayList<DataRow> select(String expression)
    {
        Expression e = Expression.FindExpression(expression);
        ArrayList<DataRow> list = new ArrayList<DataRow>();

        for(DataRow row : this)
          if(e.eval(row))
              list.add(row);
        return list;
    }
}

//<editor-fold defaultstate="collapsed" desc="Expression">
class Expression
{
	private String expression;
	private int exp_len;
	private char[] exp_array;
	private ArrayList<String> token_list;
    private boolean is_flushed;
    private char c;
	private StringBuffer sb;
	private int cur_token_index;
	private int token_count;

	public Expression(String expression)
	{
		this.expression = expression;
		this.exp_len = expression.length();
		this.exp_array = expression.toCharArray();
		this.token_list = new ArrayList<String>();
		this.is_flushed = true;
		this.cur_token_index = -1;
		this.sb = new StringBuffer();
		this.initTokenList();
		this.token_count = this.token_list.size();

	}

	private void flush()
	{
		if(this.is_flushed)
			return;

		this.token_list.add(this.sb.toString());
		this.sb = new StringBuffer();
		this.is_flushed = true;
	}

	private void collect()
	{
		this.sb.append(c);
        this.is_flushed = false;
	}

	private boolean nextToken()
	{

		if(this.cur_token_index<this.token_count-1)
		{
			this.cur_token_index++;
			return true;
		}

		return false;
	}

	private String currentToken()
	{
		return this.token_list.get(this.cur_token_index);
	}

    private void initTokenList()
    {
    	for(int i=0;i<this.exp_len;i++)
    	{
    		c = exp_array[i];
    		if(Character.isWhitespace(c))
            {
                this.flush();
                continue;
            }

            switch(c)
            {
            	case '<' :

            		this.flush();
            		if(i+1<this.exp_len && exp_array[i+1]=='=')
                    {
                        this.token_list.add("<=");
                        i++;
                    }
                    else
                    {
                    	this.token_list.add("<");
                    }
            		break;

            	case '>' :

            		this.flush();
            		if(i+1<this.exp_len && exp_array[i+1]=='=')
                    {
                        this.token_list.add(">=");
                        i++;
                    }
                    else
                    {
                    	this.token_list.add(">");
                    }
            		break;

            	case '(' :

            		this.flush();
            		this.token_list.add("(");
            		break;

            	case ')' :

            		this.flush();
            		this.token_list.add(")");
            		break;

            	case '=' :

            		if(i+1<this.exp_len && exp_array[i+1]=='=')
            		{
            			this.flush();
            			this.token_list.add("==");
            			i++;
            		}
            		else
            		{
            			this.collect();
            		}
            		break;

            	case '!' :

            		if(i+1<this.exp_len && exp_array[i+1]=='=')
            		{
            			this.flush();
            			this.token_list.add("!=");
            			i++;
            		}
            		else
            		{
            			this.collect();
            		}
            		break;


            	default:

            		this.collect();
            		break;
            }
    	}

    	this.flush();
    }

    public boolean eval(DataRow dr)
    {
    	this.nextToken();
    	boolean result = this.doAndOr(dr);
        this.cur_token_index = -1;
        return result;
    }

    private boolean doAndOr(DataRow dr)
    {
    	boolean result = this.doNot(dr);
    	String op = "";

        boolean result_right;

    	while((op=this.currentToken()).equals("and") || op.equals("or"))
    	{
    		this.nextToken();

    		if(op.equals("and"))
            {
                result_right = this.doNot(dr);
    			result = result && result_right;
            }
    		else
            {
                result_right = this.doNot(dr);
    			result = result || result_right;
            }
    	}

    	return result;
    }

    private boolean doNot(DataRow dr)
    {
    	String op="";

    	if((op=this.currentToken()).equals("not"))
    		this.nextToken();

    	boolean result = this.doBrackets(dr);

    	if(op.equals("not"))
    			return !result;

    	return result;
    }

    private  boolean doBrackets(DataRow dr)
    {
    	boolean result;
    	if(this.currentToken().equals("("))
    	{
    		this.nextToken();
    		result = this.doAndOr(dr);
    		this.nextToken();
    	}
    	else
    	{
    		result = this.doCompare(dr);
    	}

    	return result;
    }

    private boolean  doCompare(DataRow dr)
    {
    	Object field = dr.get(this.currentToken());
    	this.nextToken();
    	String opt = this.currentToken();
    	this.nextToken();
    	String value = this.currentToken();
        this.nextToken();

    	if(opt.equals("like"))
    	{
    		return isLike(field,value);
    	}
    	else if(opt.equals(">"))
    	{
    		return isGreat(field,value);
    	}
        else if(opt.equals("<"))
    	{
    		return isLess(field,value);
    	}
    	else if(opt.equals("=="))
    	{
    		return isEquals(field,value);
    	}
        else if(opt.equals(">="))
    	{
    		return isGreatEquals(field,value);
    	}
        else if(opt.equals("<="))
    	{
    		return isLessEquals(field,value);
    	}
        else if(opt.equals("!="))
        {
            return isNotEquals(field,value);
        }

    	return false;

    }


//<editor-fold  defaultstate="collapsed" desc="tool method">

    private static boolean isLike(Object field,String value)
    {
    	int len = value.length();
		if(value.startsWith("'%") && value.endsWith("%'"))
			return Convert.toString(field).contains(value.substring(2,len-2));
		else if(value.startsWith("'%"))
			return Convert.toString(field).endsWith(value.substring(2,len-1));
		else if(value.endsWith("%'"))
			return Convert.toString(field).startsWith(value.substring(1,len-2));
		else
			return Convert.toString(field).equals(value.substring(1,len-1));
    }

    private static boolean isLess(Object field,String value)
    {
    	if(field instanceof Number)
            return Convert.toFloat(field)<Convert.toFloat(value);
        return Convert.toString(field).compareTo(value.substring(1,value.length()-1))<0;
    }

    private static boolean isGreat(Object field,String value)
    {
        if(field instanceof Number)
            return Convert.toFloat(field)>Convert.toFloat(value);
        return Convert.toString(field).compareTo(value.substring(1,value.length()-1))>0;
    }

    private static boolean isEquals(Object field,String value)
    {
         if(value.equals("null"))
            return field==null;

        if(field instanceof Number)
            return Convert.toFloat(field)==Convert.toFloat(value);
        if(field instanceof Boolean)
            return Convert.toBool(field)==Convert.toBool(value); 

        return Convert.toString(field).equals(value.substring(1,value.length()-1));
    }

    private static boolean isNotEquals(Object field,String value)
    {
        if(value.equals("null"))
            return field!=null;

        if(field instanceof Number)
            return Convert.toFloat(field)!=Convert.toFloat(value);
        if(field instanceof Boolean)
            return Convert.toBool(field)==Convert.toBool(value);

        return !Convert.toString(field).equals(value.substring(1,value.length()-1));
    }

    private static boolean isLessEquals(Object field,String value)
    {
    	if(field instanceof Number)
            return Convert.toFloat(field)<=Convert.toFloat(value);
        return Convert.toString(field).compareTo(value.substring(1,value.length()-1))<=0;
    }

    private static boolean isGreatEquals(Object field,String value)
    {
        if(field instanceof Number)
            return Convert.toFloat(field)>=Convert.toFloat(value);
        return Convert.toString(field).compareTo(value.substring(1,value.length()-1))>=0;
    }
//</editor-fold>

    private static HashMap<String,Expression> expression_map = new HashMap<String,Expression>();

    public static Expression FindExpression(String expression)
    {
        Expression e = expression_map.get(expression);
        if(e==null)
        {
            e = new Expression(expression);
            expression_map.put(expression, e);
        }
        return e;
    }

}
 //</editor-fold>


 / / /


 package system.data;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Map;
import java.util.Set;
import system.Convert;

/***
 * DataRow 由一个DataTable 创建而来，
 * DataRow 实际是一个列表，DataRow 从 DataTable 中获得列名和索引的对应关系并实现Map 接口实现按列取值
 * 这个结构不应该单独存在只作为DataTable 的子项
 * @author Fred
 */
public class DataRow implements Map
{
    private ArrayList fields;
    private DataTable parentTable;
    private int column_count;

    /***
     *  这个方法不应该被程序员调用
     * @param dTable
     */
    public DataRow(DataTable dTable)
    {
        this.fields = new ArrayList();
        this.parentTable = dTable;
        this.column_count=0;
    }

    /***
     *  将另外一张表的一行的列数据补充到当前行的已有列中
     * @param dr
     * @return 当前行（已经补充完数据的）
     */
    public DataRow join(DataRow dr)
    {
        if(dr==null)
            return this;
        Set<String> key_set = dr.keySet();
        //dr 的所有key 覆盖到当前行的所有同名key中
        for(String k : key_set)
            this.put(k, dr.get(k));
        return this;
    }

    /***
     * 给 ArrayList 表示的行数据按照列索引设置值
     * 注意如果当前列索引超出了 ArrayList  最后一个元素的索引下标，则将缺失的所有元素用空补上。
     * @param key 列名
     * @param value 列值
     * @return 设置前列的旧值
     */
    public Object put(Object key, Object value)
    {
        Integer column_index = this.parentTable.column_index_map.get(key);
        if(column_index==null)
        	return null;

        int j = column_index.intValue();
        while(this.column_count<j+1)
        {
        	this.fields.add(null);
        	this.column_count++;
        }

        this.fields.set(j,value);
        return null;
    }

    public Object get(Object key)
    {
        Integer column_index = this.parentTable.column_index_map.get(key);
        if(column_index==null)
        	return null;
         int j = column_index.intValue();

         if(j<this.column_count)
            return this.fields.get(j);
         return null;
    }

    //<editor-fold defaultstate="collapsed" desc="only_for_implements_Map">
    public String getString(Object key)
    {
        return Convert.toString(get(key));
    }

    public int getInt(Object key)
    {
        return Convert.toInt(get(key));
    }

    public float getFloat(Object key)
    {
        return Convert.toFloat(get(key));
    }

    public Date getDate(Object key)
    {
        return Convert.toDate(get(key));
    }

    public void clear()
    {
        this.fields.clear();
    }

    public boolean containsKey(Object key)
    {
        return this.parentTable.column_index_map.containsKey(key);
    }

    public boolean containsValue(Object value)
    {
        return this.parentTable.column_index_map.containsValue(value);
    }

    public Set entrySet()
    {
        return this.parentTable.column_index_map.entrySet();
    }

    public boolean isEmpty()
    {
        return this.fields.isEmpty();
    }

    public void putAll(Map m)
    {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public Object remove(Object key)
    {
        Integer column_index = this.parentTable.column_index_map.get(key);
        if(column_index==null)
        	return null;

         int j = column_index.intValue();
         return this.fields.remove(j);
    }

    public int size()
    {
        return this.parentTable.column_count;
    }

    public Set keySet()
    {
        return this.parentTable.column_index_map.keySet();
    }

    public Collection values()
    {
         return this.parentTable.column_index_map.values();
    }
    //</editor-fold>
}


WengFred
关注
专栏目录
ADO.NET查询返回记录集DataSet
赵玉的专栏
02-18 397
的一个优点是它可以容纳来自多个表的数据，并且可以维护表之间的关系。如果你需要处理更复杂的查询，比如涉及连接多个表，你可以在。可能更高效，因为它提供了一个轻量级、只读、向前移动的数据流。然而，对于简单的查询和操作，直接使用。对象可以表示来自数据库的一个表的数据。中，如果你想要执行一个查询并返回一个。是一个内存中的缓存，它可以包含多个。替换为适合你的数据库环境的信息。下面是一个示例，展示了如何使用。方法用于执行查询并将结果填充到。来访问查询结果，它返回一个。查询中指定这些关系，并使用。对象，你可以遍历它的。
datatable java实现_如何用Java实现.NET中DataTable功能
weixin_32226023的博客
02-12 1011
因为我本来就是搞net的，突然来了两个项目就是要用java以及oracle，便从各种方向上寻求net的影子，便有了今天这些工具类。不知道好不好，bug测试了一下了，性能上也只有经过项目来验证吧。其中一部分涉及到双数据库操作，所以也提了一种解决方案，写的不好，大家看看吧!我们先看效果，再说说怎么弄!我们来试试如何用，我也写了一个测试数据。然后我们在Junit中测试：@Testpublicvoidjo...
datatable java实现_Java实现.NET中DataTable功能方案探究
weixin_42165508的博客
02-12 198
packagecdu.yas.xykps.util;importjava.sql.Blob;importjava.sql.Date;importjava.util.List;/*** @功能描述 数据行，即是表格中的每一行数据的集合，为List类型，其中List中每一个对象是一个DataColumn类(键值对)* @可能的错误 当需要取得行数据中某一列时，若是类型转换不匹配会出错(例：1 若是数据...
在Java中实现.net中DataTable功能以及操作双数据库的List连接问题解决方案探究
w549265480的专栏
06-24 720
前两天实现了net中DataTable功能，虽说功能不是很强大，但是完全满足了java中的多表查询，带来的编程风格改变还是存在的。 现在拿出来说下，和各位大哥探讨下。 因为我本来就是搞net的，突然来了两个项目就是要用java以及oracle，便从各种方向上寻求net的影子，便有了今天这些工具类。 不知道好不好，bug测试了一下了，性能上也只有经过项目来验证吧！！！ 其中一部分涉及到双数据
[转]在Java中实现.net中DataTable功能以及操作双数据库的List连接问题解决方案探究
keenweiwei的专栏
03-08 2030
[转]在Java中实现.net中DataTable功能以及操作双数据库的List连接问题解决方案探究 http://www.cnblogs.com/yexiaochai/archive/2011/07/15/2107468.html   Java实现ADO.NET DataTable的SQL查询 http://www.cnblogs.com/suicide/archive/2009/04/
基于Java的DataBuffer在Java中使用ADO.NET.zip
最新发布
06-15
虽然Java自身有JDBC作为标准的数据访问接口，但通过一些方式，我们依然可以实现在Java中使用ADO.NET。本教程将深入探讨如何在Java中使用基于ADO.NET的数据缓冲区——DataBuffer。 首先，理解DataBuffer。在ADO.NET...
Java ADO.NET使用例子.rar
07-10
在Java中使用DataBuffer ADO.NET的例子，源码作者对JAVA中DataBuffer类库的应用有着出色的理解。DataBuffer类是javadesktop中的一个开源子项目，通过DataBuffer 你可以熟悉理解DataSet、DataTable、DataRow……类库...
Tutorialspoint Bootstrap4 PHP Java NIO ASP.Net ADO.Net .NET Core 教程
12-17
此外，ADO.Net还包括数据适配器(DataAdapter)和命令对象(Command)，用于与各种数据库进行通信。 .NET Core 是微软推出的新一代跨平台开发框架，可用于构建桌面应用、Web应用、云服务和微服务。它具有高性能、模块化...
java 中如何实现类似.Net中的DataSet
andylauxing的专栏
04-18 3909
无意看到的一个贴，在此收藏一下。 文章出处: http://tech.it168.com/a2011/0720/1220/000001220768_all.shtml   Java实现.NET中DataTable功能方案探究 2011年07月21日13:30 来源：叶小钗博客 作者：叶小钗 编辑：胡铭娅 评论：0条 　　【IT168 技术】前两天实现了net中Dat
javaado开发代码
11-04
这是一个java数据的开打代码 大家可以参考里面的数据传输 的是如何实现的
java ado recordset_ADO ADO Recordset（记录集）
weixin_33796288的博客
02-13 115
ADO Recordset(记录集)如需读取数据库的数据，那么其中的数据必须首先被载入一个记录集中。创建一个 ADO 表记录集(ADO Table Recordset)在 ADO 数据库连接创建之后，如上一章所述，接下来就可以建立一个 ADO 记录集了。假设我们有一个名为 "Northwind" 的数据库，我们可以通过下面的代码访问数据库中的 "Customers" 表：set conn=Serv...
用java实现的类似.net的DataTable(2)
包子大叔的笔记
12-06 940
DataColumn.java package com.yihujiu.util.table; import org.json.JSONArray; import org.json.JSONException; import java.util.ArrayList; import java.util.HashMap; import java.util.ListIterator; /** * 列不区分大小写 */ public class DataColumn extends ArrayList&l
.Net和Java有何相似之处
小毛头的BLOG
09-08 3530
1.  ASP.Net，它是.Net系列技术，是微软动态服务器页面(ASP)的下一代版本。2.       .Net的许多技术，至少是部分上，显然受到了Java的推动。3.       Java 和.Net之间的相似之处一般很明显。比如，在ASP.Net和JSP中，页面都是预编译过的，因而运行起来更快。4.         “典型微软模式”------模式之一是微软赋予了开发者很大的自
java datarow_Java DataRow類代碼示例
weixin_30802819的博客
02-16 277
本文整理匯總了Java中org.apache.cayenne.DataRow類的典型用法代碼示例。如果您正苦於以下問題：Java DataRow類的具體用法？Java DataRow怎麽用？Java DataRow使用的例子？那麽恭喜您, 這裏精選的類代碼示例或許可以為您提供幫助。DataRow類屬於org.apache.cayenne包，在下文中一共展示了DataRow類的11個代碼示例，這些例...
java datarow 使用_Datatable和DataRow的使用
weixin_31971727的博客
02-13 312
SqlConnection conn = new SqlConnection();DataSet data = new DataSet();SqlDataAdapter da;String sqlStr;SqlCommandBuilder cb;protected void Page_Load(object sender, EventArgs e){try{sqlStr = "select * f...
Java的DataTable
bjsq的专栏
06-19 506
近日的开发过程中遇到了需要对LIST中对象进行多属性检索（有时需要模糊查询），而且比较频繁（因为需要频繁操作所以不想使用数据库），原来使用C#开发时会使用DataTable对象，而Java中没有，所以经过多方收集资料，发现通过XML的Xpath方式可以实现 [code="java"] String regex = ""; if (value.length() > 3 && value.s...
在Java中实现.NET的System.Data名称空间下的功能-九年以后
Azure Cube
07-05 1505
这篇博文是2006年写的了，现在是2014年-九年过去了，也不再纠结这个上面了。现在在用Slick，更加原生的支持Scala方式的数据库访问，也不用再生搬硬套了。
java web目录结构 ado_ADO.NET理论+实践
weixin_28901739的博客
02-17 127
题记：每一事物的产生和存在都有其特定的理由。理论：ADO.NET是一组与数据源进行交互的面向对象类库。通常情况下数据源就是数据库，当然同样也能是文本文件，Excel表格或XML文件，我们知道的数据库有多种，例如SQLServer，Access，Oracle ，DB2等等，因为不同的数据源采用不同的协议，例如有的数据源使用ODBC协议，有的使用OleDb协议。而这些数据源都可以通过ADO.NET来进...
C#面试深度解析：从Asp.Net到ADO.NET
ADO.NET引入了DataSet，它允许在断开连接的情况下处理数据，这降低了对数据库服务器的资源消耗，有利于实现分布式处理。此外，ADO.NET使用数据适配器，使得数据操作更为灵活。对比之下，ADO基于Recordset的持续连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值