二维数组-String数组之间如何传值

问题描述

String数组之间如何传值

package com.excel.action;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

import jxl.Workbook;
import jxl.format.Alignment;
import jxl.format.Border;
import jxl.format.BorderLineStyle;
import jxl.format.Colour;
import jxl.format.UnderlineStyle;
import jxl.write.Label;
import jxl.write.NumberFormats;
import jxl.write.WritableCellFormat;
import jxl.write.WritableFont;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;

public class JxlTable {

private final static JxlTable jxlTable = new JxlTable();

public static JxlTable getInstance() {
    return jxlTable;
}

public JxlTable() {
}

public boolean createTable(String[] body, String filePath) {
    boolean createFlag = true;
    WritableWorkbook book;
    try {
        // 根据路径生成excel文件
        book = Workbook.createWorkbook(new File(filePath));
        // 创建一个sheet名为"表格"
        WritableSheet sheet = book.createSheet("表格", 0);
        // 设置NO列宽度
        sheet.setColumnView(1, 5);
        // 去掉整个sheet中的网格线
        sheet.getSettings().setShowGridLines(false);
        Label tempLabel = null;

        // 表体输出
        int bodyLen = body.length;
        // 循环写入表体内容
        for (int j = 0; j < bodyLen; j++) {
            String[] bodyTempArr = body[j].split(",");
            for (int k = 0; k < bodyTempArr.length; k++) {
                WritableCellFormat tempCellFormat = null;
                tempCellFormat = getBodyCellStyle();
                if (tempCellFormat != null) {
                    if (k == 0 || k == (bodyTempArr.length - 1)) {
                        tempCellFormat.setAlignment(Alignment.CENTRE);
                    }
                }
                tempLabel = new Label(1 + k, 2 + j, bodyTempArr[k],
                        tempCellFormat);
                sheet.addCell(tempLabel);
            }
        }
        book.write();
        book.close();
    } catch (IOException e) {
        createFlag = false;
        System.out.println("EXCEL创建失败!");
        e.printStackTrace();
    } catch (RowsExceededException e) {
        createFlag = false;
        System.out.println("EXCEL单元设置创建失败!");
        e.printStackTrace();
    } catch (WriteException e) {
        createFlag = false;
        System.out.println("EXCEL写入失败!");
        e.printStackTrace();
    }

    return createFlag;
}

public WritableCellFormat getHeaderCellStyle() {
    WritableFont font = new WritableFont(WritableFont.createFont("宋体"), 10,
            WritableFont.BOLD, false, UnderlineStyle.NO_UNDERLINE);
    WritableCellFormat headerFormat = new WritableCellFormat(
            NumberFormats.TEXT);
    try {
        // 添加字体设置
        headerFormat.setFont(font);
        // 设置单元格背景色:表头为黄色
        headerFormat.setBackground(Colour.YELLOW);
        // 设置表头表格边框样式
        // 整个表格线为粗线、黑色
        headerFormat.setBorder(Border.ALL, BorderLineStyle.THICK,
                Colour.BLACK);
        // 表头内容水平居中显示
        headerFormat.setAlignment(Alignment.CENTRE);
    } catch (WriteException e) {
        System.out.println("表头单元格样式设置失败!");
    }
    return headerFormat;
}

public WritableCellFormat getBodyCellStyle() {
    WritableFont font = new WritableFont(WritableFont.createFont("宋体"), 10,
            WritableFont.NO_BOLD, false, UnderlineStyle.NO_UNDERLINE);
    WritableCellFormat bodyFormat = new WritableCellFormat(font);
    try {
        // 设置单元格背景色:表体为白色
        bodyFormat.setBackground(Colour.WHITE);
        // 设置表头表格边框样式
        // 整个表格线为细线、黑色
        bodyFormat
                .setBorder(Border.ALL, BorderLineStyle.THIN, Colour.BLACK);
    } catch (WriteException e) {
        System.out.println("表体单元格样式设置失败!");
    }
    return bodyFormat;
}

   /**
 * 读取Excel的内容,第一维数组存储的是一行中格列的值,二维数组存储的是多少个行
 * @param file 读取数据的源Excel
 * @param ignoreRows 读取数据忽略的行数,比喻行头不需要读入 忽略的行数为1
 * @return 读出的Excel中数据的内容
 * @throws FileNotFoundException
 * @throws IOException
 */
public static String[][] getData(File file, int ignoreRows)
       throws FileNotFoundException, IOException {
   List<String[]> result = new ArrayList<String[]>();
   int rowSize = 0;
   BufferedInputStream in = new BufferedInputStream(new FileInputStream(
          file));
   // 打开HSSFWorkbook
   POIFSFileSystem fs = new POIFSFileSystem(in);
   HSSFWorkbook wb = new HSSFWorkbook(fs);
   HSSFCell cell = null;
   for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++) {
       HSSFSheet st = wb.getSheetAt(sheetIndex);
       // 第一行为标题,不取
       for (int rowIndex = ignoreRows; rowIndex <= st.getLastRowNum(); rowIndex++) {
          HSSFRow row = st.getRow(rowIndex);
          if (row == null) {
              continue;
          }
          int tempRowSize = row.getLastCellNum() + 1;
          if (tempRowSize > rowSize) {
              rowSize = tempRowSize;
          }
          String[] values = new String[rowSize];
          Arrays.fill(values, "");
          boolean hasValue = false;
          for (short columnIndex = 0; columnIndex <= row.getLastCellNum(); columnIndex++) {
              String value = "";
              cell = row.getCell(columnIndex);
              if (cell != null) {
                 // 注意:一定要设成这个,否则可能会出现乱码
                 cell.setEncoding(HSSFCell.ENCODING_UTF_16);
                 switch (cell.getCellType()) {
                 case HSSFCell.CELL_TYPE_STRING:
                     value = cell.getStringCellValue();
                     break;
                 case HSSFCell.CELL_TYPE_NUMERIC:
                     if (HSSFDateUtil.isCellDateFormatted(cell)) {
                        Date date = cell.getDateCellValue();
                        if (date != null) {
                            value = new SimpleDateFormat("yyyy-MM-dd")
                                   .format(date);
                        } else {
                            value = "";
                        }
                     } else {
                        value = new DecimalFormat("0").format(cell
                               .getNumericCellValue());
                     }
                     break;
                 case HSSFCell.CELL_TYPE_FORMULA:
                     // 导入时如果为公式生成的数据则无值
                     if (!cell.getStringCellValue().equals("")) {
                        value = cell.getStringCellValue();
                     } else {
                        value = cell.getNumericCellValue() + "";
                     }
                     break;
                 case HSSFCell.CELL_TYPE_BLANK:
                     break;
                 case HSSFCell.CELL_TYPE_ERROR:
                     value = "";
                     break;
                 case HSSFCell.CELL_TYPE_BOOLEAN:
                     value = (cell.getBooleanCellValue() == true ? "Y"
                            : "N");
                     break;
                 default:
                     value = "";
                 }
              }
              if (columnIndex == 0 && value.trim().equals("")) {
                 break;
              }
              values[columnIndex] = rightTrim(value);
              hasValue = true;
          }

          if (hasValue) {
              result.add(values);
          }
       }
   }
   in.close();
   String[][] returnArray = new String[result.size()][rowSize];
   for (int i = 0; i < returnArray.length; i++) {
       returnArray[i] = (String[]) result.get(i);
   }
   return returnArray;
}

/**
 * 去掉字符串右边的空格
 * @param str 要处理的字符串
 * @return 处理后的字符串
 */
 public static String rightTrim(String str) {
   if (str == null) {
       return "";
   }
   int length = str.length();
   for (int i = length - 1; i >= 0; i--) {
       if (str.charAt(i) != 0x20) {
          break;
       }
       length--;
   }
   return str.substring(0, length);
}

public static void main(String[] args) throws Exception {
     File file = new File("F:/tomcat7/webapps/Excel/upload/3.xls");
       String[][] result = getData(file, 1);
       int rowLength = result.length;
       for(int i=0;i<rowLength;i++) {
           for(int j=0;j<result[i].length;j++) {
              System.out.print(result[i][j]+"tt");
           }
           System.out.println();
       }
    String[][] body = result;   //如何传值?

    String filePath = "F:/tomcat7/webapps/Excel/upload/3333.xls";
    JxlTable testJxl = JxlTable.getInstance();
    boolean flag = testJxl.createTable(body, filePath);  /////在这里报错 如何传值 求助
    if (flag) {
        System.out.println("表格创建成功!!");
    }
}

}

解决方案

大概改了下,你试试

package com.excel.action;
 import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import jxl.Workbook;
import jxl.format.Alignment;
import jxl.format.Border;
import jxl.format.BorderLineStyle;
import jxl.format.Colour;
import jxl.format.UnderlineStyle;
import jxl.write.Label;
import jxl.write.NumberFormats;
import jxl.write.WritableCellFormat;
import jxl.write.WritableFont;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;

public class JxlTable {
    private final static JxlTable jxlTable = new JxlTable();
    public boolean createTable(List<String[]>data, String filePath) {
        boolean createFlag = true;
        WritableWorkbook book;
        try {
            // 根据路径生成excel文件
            book = Workbook.createWorkbook(new File(filePath));
            // 创建一个sheet名为"表格"
            WritableSheet sheet = book.createSheet("表格", 0);
            // 设置NO列宽度
            sheet.setColumnView(1, 5);
            // 去掉整个sheet中的网格线
            sheet.getSettings().setShowGridLines(false);
            Label tempLabel = null;

            // 表体输出
            int bodyLen = body.length;
            // 循环写入表体内容
            for (int j = 0; j < bodyLen; j++) {
                String[] bodyTempArr = data.get(j);
                for (int k = 0; k < bodyTempArr.length; k++) {
                    WritableCellFormat tempCellFormat = null;
                    tempCellFormat = getBodyCellStyle();
                    if (tempCellFormat != null) {
                        if (k == 0 || k == (bodyTempArr.length - 1)) {
                            tempCellFormat.setAlignment(Alignment.CENTRE);
                        }
                    }
                    tempLabel = new Label(1 + k, 2 + j, bodyTempArr[k], tempCellFormat);
                    sheet.addCell(tempLabel);
                }
            }
            book.write();
            book.close();
        } catch (IOException e) {
            createFlag = false;
            System.out.println("EXCEL创建失败!");
            e.printStackTrace();
        } catch (RowsExceededException e) {
            createFlag = false;
            System.out.println("EXCEL单元设置创建失败!");
            e.printStackTrace();
        } catch (WriteException e) {
            createFlag = false;
            System.out.println("EXCEL写入失败!");
            e.printStackTrace();
        }

        return createFlag;
    }

    public WritableCellFormat getHeaderCellStyle() {
        WritableFont font = new WritableFont(WritableFont.createFont("宋体"), 10, WritableFont.BOLD, false,
                UnderlineStyle.NO_UNDERLINE);
        WritableCellFormat headerFormat = new WritableCellFormat(NumberFormats.TEXT);
        try {
            // 添加字体设置
            headerFormat.setFont(font);
            // 设置单元格背景色:表头为黄色
            headerFormat.setBackground(Colour.YELLOW);
            // 设置表头表格边框样式
            // 整个表格线为粗线、黑色
            headerFormat.setBorder(Border.ALL, BorderLineStyle.THICK, Colour.BLACK);
            // 表头内容水平居中显示
            headerFormat.setAlignment(Alignment.CENTRE);
        } catch (WriteException e) {
            System.out.println("表头单元格样式设置失败!");
        }
        return headerFormat;
    }

    public WritableCellFormat getBodyCellStyle() {
        WritableFont font = new WritableFont(WritableFont.createFont("宋体"), 10, WritableFont.NO_BOLD, false,
                UnderlineStyle.NO_UNDERLINE);
        WritableCellFormat bodyFormat = new WritableCellFormat(font);
        try {
            // 设置单元格背景色:表体为白色
            bodyFormat.setBackground(Colour.WHITE);
            // 设置表头表格边框样式
            // 整个表格线为细线、黑色
            bodyFormat.setBorder(Border.ALL, BorderLineStyle.THIN, Colour.BLACK);
        } catch (WriteException e) {
            System.out.println("表体单元格样式设置失败!");
        }
        return bodyFormat;
    }

    /**
     * 读取Excel的内容,第一维数组存储的是一行中格列的值,二维数组存储的是多少个行
     *
     * @param file
     *            读取数据的源Excel
     * @param ignoreRows
     *            读取数据忽略的行数,比喻行头不需要读入 忽略的行数为1
     * @return 读出的Excel中数据的内容
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static List<String[]> getData(File file, int ignoreRows) throws FileNotFoundException, IOException {
        List<String[]> result = new ArrayList<String[]>();
        int rowSize = 0;
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
        // 打开HSSFWorkbook
        POIFSFileSystem fs = new POIFSFileSystem(in);
        HSSFWorkbook wb = new HSSFWorkbook(fs);
        HSSFCell cell = null;
        for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++) {// getNumberOfSheets:读取sheet的数量
            HSSFSheet st = wb.getSheetAt(sheetIndex);// 第一个sheet
            // 第一行为标题,不取rowIndex=1
            for (int rowIndex = ignoreRows; rowIndex <= st.getLastRowNum(); rowIndex++) {// 每一行的数据存入一个数组中,再将这个数组加入到一个list中
                HSSFRow row = st.getRow(rowIndex);
                if (row == null) {
                    continue;
                }
                int tempRowSize = row.getLastCellNum() + 1;
                if (tempRowSize > rowSize) {
                    rowSize = tempRowSize;
                }
                String[] values = new String[rowSize];// 以列数为大小创建一个String数组对其中的每个元素并赋值空字符串
                Arrays.fill(values, "");
                boolean hasValue = false;
                for (short columnIndex = 0; columnIndex <= row.getLastCellNum(); columnIndex++) {
                    String value = "";
                    cell = row.getCell(columnIndex);// 取这一行的每一个单元格
                    if (cell != null) {
                        // 注意:一定要设成这个,否则可能会出现乱码
                        cell.setEncoding(HSSFCell.ENCODING_UTF_16);
                        switch (cell.getCellType()) {// 根据每个单元格的数据类型取值
                        case HSSFCell.CELL_TYPE_STRING:
                            value = cell.getStringCellValue();
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC:
                            if (HSSFDateUtil.isCellDateFormatted(cell)) {
                                Date date = cell.getDateCellValue();
                                if (date != null) {
                                    value = new SimpleDateFormat("yyyy-MM-dd").format(date);
                                } else {
                                    value = "";
                                }
                            } else {
                                value = new DecimalFormat("0").format(cell.getNumericCellValue());
                            }
                            break;
                        case HSSFCell.CELL_TYPE_FORMULA:
                            // 导入时如果为公式生成的数据则无值
                            if (!cell.getStringCellValue().equals("")) {
                                value = cell.getStringCellValue();
                            } else {
                                value = cell.getNumericCellValue() + "";
                            }
                            break;
                        case HSSFCell.CELL_TYPE_BLANK:
                            break;
                        case HSSFCell.CELL_TYPE_ERROR:
                            value = "";
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN:
                            value = (cell.getBooleanCellValue() == true ? "Y" : "N");
                            break;
                        default:
                            value = "";
                        }
                    }
                    if (columnIndex == 0 && value.trim().equals("")) {
                        break;
                    }
                    values[columnIndex] = rightTrim(value);
                    hasValue = true;
                }

                if (hasValue) {
                    result.add(values);
                }
            }
        }
        in.close();
//      String[][] returnArray = new String[result.size()][rowSize];
//      for (int i = 0; i < returnArray.length; i++) {
//          returnArray[i] = (String[]) result.get(i);
//      }
        return result;
    }

    /**
     * 去掉字符串右边的空格
     *
     * @param str
     *            要处理的字符串
     * @return 处理后的字符串
     */
    public static String rightTrim(String str) {
        if (str == null) {
            return "";
        }
        int length = str.length();
        for (int i = length - 1; i >= 0; i--) {
            if (str.charAt(i) != 0x20) {
                break;
            }
            length--;
        }
        return str.substring(0, length);
    }

    public static void main(String[] args) throws Exception {
        File file = new File("F:/tomcat7/webapps/Excel/upload/3.xls");
        List<String[]> result = getData(file, 1);
//      int rowLength = result.length;
//      for (int i = 0; i < rowLength; i++) {
//          for (int j = 0; j < result[i].length; j++) {
//              System.out.print(result[i][j] + "tt");
//          }
//          System.out.println();
//      }
//      String[][] body = result; // 如何传值?

        String filePath = "F:/tomcat7/webapps/Excel/upload/3333.xls";

        boolean flag = jxlTable.createTable(result, filePath); ///// 传个List
        if (flag) {
            System.out.println("表格创建成功!!");
        }
    }
}

解决方案二:

你方法定义的是一维数组,main方法传参的body是二维数组,当然死报错的了。。。

解决方案三:

能否贴点数据啊,不好测试

解决方案四:

看你的createTable()方法可以知道,你的参数有问题,如果按照你getData()方法的写法这里应该是 String[][] body而不是 String[]body,这个
问题楼上已经说了,createTable参数有问题
有几个地方建议一下:
1、getData()方法中最后你为什么要把最终结果从list里取出来再放入一个数组中?直接返回这个list不好吗?然后修改下createTable()直接把这个list扔给它处理,看你createTable()的写法也应该是这样的
2、根据你的createTable()中的取值方式可以看到你的每一行数据中的各个单元格数据应该是以","分割的,但在你的getData()方法里我好像没有看到向其中加这个分割符

时间: 2025-01-20 15:01:33

二维数组-String数组之间如何传值的相关文章

关于 二维码 与 NFC 之间的出身贫贱说

关于 二维码 与 NFC 之间的出身贫贱说 太阳火神的美丽人生 (http://blog.csdn.net/opengl_es) 本文遵循"署名-非商业用途-保持一致"创作公用协议 转载请保留此句:太阳火神的美丽人生 -  本博客专注于 敏捷开发及移动和物联设备研究:iOS.Android.Html5.Arduino.pcDuino,否则,出自本博客的文章拒绝转载或再转载,谢谢合作. 二维码,这个大家都非常了解了,用微信一扫,添加好友了:用360手机助手一扫,软件下载了:这是在传递一串

HDU 1892 二维树状数组

题意给的操作讲的很明白 注意不能出现负数 坐标值可能为0 两个坐标大小不能确定  #include <iostream> #include<cstdio> #include<cstring> using namespace std; const int maxn = 1002; int tree[maxn + 2][maxn + 2]; int n; inline int Lowbit(int x) { return x&(-x); } inline void

HDU 2642 二维树状数组

题意很明确 给你一个图某坐标上的星星亮 暗 条件 求出当前区间内所有亮星星的总数  #include <iostream> #include<cstdio> #include<cstring> using namespace std; const int maxn = 1005; int tree[maxn + 2][maxn + 2]; inline int Lowbit(int x) { return x&(-x); } inline void Update

poj 2155 Matrix 二维树状数组

   经典题,把一个-=写成=-了查了半天都没查出来-- /* author:jxy lang:C/C++ university:China,Xidian University **If you need to reprint,please indicate the source** */ #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include

2013级C++第15周项目——二维数组

课程主页在:http://blog.csdn.net/sxhelijian/article/details/11890759 [项目1-折腾二维数组]创建一个长度为5行4列的二维整型数组,通过初始化,为数组中的前两列的10个元素赋初值,然后通过键盘输入,使后两列的10个元素获得值,将所有元素值乘以3后保存在数组中.输出数组时,按行序优先输出,再按列序优先输出(输出的第一行是数组中的第一列--,其实输出的就是"转置"),再将数组"倒"着输出(即最后一行最后一列的最先输

2014秋C++ 第14周项目 二维数组

课程主页在http://blog.csdn.net/sxhelijian/article/details/39152703,课程资源在云学堂"贺老师课堂"同步展示,使用的帐号请到课程主页中查看.  [项目1-折腾二维数组]创建一个5行4列的二维整型数组,通过初始化,为数组中的前两列的10个元素赋初值,然后: 通过键盘输入,使后两列的10个元素获得值: 按行序优先输出数组元素: 将所有元素值乘以3后保存在数组中: 按列序优先输出(输出的第一行是数组中的第一列--,其实输出的就是"

Java千百问_06数据结构(017)_什么是二维数组

1.二维数组如何定义 Java语言中,多维数组被看作数组的数组.  了解一维数组看这里:java中的数组是什么  定义方式和一维数组类似,如下: type arrayName[ ][ ]: type [ ][ ]arrayName; 2.二维数组如何初始化 二维数组初始化和一维数组一样,分为静态初始化和动态初始化 静态初始化  Java语言中,由于把二维数组看作是数组的数组,数组空间不是连续分配的,所以不要求二维数组每一维的大小相同.初始化方式如下: int intArray[ ][ ]={{1

《C语言及程序设计》实践项目——二维数组

返回:贺老师课程教学链接 [项目1-折腾二维数组]创建一个5行4列的二维整型数组,通过初始化,为数组中的前两列的10个元素赋初值,然后: 通过键盘输入,使后两列的10个元素获得值: 按行序优先输出数组元素: 将所有元素值乘以3后保存在数组中: 按列序优先输出(输出的第一行是数组中的第一列--,其实输出的就是"转置"): 将数组"倒"着输出(即最后一行最后一列的最先输出,第0行第0列的最后输出): 输出数组中的所有偶数: 输出所有行列下标之和为3的倍数的元素值. #i

C++第15周项目1——折腾二维数组

课程首页地址:http://blog.csdn.net/sxhelijian/article/details/7910565 [项目1-折腾二维数组]创建一个长度为5行4列的二维整型数组,通过初始化,为数组中的前两列的10个元素赋初值,然后通过键盘输入,使后两列的10个元素获得值,将所有元素值乘以3后保存在数组中.输出数组时,按行序优先输出,再按列序优先输出(输出的第一行是数组中的第一列--,其实输出的就是"转置"),再将数组"倒"着输出(即最后一行最后一列的最先输