使用哈希表操作数据库的例子

---摘自互联网

// ********************************************************************
// * This code is distributed in the hope that it will be useful, *
// * but WITHOUT ANY WARRANTY; without even the implied warranty of *
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
// ********************************************************************
//
// Using Hashtables to Store & Extract results from a Database.
//
// These functions are an example on how to get the data out of a
// resultset from a database and store the values in a Hashtable.
// several of the function are then an example on how to get the data
// out of the hashtables. Why would you want to do all this work?
// Maintaining a database connection over the web is expensive. By
// dumping the data into a hashtable you can minimize the amount of
// time you stay connected to your database. Also by storing the data
// in a hashtable offers flexible way to pass your data from
// object to object.
//
// This is a set of five functions
//
// Function makeHashTable :
// Takes a database ResultSet and places the data into a
// Hashtable array for later use.
//
// Function cleanHashTable :
// Takes a Hashtable array and removes the unused portion
// of a hashtable array. For example: You use makeHashTable
// and since it allocates the hashtable array in chunks of 20,
// its possible that it creates a hashtable of size 40, but
// only the first 22 indexes are used. So makeHashTable calls
// the cleanHashTable function which resizes the Hashtable
// array to only 22 indexes.
//
//Function columnOrder:
// Since a Hashtable does not guarantee to maintain the order
// of the elements put into it. This function produces a
// hashtable to store the column order of the ResultSet
//
//Function hastToTabFile
// An example on how to take a hashtable produced by the
// makeHashTable function and turn it into a tab delimited
// output string (used to download a dataresult as a flatfile)
// This function uses a the results from the columnOrder
// function to navigate the hashtable. If this function can't
// find this index hashtable, it then passes the hashtable
// to the hashToTab Function to step through the hashtable using
// enumeration methods.
//
//Function hashToTab
// If no index hasharray was found then this function uses
// Enumeration to step through the Hashtable and return a
// result
//
//////////////////////////////////////////////////////////////////////////
//
// Please note the following.
// -I suspect using a Vector would give much faster results .
// -If you are using Java 1.2 You should consider using an ArrayList,
// HashSet or TreeSet rather than a Hashtable or a Vector.
// -Use a Hashtable or Vector when you want java 1.1.x compatibility
//
//////////////////////////////////////////////////////////////////////////

public Hashtable[] makeHashTable(ResultSet ars_data)
{
int li_columns = 0;
int li_rowcount = 0;

Hashtable[] lht_results = new Hashtable[20];

try
{ // 1)get the column count and store our column order information
// in our first index of our Hashtable array
ResultSetMetaData lmeta_data = ars_data.getMetaData();

li_columns = lmeta_data.getColumnCount();

if (li_columns > 0)
{ lht_results[li_rowcount] = columnOrder(lmeta_data,li_columns);
li_rowcount++;
}

// 2)loop through the result set and add the data 1 row at a time to
// the hashtable array
while (ars_data.next())
{
// 3) If we are at the last index of our hashtable then expand it
// by another 20 indexes
if (li_rowcount == lht_results.length)
{
Hashtable[] lht_temp = new Hashtable[lht_results.length + 20];
for (int li_loop = 0; li_loop < lht_results.length ; li_loop++)
{
lht_temp[li_loop] = lht_results[li_loop];
}
lht_results = lht_temp;
}

// 4) loop through our column information and add it to our hash array
Hashtable lht_row = new Hashtable(1);
for ( int i = 1; i <= li_columns; i++)
{
Object luo_value = null;
try
{
luo_value = ars_data.getObject(i);
}
catch(Exception e){}
if (luo_value ==null) luo_value = new String("");
lht_row.put(lmeta_data.getColumnLabel(i),luo_value);
}

lht_results[li_rowcount] = lht_row;
li_rowcount++;

}
}
catch(SQLException e)
{
}

if (lht_results[0] == null)
{
return null;
}

return cleanHashTable(lht_results);
}

private Hashtable[] cleanHashTable(Hashtable[] aht_data)
{
Hashtable[] lht_temp = null;
int li_total_rows = aht_data.length;

// 1) loop thru and determine where the first null row appears
for (int i=0; i<aht_data.length; i++)
{
if (aht_data == null)
{
li_total_rows = i;
break;
}
}

// 2) rebuild a new hashtable array of the right size
// and reload it with your data
if (li_total_rows < aht_data.length)
{ lht_temp = new Hashtable[li_total_rows];

for (int i=0; i<li_total_rows; i++)
{
lht_temp[i] = aht_data[i];
}

aht_data = lht_temp;
lht_temp = null;
}

return aht_data;
}

private Hashtable columnOrder(ResultSetMetaData ameta_data, int ai_columns)
{
// 1) Size the Hashtable to be slighly larger than column count
// and load factor to 1 so the hash table wont have to resize itself.
Hashtable lht_row = new Hashtable((ai_columns + 3),1);

try
{ // 2) Store how many columns we have.
lht_row.put("Column_Count",String.valueOf(ai_columns));

// 3) Loop thru and store each column label and use its position
// number as its key
for ( int i = 1; i <= ai_columns; i++)
{
lht_row.put(String.valueOf(i),ameta_data.getColumnLabel(i));
}
}
catch (SQLException e)
{ // 4 Return a null result if an error happens
lht_row = null;
}

return lht_row;
}

public String hastToTabFile(Hashtable[] ahash_data, boolean ab_header)
{ //*****************************************************************
// ahash_data: array of hashtables to convert to tabfile
// ab_header : True if you want the tab file to include the headers
//*****************************************************************
String ls_tabfile = "";

if (ahash_data == null)
{ // 1) if no data then return empty file
ls_tabfile = "";
}
else
{
// 2) first get column headers
int li_column_count = 0;
String ls_column_count = ahash_data[0].get("Column_Count").toString();
try
{
li_column_count = Integer.parseInt(ls_column_count);
}
catch(NumberFormatException e)
{
// 3) since this hashtable doesnt have the the column data stashed
// treat it as a normal hashtable array
return hashToTab(ahash_data,ab_header);
}

// 4) Gather up each columns label/key name also build up the header column
String[] ls_indexes = new String[li_column_count];

for(int icol = 0; icol < li_column_count; icol++)
{
ls_indexes[icol] = ahash_data[0].get(String.valueOf(icol+1)).toString();
if(ab_header) ls_tabfile = ls_tabfile + ls_indexes[icol] + "\t";
}

// 5) Include the headers in the file if user requested them
if(ab_header) ls_tabfile = ls_tabfile + "\n";

// 6) loop through and gather tha data to display
for (int irow=1; irow < ahash_data.length; irow++)
{ if (ahash_data[irow] != null)
{
for(int icol = 0; icol < li_column_count; icol++)
{
ls_tabfile = ls_tabfile + ahash_data[irow].get(ls_indexes[icol]).toString() + "\t";
}
ls_tabfile = ls_tabfile + "\n";
}
}
}

return ls_tabfile;
}

private String hashToTab(Hashtable[] ahash_data, boolean ab_header)
{//*****************************************************************
// ahash_data: array of hashtables to convert to tabfile
// ab_header : True if you want the tab file to include the headers
//*****************************************************************
String ls_tabfile = "";

if (ahash_data == null)
{ // 1) if no data return empty file
ls_tabfile = "";
}
else
{
// 2) IF requested print out the header files
if (ab_header)
{
for(Enumeration lenum_header = ahash_data[0].keys(); lenum_header.hasMoreElements();)
{
String ls_col = lenum_header.nextElement().toString() + "\t";
ls_tabfile = ls_tabfile + ls_col;
}
ls_tabfile = ls_tabfile + "\n";
}

// 3) Loop through the rows and gather tha data to display
for (int i=0; i < ahash_data.length; i++)
{ Hashtable lhash_row = ahash_data[i];
if (lhash_row != null)
{ // 4) Loop thru each column and prints the columns data
for(Enumeration l_enum = lhash_row.keys(); l_enum.hasMoreElements();)
{
String ls_col = l_enum.nextElement().toString() ;
ls_tabfile = ls_tabfile + lhash_row.get(ls_col).toString() + "\t";
}
ls_tabfile = ls_tabfile + "\n";
}
}
}

return ls_tabfile;
}