■■Java暂时没有泛型，如何聪明的解决多类型问题？？？■■

public String getFormatStr()
{.......static String valueOf(char[] data) ;
用这吗？
}

其实你的问题就引申出来java里面的一个设计模式解决的问题，就是visitor模式
设计模式之Visitor
Visitor定义
作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.在Java中,Visitor模式实际上是分离了collection结构中的元素和对这些元素进行操作的行为.为何使用Visitor?
Java的Collection(包括Vector和Hashtable)是我们最经常使用的技术,可是Collection好象是个黑色大染缸,本来有各种鲜明类型特征的对象一旦放入后,再取出时,这些类型就消失了.那么我们势必要用If来判断,如:
Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
　　 Object o = iterator.next();
　　 if (o instanceof Collection)
　　　　 messyPrintCollection((Collection)o);
　　 else if (o instanceof String)
　　　　 System.out.println("'"+o.toString()+"'");
　　 else if (o instanceof Float)
　　　　 System.out.println(o.toString()+"f");
　　 else
　　　　 System.out.println(o.toString());
}
在上例中,我们使用了 instanceof来判断 o的类型.很显然,这样做的缺点代码If else if 很繁琐.我们就可以使用Visitor模式解决它.如何使用Visitor?
针对上例,我们设计一个接口visitor访问者:public interface Visitor
{
　　 public void visitCollection(Collection collection);
　　 public void visitString(String string);
　　 public void visitFloat(Float float);
}
在这个接口中,将我们认为Collection有可能的类的类型放入其中.有了访问者,我们需要被访问者,被访问者就是我们Collection的每个元素Element,我们要为这些Element定义一个可以接受访问的接口(访问和被访问是互动的,只有访问者,被访问者如果表示不欢迎,访问者就不能访问),我们定义这个接口叫Visitable,用来定义一个Accept操作,也就是说让Collection每个元素具备可访问性.public interface Visitable
{
　　 public void accept(Visitor visitor);
} 好了,有了两个接口,我们就要定义他们的具体实现(Concrete class):public class ConcreteElement implements Visitable
{
　　 private String value;
　　 public ConcreteElement(String string) {
　　　　 value = string;
　　 }
　　 //定义accept的具体内容这里是很简单的一句调用
　　 public void accept(Visitor visitor) {
　　　　 visitor.visitString(this);
　　 }
}
再看看访问者的Concrete实现:public class ConcreteVisitor implements Visitor
{
　　 //在本方法中,我们实现了对Collection的元素的成功访问
　　 public void visitCollection(Collection collection) {
　　　　 Iterator iterator = collection.iterator()
　　　　 while (iterator.hasNext()) {
　　　　　　 Object o = iterator.next();
　　　　　　 if (o instanceof Visitable)
　　　　　　　　 ((Visitable)o).accept(this);
　　　　 } 　　 public void visitString(String string) {
　　　　 System.out.println("'"+string+"'");
　　 }　　 public void visitFloat(Float float) {
　　　　 System.out.println(float.toString()+"f");
　　 }
}

在上面的visitCollection我们实现了对Collection每个元素访问,只使用了一个判断语句,只要判断其是否可以访问.至此,我们完成了Visitor模式基本架构.使用Visitor模式的前提
对象群结构中(Collection) 中的对象类型很少改变,也就是说访问者的身份类型很少改变,如上面中Visitor中的类型很少改变,如果需要增加新的操作,比如上例中我们在ConcreteElement具体实现外,还需要新的ConcreteElement2 ConcreteElement3.可见使用Visitor模式是有前提的,在两个接口Visitor和Visitable中,确保Visitor很少变化,变化的是Visitable,这样使用Visitor最方便.如果Visitor也经常变化, 也就是说,对象群中的对象类型经常改变,一般建议是,不如在这些对象类中逐个定义操作.但是Java的Reflect技术解决了这个问题.Reflect技术是在运行期间动态获取对象类型和方法的一种技术,具体实现参考Javaworld的英文原文.

我正在帮你写关于用visitor模式实现的代码，不过有个请求哦，呵呵希望你能申请把这个帖子变成faq，在管理的时候提交斑竹。

//我写的好像有问题，打印为NULL。//在帮忙看看。
//谢谢！class array_temp3
{
 private int [][] _data = null; //0
 private long [][] _datalong = null; //1
 private float [][] _datafloat = null; //2
 private double [][] _datadouble = null; //3
 private char [][] _datachar = null; //4

private int ObjectType ; //标记数组类型
 private int rowCount ;
 private int colCount ;


 public array_temp3(int[][] data)
{
 this._data = data;//构造函数，传递数组
 ObjectType = 0;
 }
/////////////////////////////////////////////////////////////////////
 public array_temp3(char[][] datachar)
 {
 this._datachar = datachar;//构造函数，传递数组
 ObjectType = 4;
 }
//////////////////////////////////////////////////////////////////////
 public String getFormatStr()
{

 //////////////////////////输出整数类型////////////////////////////////////
 if ( ObjectType == 0)
 {
 if (this._data==null||this._data.length==0
 ||this._data[0].length==0)
 this.rowCount = this._data.length;//获取行数
 this.colCount = this._data[0].length;//获取列数

 return null;//如果数组为空
 }
 else if ( ObjectType == 4 )
 {
 if (this._datachar==null||this._datachar.length==0
 ||this._datachar[0].length==0)
 this.rowCount = this._datachar.length;//获取行数
 this.colCount = this._datachar[0].length;//获取列数

 return null;//如果数组为空
 }
 //定义返回字符串
 String output = "The Data of two dimensional array:\n";
 for (int i=0;i<rowCount ;i++ )
 { //输出原始二维数组
 for (int j=0;j<colCount ;j++ )
{
 //二维数组的输出
 if ( ObjectType == 0)
 output += " "+_data[i][j]+" ";
 else if( ObjectType == 4 )
 output += " "+_datachar[i][j]+" ";
 }
 output += "\n";
 }
 return output;
 }
///////////////////////////////////////////////////////////////////////////
 public static void main(String[] args)
 {
 //预设 5 * 4 的矩阵数据
 int[][] Data =
 { { 9, 7, 6, 6},
 {9, 7, 6, 6},
 {3 , 5, 3, 3},
 {6, 6, 4 , 7},
 {7, 5, 1 , 4},
 {9 , 2, 8, 0}
 };
 //数组输出类
 array_temp3 temp = new array_temp3(Data);
 System.out.println(temp.getFormatStr());

 char[][] DataChar =
 {
 {'c', 'a', 'q', 'q'},
 {'q', 'd', 'g', 'm'},
 };
 //数组输出类
 array_temp3 tempChar = new array_temp3(DataChar);
 System.out.println(tempChar.getFormatStr());

 }
/////////////////////////////////////////////////////////////////////////////
}

我基本上写完了代码如下//PrintArray文件
/**
*
* Title: 打印数组的接口
* Description: 提供对多种数据类型数组的打印功能的即可
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public interface PrintArray {
 public void print(IntArray intarr); //打印int型数组
 public void print(LongArray longarr); //打印long型数组
 public void print(FloatArray floatarr); //打印float型数组
 public void print(DoubleArray doublearr); //打印double型数组
 public void print(CharArray chararr); //打印char型数组
 //.....
 //可以继续添加你要打印的其他类型数组
}//Printable文件/**
* Title:接收实现了打印各种类型数组的对象的接口
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public interface Printable {
 public void accept(PrintArray printer);
 public String[][] getPrintData(); //获得打印数据
}

//IntArray文件
/**
* Title: 接收实现int[][]的打印的对象
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public class IntArray implements Printable{
 private int[][] _array;
 public IntArray(int[][] array) {
_array = array;
 }
 //定义accept的具体内容这里是输入int型数组
 public void accept(PrintArray printer) {
printer.print(this);
 }
 private int getMaxLength(){//获取最大长度int的长度
int intlength = 0;
for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
if((""+this._array[i][j]).length()>intlength){
 intlength = (""+this._array[i][j]).length();
}
 }
}
return intlength;
 }
 public String[][] getPrintData(){
int intlength = getMaxLength();
String[][] _printdata = new String[_array.length][_array[0].length]; for(int i =0;i<_printdata.length;i++){
 for(int j =0;j<_printdata[0].length;j++){
_printdata[i][j] ="";
 }
}
for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
if((""+this._array[i][j]).length()<intlength){
 for(int k=0;k<intlength-(""+this._array[i][j]).length();k++){
_printdata[i][j] += " ";
 }
 _printdata[i][j] += _array[i][j];
}
else{
 _printdata[i][j] = ""+_array[i][j];
}
 }
}
return _printdata;
 }
}//LongArray文件/**
* Title: 接收实现long[][]的打印的对象
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public class LongArray implements Printable{
 private long[][] _array;
 public LongArray(long[][] array) {
_array = array;
 }
 //定义accept的具体内容这里是输入long型数组
 public void accept(PrintArray printer) {
printer.print(this);
 }
 private int getMaxLength(){//获取最大长度long的长度
int intlength = 0;
for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
if((""+this._array[i][j]).length()>intlength){
 intlength = (""+this._array[i][j]).length();
}
 }
}
return intlength;
 }
 public String[][] getPrintData(){
int intlength = getMaxLength();
String[][] _printdata = new String[_array.length][_array[0].length]; for(int i =0;i<_printdata.length;i++){
 for(int j =0;j<_printdata[0].length;j++){
_printdata[i][j] ="";
 }
}
for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
if((""+this._array[i][j]).length()<intlength){
 for(int k=0;k<intlength-(""+this._array[i][j]).length();k++){
_printdata[i][j] += " ";
 }
 _printdata[i][j] += _array[i][j];
}
else{
 _printdata[i][j] = ""+_array[i][j];
}
 }
}
return _printdata;
 }
}

//FloatArray文件
/**
* Title:接收实现float[][]的打印的对象 
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public class FloatArray implements Printable{ private float[][] _array;
 public FloatArray(float[][] array) {
_array = array;
 }
 //定义accept的具体内容这里是输入float型数组
 public void accept(PrintArray printer) {
printer.print(this);
 }
 private int getMaxLength(){//获取最大长度float的长度
 int intlength = 0;
 for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
 if((""+this._array[i][j]).length()>intlength){
 intlength = (""+this._array[i][j]).length();
 }
 }
 }
 return intlength;
 }
 public String[][] getPrintData(){
 int intlength = getMaxLength();
 String[][] _printdata = new String[_array.length][_array[0].length]; for(int i =0;i<_printdata.length;i++){
 for(int j =0;j<_printdata[0].length;j++){
 _printdata[i][j] ="";
 }
 }
 for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
 if((""+this._array[i][j]).length()<intlength){
 for(int k=0;k<intlength-(""+this._array[i][j]).length();k++){
 _printdata[i][j] += " ";
 }
 _printdata[i][j] += _array[i][j];
 }
 else{
 _printdata[i][j] = ""+_array[i][j];
 }
 }
 }
 return _printdata;
 }
}//DoubleArray文件
/**
* Title: 接收实现double[][]的打印的对象
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public class DoubleArray implements Printable{ private double[][] _array;
 public DoubleArray(double[][] array) {
_array = array;
 }
 //定义accept的具体内容这里是输入double型数组
 public void accept(PrintArray printer) {
printer.print(this);
 }
 private int getMaxLength(){//获取最大长度double的长度
 int intlength = 0;
 for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){ if((""+this._array[i][j]).length()>intlength){
 intlength = (""+this._array[i][j]).length();
 }
 }
 }
 return intlength;
 }
 public String[][] getPrintData(){
 int intlength = getMaxLength();
 String[][] _printdata = new String[_array.length][_array[0].length]; for(int i =0;i<_printdata.length;i++){
 for(int j =0;j<_printdata[0].length;j++){
 _printdata[i][j] ="";
 }
 }
 for(int i =0;i<this._array.length;i++){
 for(int j =0;j<this._array[0].length;j++){
 if((""+this._array[i][j]).length()<intlength){
 for(int k=0;k<intlength-(""+this._array[i][j]).length();k++){
 _printdata[i][j] += " ";
 }
 _printdata[i][j] += _array[i][j];
 }
 else{
 _printdata[i][j] = ""+_array[i][j];
 }
 }
 }
 return _printdata;
 }
}

//CharArray文件
/**
* Title: 接收实现char[][]的打印的对象
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author unascribed
* @version 1.0
*/public class CharArray implements Printable{ private char[][] _array;
 public CharArray(char[][] array) {
_array = array;
 }
 //定义accept的具体内容这里是输入char型数组
 public void accept(PrintArray printer) {
printer.print(this);
 }
 private int getMaxLength(){//获取最大长度char的长度
 return 1;
 }
 public String[][] getPrintData(){
 int intlength = getMaxLength();
 String[][] _printdata = new String[_array.length][_array[0].length]; for(int i =0;i<_printdata.length;i++){
 for(int j =0;j<_printdata[0].length;j++){
 _printdata[i][j] =""+_array[i][j];
 }
 }
 return _printdata;
 }
}

//PrintImplement1文件
/**
* Title:一种打印数组的接口的实现
* Description: 
* Copyright: Copyright (c) 2003
* Company: 
* @author dooby
* @version 1.0
*/public class PrintImplement1 implements PrintArray{ private final static String lefttop = "┏";
 private final static String leftbottom = "┗";
 private final static String righttop = "┓";
 private final static String rightbottom = "┛";
 private final static String middle = "┃"; private String printArray(String[][] _printdata){
int rowCount= _printdata.length;//获取行数
int colCount= _printdata[0].length;//获取列数
//定义返回字符串
String output = "The Data of two dimensional array:\n";
for (int i=0;i<rowCount ;i++ ){ //输出原始二维数组
 for (int j=0;j<colCount ;j++ ){
if ( j == 0 && i == 0 ) output += lefttop;
if ( j == 0 && i == rowCount-1 ) output += leftbottom;
if ( j == 0 && i != 0 && i != rowCount-1) output += middle;
//二维数组的输出
output += " "+_printdata[i][j]+" ";
if ( j == colCount-1 && i != 0 && i != rowCount-1) output += middle;
if ( j == colCount-1 && i == 0 ) output += righttop;
if ( j == colCount-1 && i == rowCount-1 ) output += rightbottom;
 }
 output += "\n";
}
return output;
 }
 //打印int型数组
 public void print(IntArray intarr){
System.out.println(this.printArray(intarr.getPrintData()));
 }
 //打印long型数组
 public void print(LongArray longarr){
System.out.println(this.printArray(longarr.getPrintData()));
 }
 //打印float型数组
 public void print(FloatArray floatarr){
System.out.println(this.printArray(floatarr.getPrintData()));
 }
 //打印double型数组
 public void print(DoubleArray doublearr){
System.out.println(this.printArray(doublearr.getPrintData()));
 }
 //打印char型数组
 public void print(CharArray chararr){
System.out.println(this.printArray(chararr.getPrintData()));
 } //测试函数
 public static void main(String[] args){ PrintImplement1 print = new PrintImplement1();
int[][] intarr ={
 {999, 7, 6, 6},
 {9, 7, 6, 6},
 {35555, 5, 3, 3},
 {6, 6, 4, 7},
 {7, 5, 1, 4},
 {1, 2, 8, 0}};
Printable able = new IntArray(intarr);
able.accept(print); long[][] longarr ={
 {99555559, 7, 6, 6},
 {9, 7, 6, 6},
 {35555, 5, 3, 3},
 {6, 6, 4, 7},
 {7555555, 5, 1, 4},
 {1, 2, 8, 0}};
able = new LongArray(longarr);
able.accept(print);
float[][] floatarr ={
 {9955.5559f, 70.10f, 6, 6},
 {9, 7, 6, 6},
 {35555, 5, 3, 3},
 {6, 6, 4, 7},
 {7555555, 5, 1, 4},
 {1, 2, 8, 0}};
able = new FloatArray(floatarr);
able.accept(print);
double[][] doublearr ={
 {9900000055.5559d, 70.10d, 6, 6},
 {9, 7, 6, 6},
 {35555, 5, 3, 3},
 {6, 6, 4, 7},
 {7555555, 5, 1, 4},
 {1, 2, 8, 0}};
able = new DoubleArray(doublearr);
able.accept(print);
char[][] chararr ={
 {'1', '1','1','1'},
 {'1', '1','1','1'},
 {'1', '1','1','1'},
 {'1', '1','1','1'},
 {'1', '1','1','1'},
 {'1', '1','1','1'}};
able = new CharArray(chararr);
able.accept(print); }
}

上面的代码可以让你很方便的添加一个其他类型的数组打印，只需要添加一个实现Printable接口的类就可以了，完全不用修改其他的实现类，并在PrintArray接口里面添加对应方法就可以了。而且你可以写出多个实现PrintArray的类，不一定非要打印出来【】的形式，可以打印出来||的形式

package ConsoleReader;public class ArrayPrint
{
 private int [] _dataone = null; //10
 private int [][] _data = null; //0
 private long [][] _datalong = null; //1
 private float [][] _datafloat = null; //2
 private double [][] _datadouble = null; //3
 private char [][] _datachar = null; //4


 private int _dimension;
 String[] _printone = null;
 String[][] _printdata0 = null;
 String[][] _printdata1 = null;
 String[][] _printdata2 = null;
 String[][] _printdata3 = null;
 String[][] _printdata4 = null;

 private int rowCount ;
 private int colCount ; public ArrayPrint(int[] data )//int[] 10
 {
 this._dataone = data ;//构造函数，传递数组
 this._dimension = 10;
 this.parseArray();
 }
 public ArrayPrint(int[][] data)//int[][] 0
 {
 this._data = data;//构造函数，传递数组
 this._dimension = 0;
 this.parseArray();
 }
 public ArrayPrint(long[][] data)//long[][] 1
 {
 this._datalong = data;//构造函数，传递数组
 this._dimension = 1;
 this.parseArray();
 }
 public ArrayPrint(float[][] data)//float[][] 2
 {
 this._datafloat = data;//构造函数，传递数组
 this._dimension = 2;
 this.parseArray();
 }
 public ArrayPrint(double[][] data)//double[][] 3
 {
 this._datadouble = data;//构造函数，传递数组
 this._dimension = 3;
 this.parseArray();
 }
 public ArrayPrint(char[][] data)//char[][] 4
 {
 this._datachar = data;//构造函数，传递数组
 this._dimension = 4;
 this.parseArray();
 }
///////////////////////////////////////////////////////////
 private int getMaxLength()
 { //获取最大长度数字的长度
 if (this._dimension == 0) //int[][]
 {
 int intlength = 0;
 for(int i =0;i<this._data.length;i++)
 {
 for(int j =0;j<this._data[0].length;j++)
 {
 if((""+this._data[i][j]).length() > intlength)
 {
 intlength = (""+this._data[i][j]).length();
 }
 }
 }
 return intlength;
 }
 else if(this._dimension == 10)//int[]
 {
 int intlength = 0;
 for(int i =0;i<this._dataone.length;i++)
 {
 if((""+this._dataone[i]).length() > intlength)
 {
 intlength = (""+this._dataone[i]).length();
 }
 }
 return intlength;
 }
 else if (this._dimension == 1)//long[][]
 {
 int intlength = 0;
 for(int i =0;i<this._datalong.length;i++)
 {
 for(int j =0;j<this._datalong[0].length;j++)
 {
 if((""+this._datalong[i][j]).length() > intlength)
 {
 intlength = (""+this._datalong[i][j]).length();
 }
 }
 }
 return intlength;
 }
 else if (this._dimension == 2)//float[][]
 {
 int intlength = 0;
 for(int i =0;i<this._datafloat.length;i++)
 {
 for(int j =0;j<this._datafloat[0].length;j++)
 {
 if((""+this._datafloat[i][j]).length() > intlength)
 {
 intlength = (""+this._datafloat[i][j]).length();
 }
 }
 }
 return intlength;
 }
 else if (this._dimension == 3)//double[][]
 {
 int intlength = 0;
 for(int i =0;i<this._datadouble.length;i++)
 {
 for(int j =0;j<this._datadouble[0].length;j++)
 {
 if((""+this._datadouble[i][j]).length() > intlength)
 {
 intlength = (""+this._datadouble[i][j]).length();
 }
 }
 }
 return intlength;
 }
 else if (this._dimension == 4)//char[][]
 {
 int intlength = 0;
 for(int i =0;i<this._datachar.length;i++)
 {
 for(int j =0;j<this._datachar[0].length;j++)
 {
 if((""+this._datachar[i][j]).length() > intlength)
 {
 intlength = (""+this._datachar[i][j]).length();
 }
 }
 }
 return intlength;
 }

 return 0;
 }

private void parseArray()
 { //格式化数组到字符串数组
 if (this._dimension == 0)
 {
 int intlength = getMaxLength();
 _printdata0 = new String[_data.length][_data[0].length]; for(int i =0;i<this._printdata0.length;i++)
 {
 for(int j =0;j<this._printdata0[0].length;j++)
 {
 _printdata0[i][j] ="";
 }
 }
 for(int i =0;i<this._data.length;i++)
 {
 for(int j =0;j<this._data[0].length;j++)
 {
 if((""+this._data[i][j]).length()<intlength)
 {
 _printdata0[i][j] += _data[i][j];
 for(int k=0;k<intlength-(""+this._data[i][j]).length();k++)
 {
 _printdata0[i][j] += " ";
 }

 }
 else
 {
 _printdata0[i][j] = ""+_data[i][j];
 }
 }
 }
 }
 else if(this._dimension == 10)
 {
 int intlength = getMaxLength();
 _printone = new String[_dataone.length]; for(int i =0;i<this._printone.length;i++)
 {
 _printone[i] ="";
 }
 for(int i =0;i<this._dataone.length;i++)
 {
 if((""+this._dataone[i] ).length()<intlength)
 {
 _printone[i] += _dataone[i] ;
 for(int k=0;k<intlength-(""+this._dataone[i] ).length();k++)
 {
 _printone[i] += " ";
 }

 }
 else
 {
 _printone[i] = ""+_dataone[i] ;
 }
 }
 }
 else if (this._dimension == 1) //long[][]
 {
 int intlength = getMaxLength();
 _printdata1 = new String[_datalong.length][_datalong[0].length]; for(int i =0;i<this._printdata1.length;i++)
 {
 for(int j =0;j<this._printdata1[0].length;j++)
 {
 _printdata1[i][j] ="";
 }
 }
 for(int i =0;i<this._datalong.length;i++)
 {
 for(int j =0;j<this._datalong[0].length;j++)
 {
 if((""+this._datalong[i][j]).length()<intlength)
 {
 _printdata1[i][j] += _datalong[i][j];
 for(int k=0;k<intlength-(""+this._datalong[i][j]).length();k++)
 {
 _printdata1[i][j] += " ";
 }

 }
 else
 {
 _printdata1[i][j] = ""+_datalong[i][j];
 }
 }
 }
 }
 else if (this._dimension == 2) //float[][]
 {
 int intlength = getMaxLength();
 _printdata2 = new String[_datafloat.length][_datafloat[0].length]; for(int i =0;i<this._printdata2.length;i++)
 {
 for(int j =0;j<this._printdata2[0].length;j++)
 {
 _printdata2[i][j] ="";
 }
 }
 for(int i =0;i<this._datafloat.length;i++)
 {
 for(int j =0;j<this._datafloat[0].length;j++)
 {
 if((""+this._datafloat[i][j]).length()<intlength)
 {
 _printdata2[i][j] += _datafloat[i][j];
 for(int k=0;k<intlength-(""+this._datafloat[i][j]).length();k++)
 {
 _printdata2[i][j] += " ";
 }

 }
 else
 {
 _printdata2[i][j] = ""+_datafloat[i][j];
 }
 }
 }
 }
 else if (this._dimension == 3) //double[][]
 {
 int intlength = getMaxLength();
 _printdata3 = new String[_datadouble.length][_datadouble[0].length]; for(int i =0;i<this._printdata3.length;i++)
 {
 for(int j =0;j<this._printdata3[0].length;j++)
 {
 _printdata3[i][j] ="";
 }
 }
 for(int i =0;i<this._datadouble.length;i++)
 {
 for(int j =0;j<this._datadouble[0].length;j++)
 {
 if((""+this._datadouble[i][j]).length()<intlength)
 {
 _printdata3[i][j] += _datadouble[i][j];
 for(int k=0;k<intlength-(""+this._datadouble[i][j]).length();k++)
 {
 _printdata3[i][j] += " ";
 }

 }
 else
 {
 _printdata3[i][j] = ""+_datadouble[i][j];
 }
 }
 }
 }
 else if (this._dimension == 4) //char[][]
 {
 int intlength = getMaxLength();
 _printdata4 = new String[_datachar.length][_datachar[0].length]; for(int i =0;i<this._printdata4.length;i++)
 {
 for(int j =0;j<this._printdata4[0].length;j++)
 {
 _printdata4[i][j] ="";
 }
 }
 for(int i =0;i<this._datachar.length;i++)
 {
 for(int j =0;j<this._datachar[0].length;j++)
 {
 if((""+this._datachar[i][j]).length()<intlength)
 {
 _printdata4[i][j] += _datachar[i][j];
 for(int k=0;k<intlength-(""+this._datachar[i][j]).length();k++)
 {
 _printdata4[i][j] += " ";
 }

 }
 else
 {
 _printdata4[i][j] = ""+_datachar[i][j];
 }
 }
 }
 }
 }

public String getFormatStr()
{
 if ( this._dimension == 0 ||this._dimension == 1 ||
 this._dimension == 2 ||this._dimension == 3 ||
 this._dimension == 4 )
 {

 if ( this._dimension == 0 )
 {
 if (_printdata0==null||_printdata0.length==0||this._printdata0[0].length==0)
 return null;//如果数组为空
 this.rowCount= this._printdata0.length;//获取行数
 this.colCount= this._printdata0[0].length;//获取列数
 }
 else if( this._dimension == 1 )
 {
 if (_printdata1==null||_printdata1.length==0||this._printdata1[0].length==0)
 return null;//如果数组为空
 this.rowCount= this._printdata1.length;//获取行数
 this.colCount= this._printdata1[0].length;//获取列数
 }
 else if( this._dimension == 2 )
 {
 if (_printdata2==null||_printdata2.length==0||this._printdata2[0].length==0)
 return null;//如果数组为空
 this.rowCount= this._printdata2.length;//获取行数
 this.colCount= this._printdata2[0].length;//获取列数
 }
 else if( this._dimension == 3 )
 {
 if (_printdata3==null||_printdata3.length==0||this._printdata3[0].length==0)
 return null;//如果数组为空
 this.rowCount= this._printdata3.length;//获取行数
 this.colCount= this._printdata3[0].length;//获取列数
 }
 else if( this._dimension == 4 )
 {
 if (_printdata4==null||_printdata4.length==0||this._printdata4[0].length==0)
 return null;//如果数组为空
 this.rowCount= this._printdata4.length;//获取行数
 this.colCount= this._printdata4[0].length;//获取列数
 }
 String output = null;// = "The Data of two dimensional array:\n";

 //定义返回字符串
 if ( this._dimension == 0 )
 output = "The Data of two dimensional int[][] array:\n";
 else if ( this._dimension == 1 )
 output = "The Data of two dimensional long[][] array:\n";
 else if ( this._dimension == 2 )
 output = "The Data of two dimensional float[][] array:\n";
 else if ( this._dimension == 3 )
 output = "The Data of two dimensional double[][] array:\n";
 else if ( this._dimension == 4 )
 output = "The Data of two dimensional char[][] array:\n";
 for (int i=0;i<rowCount ;i++ )
 { //输出原始二维数组
 for (int j=0;j<colCount ;j++ )
{
 if ( j == 0 && i == 0 )
 output += "┏";
 if ( j == 0 && i == rowCount-1 )
 output += "┗";
 if ( j == 0 && i != 0 && i != rowCount-1)
 output += "┃";
 //二维数组的输出
 if ( this._dimension == 0 )
 output += " "+_printdata0[i][j]+" ";
 else if ( this._dimension == 1 )
 output += " "+_printdata1[i][j]+" ";
 else if ( this._dimension == 2 )
 output += " "+_printdata2[i][j]+" ";
 else if ( this._dimension == 3 )
 output += " "+_printdata3[i][j]+" ";
 else if ( this._dimension == 4 )
 output += " "+_printdata4[i][j]+" "; if ( j == colCount-1 && i != 0 && i != rowCount-1)
 output += "┃";
 if ( j == colCount-1 && i == 0 )
 output += "┓";
 if ( j == colCount-1 && i == rowCount-1 )
 output += "┛";
 }
 output += "\n";
 }
 return output;
 }
 else if (this._dimension == 10)//int[]
 {
 if (_dataone==null||_dataone.length==0)
 {
 return null;//如果数组为空
 }
 this.rowCount= this._dataone.length;//获取可数
 String output = "The Data of one dimensional int[] array:\n";
 for ( int i = 0;i < rowCount;i++)
 output += " "+_printone[i]+" ";
 output += "\n";
 return output;
 }
 return null;
 }
////////////////////////////////////////////////////////////////////
/*
public static void main(String[] args)
 {
 //预设 5 * 4 的矩阵数据
 int[][] Data =
 { {94, 7, 6, 6},
 {9, 7, 6, 6},
 {3, 5, 3, 3},
 {6, 64, 4, 7},
 {7, 5, 1, 4},
 {1, 2, 8, 440}
 }; ArrayPrint temp = new ArrayPrint(Data);
 System.out.println(temp.getFormatStr());

 int [] num = {2,32,4,2,34,23,4,23,4,234,2,3};

 ArrayPrint temp2 = new ArrayPrint(num);
 System.out.println(temp2.getFormatStr());

 char[][] DataChar =
 {
 {'c', 'a', 'q', 'q'},
 {'q', 'd', 'g', 'm'},
 };
 //数组输出类
 ArrayPrint tempChar = new ArrayPrint(DataChar);
 System.out.println(tempChar.getFormatStr());

 long[][] DataLong =
 {
 {47, 7, 6, 6},
 {96, 76, 66, 606},
 {1009, 566, 3, 3},
 {6, 64, 46, 706},
 {7, 506, 1, 40},
 {168, 288, 8, 404}
 };
 //数组输出类
 ArrayPrint tempLong = new ArrayPrint(DataLong);
 System.out.println(tempLong.getFormatStr());

 float[][] DataFloat =
 {
 {479, 7, 6, 6},
 {96, 76, 66, 606},
 {109, 566, 3, 3},
 {6, 64, 46, 706},
 {7, 56, 1, 40},
 {168, 288, 8, 404}
 };
 //数组输出类
 ArrayPrint tempFloat = new ArrayPrint(DataFloat);
 System.out.println(tempFloat.getFormatStr());

 double[][] DataDoubel =
 {
 {4.79, 7, 6, 6},
 {96, 7.6, 66, 6.06},
 {1.09, 56.6, 3.00, 3},
 {6, 6.4, 46, 706},
 {7, 56, 1, 40},
 {1.68, 2.88, 8, 4.04}
 };
 //数组输出类
 ArrayPrint tempDouble = new ArrayPrint(DataDoubel);
 System.out.println(tempDouble.getFormatStr());
 }
*/
 }

呵呵,我曾写过一个类似的...
各种类型互相转换 ------------------------------------------------------
我们还年轻牛奶会有的奶牛也会有的
可天天在 csdn 混这些会有吗 ??

现在写的教学的意味多很多，真正应用的时候我应该会写得功能完备一些。加油了MPU (黑眼圈)，你问的几个问题，令我受益也很多（害我半夜看设计模式，呵呵）

这么复杂?写个通用类型打印方法,输出1维数组,然后用这个方法输出多维数组. (只用了3种类型,可以多添加其他类型)public void prt(Object o){
 int[] int_lis = null;
 double[] double_lis = null;
 float[] float_lis=null;
 int len;
 try{
 int_lis = (int[])o;
 len = int_lis.length;
 }catch(Exception e1){
 try{
 float_lis = (float[])o;
 len = float_lis.length;
 }catch(Exception e2){
 try{
 double_lis = (double[])o;
 len = double_lis.length;
 }catch(Exception e3){
 throw new RuntimeException(":(");
 }
 }
 }
 //然后判断哪个非空就输出
 for( int i = 0 ; i<len ; i++){
 System.out.pritln( int_lis!=null? int_lis[i]:
 float_lis!=null? float_lis[i]:
 double_lis!=null? double_lis[i]:Double.NaN);
 }

}

to dooby(德鲁比) :以前完全不懂设计模式，只在网上下了本《设计模式》的书。我的想法本来用C＋＋，template<class TYPE>泛形解决。但二维数组的参数传递void arrrayprint(long **pl , int d1 , int d2);太麻烦，而且从指针中，又肯定(问过高手)不能获得数组的维数。把二维数组传给vector<vector<TYPE> >又不会，觉得C＋＋学了好长时间像没学一样。所以就用Java写了一下，没想到“害我半夜看设计模式”。不好意思，谢谢了！

java现在支持有限的泛型编程啊，所以这些应该可以解决的。

调试易

■■Java暂时没有泛型，如何聪明的解决多类型问题？？？■■

解决方案 »