精华内容
下载资源
问答
  • java打印表格到打印机

    2021-03-17 19:52:05
    在这里我我有部分功能是要将一张表格通过java调用打印机打印出来,这里要用到java的Printable接口Printable 接口由当前页面 painter 的 print 方法实现,该方法由打印系统调用,以呈现页面。构建 Pageable 时,使用 ...

    在这里我我有部分功能是要将一张表格通过java调用打印机打印出来,这里要用到java的Printable接口

    Printable 接口由当前页面 painter 的 print 方法实现,该方法由打印系统调用,以呈现页面。构建 Pageable 时,使用 PageFormat 实例和实现此接口的实例构成的实例用于描述每个页面。调用实现 Printable 的实例,以打印页面的图形。

    在 PrinterJob 上可以设置 Printable(..)。当客户端随后通过调用 PrinterJob.print(..) 启动打印时,控制被传送到打印系统,直到所有的页面完成打印。这是通过在文档中所有页面打印完成前一直调用 Printable.print(..) 来实现的。使用 Printable 接口时,只要打印系统请求,该打印就将页面内容提交给图像。

    Printable.print(..) 的参数包括描述该页面可打印区域(计算适合该页面的内容所需要的区域)的 PageFormat 和页面索引(它指定请求页面的从 0 开始的打印流索引)。

    在这里我通过链表来获取表格内容,以实现动态改变要打印出来的表格的大小,而我在打印方法中是用二维数组来实现打印和定位的,

    因此有了个蛋痛的将链表转化为一维数组,然后又将一维数组转化为二维数组的过程。

    链表转化为一维数组可以直接用toarray()方法

    而一维数组转化为二维数组,int n = 4;//列

    int m = osf.getInfoStrings().length/n;//行

    String[][] data1 = new String[m][n];

    int num = -1;

    for (int i = 0; i < m; i++) {

    for (int j = 0; j < n; j++) {

    num++;

    data1[i][j] = (String)osf.getInfoStrings()[num];

    }

    }

    重要的实现部分就是,画出表格然后打印

    为了使打印窗口显示在最前面,这里是在JDialog上画的表格

    jdialog = new JDialog();

    jdialog.addWindowListener(new WindowAdapter(){

    public void windowClosing(WindowEvent e){

    System.exit(0);}});

    TableModel dataModel = new AbstractTableModel() {

    public int getColumnCount() {

    return headers.length; }

    public int getRowCount() { return data.length;}

    public Object getValueAt(int row, int col) {

    return data[row][col];}

    public String getColumnName(int column) {

    return headers[column];}

    public Class getColumnClass(int col) {

    return getValueAt(0,col).getClass();}

    public boolean isCellEditable(int row, int col) {

    return (col==1);}

    };

    tableView = new JTable(dataModel);

    JScrollPane scrollpane = new JScrollPane(tableView);

    scrollpane.setPreferredSize(new Dimension(500, 80));

    jdialog.getContentPane().setLayout(new BorderLayout());

    jdialog.getContentPane().add(BorderLayout.CENTER,scrollpane);

    jdialog.pack();

    printButton= new JButton();

    printButton.setText("打印");

    jdialog.getContentPane().add(BorderLayout.SOUTH,printButton);

    RepaintManager.currentManager(jdialog).setDoubleBufferingEnabled(false);

    printButton.addActionListener(this);

    jdialog.setBounds(300, 100, 650, 500);

    jdialog.setVisible(true);

    }

    public void actionPerformed(ActionEvent e)

    {

    if(e.getSource()== printButton)

    {

    PrinterJob pj=PrinterJob.getPrinterJob();

    pj.setPrintable(TablePrint.this);

    pj.printDialog();

    try{

    pj.print();

    }

    catch (Exception PrintException) {}

    }

    jdialog.dispose();

    }

    public int print(Graphics g, PageFormat pageFormat, int pageIndex) throws PrinterException {

    Graphics2D  g2 = (Graphics2D) g;

    g2.setColor(Color.black);

    int fontHeight=g2.getFontMetrics().getHeight();

    int fontDesent=g2.getFontMetrics().getDescent();

    //leave room for page number

    double pageHeight = pageFormat.getImageableHeight()-fontHeight;

    double pageWidth =  pageFormat.getImageableWidth();

    double tableWidth = (double)

    tableView.getColumnModel().getTotalColumnWidth();

    double scale = 1;

    if (tableWidth >= pageWidth) {

    scale =  pageWidth / tableWidth;

    }

    double headerHeightOnPage= tableView.getTableHeader().getHeight()*scale;

    double tableWidthOnPage=tableWidth*scale;

    double oneRowHeight=(tableView.getRowHeight()+ tableView.getRowMargin())*scale;

    int numRowsOnAPage= (int)((pageHeight-headerHeightOnPage)/ oneRowHeight);

    double pageHeightForTable=oneRowHeight* numRowsOnAPage;

    int totalNumPages= (int)Math.ceil(((double)tableView.getRowCount())/ numRowsOnAPage);

    if(pageIndex>=totalNumPages) {

    return NO_SUCH_PAGE;

    }

    g2.translate(pageFormat.getImageableX(), pageFormat.getImageableY());

    //bottom center

    g2.drawString("Page: "+(pageIndex+1), (int)pageWidth/2-35, (int)(pageHeight+fontHeight-fontDesent));

    g2.translate(0f,headerHeightOnPage);

    g2.translate(0f,-pageIndex*pageHeightForTable);

    //If this piece of the table is smaller

    //than the size available,

    //clip to the appropriate bounds.

    if (pageIndex + 1 == totalNumPages) {

    int lastRowPrinted = numRowsOnAPage * pageIndex;

    int numRowsLeft = tableView.getRowCount() - lastRowPrinted;

    g2.setClip(0, (int)(pageHeightForTable * pageIndex), (int) Math.ceil(tableWidthOnPage), (int) Math.ceil(oneRowHeight *  numRowsLeft));

    }

    //else clip to the entire area available.

    else{

    g2.setClip(0, (int)(pageHeightForTable*pageIndex), (int) Math.ceil(tableWidthOnPage), (int) Math.ceil(pageHeightForTable));

    }

    g2.scale(scale,scale);

    tableView.paint(g2);

    g2.scale(1/scale,1/scale);

    g2.translate(0f,pageIndex*pageHeightForTable);

    g2.translate(0f, -headerHeightOnPage);

    g2.setClip(0, 0, (int) Math.ceil(tableWidthOnPage), (int)Math.ceil(headerHeightOnPage));

    g2.scale(scale,scale);

    tableView.getTableHeader().paint(g2);

    //paint header at top

    return Printable.PAGE_EXISTS;

    }

    编程依旧博大精深,在此还是略窥皮毛

    在这留个脚印,以后继续踩踩...

    展开全文
  • Java 控制台 打印表格 可前往http://blog.csdn.net/j506825719/article/details/78996659查看效果图后再决定是否需要下载。
  • Java 打印表格 到A4纸的可用代码

    热门讨论 2014-05-07 21:18:53
    已试用,可行.用Java 打印表格 到A4纸的可用代码,
  • Java打印表格 Console/控制台

    千次阅读 2020-09-14 11:18:46
    功能: 控制台打印表格,支持字段动态长度,左对齐,设置最多打印多少行。 更多代码请参考具体类,下载链接:[https://download.csdn.net/download/qq_26599807/12840079]

    功能: 控制台打印表格,支持字段动态长度,左对齐,设置最多打印多少行。

    效果图:

    纯英文结果:
    在这里插入图片描述

    中英文混合结果:
    在这里插入图片描述
    SQL查询结果:
    在这里插入图片描述


    例1:简单使用

    ConsoleTable t = new ConsoleTable();
    t.appendHeader("No").appendHeader("Name").appendHeader("Sex").appendHeader("Undifin");
    t.appendRow();
    t.appendBody("S01").appendBody("MrLiu").appendBody("O").appendBody("88");
    t.appendRow();
    t.appendBody("S02").appendBody("MrLiu").appendBody("O").appendBody("99");
    t.appendRow();
    t.appendBody("S03").appendBody("MrLiu").appendBody("X").appendBody("58");
    System.out.println(t.toString());
    
    ConsoleTable t = new ConsoleTable();
    t.appendHeader("学号").appendHeader("姓名").appendHeader("性别").appendHeader("成绩");
    t.appendRow();
    t.appendBody("S01").appendBody("刘亿菲").appendBody("女").appendBody("88");
    t.appendRow();
    t.appendBody("中开04").appendBody("a").appendBody("b").appendBody("7");
    t.appendRow();
    t.appendBody("S02").appendBody("迪丽乐巴").appendBody("女").appendBody("99");
    t.appendRow();
    t.appendBody("S03").appendBody("张伟").appendBody("男").appendBody("58");
    System.out.println(t.toString());
    
    

    例2:进阶使用

    数据类型:Mysql的desc表结构的结果,List结果,show index结果等等…
    进阶输出:调用toString方法,得到字符串,可以保存到日志文件。
    部分代码:

    	private List<Object> header = new ArrayList<Object>();
    	private int headerSize = 0;
    	private List<List<Object>> body = new ArrayList<List<Object>>();
    	private int bodySize = 0;
    	private boolean printHeader = true;
    	private int maxValueLenth = 50;
    
    	public boolean isPrintHeader() {
    		return printHeader;
    	}
    
    	public void setPrintHeader(boolean printHeader) {
    		this.printHeader = printHeader;
    	}
    
    	public int getMaxValueLenth() {
    		return maxValueLenth;
    	}
    
    	/**
    	 * TODO 设置列值最大长度,超过则用省略号代替(需大于0且在头与内容前面设置有效)
    	 * 
    	 * @param maxValueLenth
    	 */
    	public void setMaxValueLenth(int maxValueLenth) {
    		if (maxValueLenth > 0 && headerSize + bodySize == 0)
    			this.maxValueLenth = maxValueLenth;
    	}
    
    	public ConsoleTable() {
    	}
    
    	public ConsoleTable(boolean printHeader) {
    		this.printHeader = printHeader;
    	}
    
    	public ConsoleTable(boolean printHeader, int maxValueLenth) {
    		this.printHeader = printHeader;
    		this.maxValueLenth = maxValueLenth;
    	}
    
    

    缺点:由于使用了\0字符串结尾字符,不支持复制粘贴。
    更多代码请参考具体类,下载链接:https://download.csdn.net/download/qq_26599807/12840079

    展开全文
  • JAVA在控制台打印表格的工具类,链式调用,注释齐全。 支持自定义:表格对齐方式、是否等宽、左右边距、水平垂直交叉空白填充符,打印数据格式支持: Object[][] List《Object[]》 List《List《Object》》 List...
  • 将对象通过console打印表格样式(类似控制台mysql查询) 支持list,List<Object> ,Object[],Iterator,Object等,不支持如:List<Integer> 等泛型为基本数据类型的集合。
  • 1. 统计表格没一列中的最长的字符串的长度. 2. 打印一列的时候,使用最长的长度作为列的长度. 3. java中可以通过System.out.printf("%长度s",string).这样的形式按长度打印.

    java打印表格 将ResultSet中的数据打印成表格

    问题描述

    MySQL的查询语句输出如下:

    mysql> select * from instructor;
    +-------+------------+------------+-----------+
    | ID    | name       | dept_name  | salary    |
    +-------+------------+------------+-----------+
    | 10101 | Srinivasan | Comp. Sci. | 65000.00  |
    | 12121 | Wu         | Finance    | 90000.00  |
    | 15151 | Mozart     | Music      | 40000.00  |
    | 22222 | Einstein   | Physics    | 95000.00  |
    | 25566 | Brown      | Biology    | 100000.00 |
    | 30765 | Green      | Music      | NULL      |
    | 32343 | El Said    | History    | 60000.00  |
    | 33456 | Gold       | Physics    | 87000.00  |
    | 45565 | Katz       | Comp. Sci. | 75000.00  |
    | 58583 | Califieri  | History    | 62000.00  |
    | 76543 | Singh      | Finance    | 80000.00  |
    | 76766 | Crick      | Biology    | 72000.00  |
    | 77987 | Kim        | Physics    | 98000.00  |
    | 83821 | Brandt     | Comp. Sci. | 92000.00  |
    | 88877 | Perry      | Finance    | 125000.00 |
    | 88878 | Perry      | Finance    | 125000.00 |
    | 98345 | Kim        | Elec. Eng. | 80000.00  |
    +-------+------------+------------+-----------+
    17 rows in set (0.04 sec)
    

    使用JDBC执行上述的查询语句,将结果集中的查询结果以表格的形式打印出来。

    思路

    • 通过结果集的元数据可以知道结果集中的列数,和列名.
    • 然后遍历结果集,分别统计每一列中的最大字符数。
    • 然后通过System.out.printf()方法进行格式化输出。

    实现

    package tools;
    
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /**
     * 结果集打印机.将结果集中的数据打印成表格.
     */
    public class ResultSetPrinter {
        public static void printResultSet(ResultSet rs) throws SQLException {
            ResultSetMetaData resultSetMetaData = rs.getMetaData();
            // 获取列数
            int ColumnCount = resultSetMetaData.getColumnCount();
            // 保存当前列最大长度的数组
            int[] columnMaxLengths = new int[ColumnCount];
            // 缓存结果集,结果集可能有序,所以用ArrayList保存变得打乱顺序.
            ArrayList<String[]> results = new ArrayList<>();
            // 按行遍历
            while (rs.next()) {
                // 保存当前行所有列
                String[] columnStr = new String[ColumnCount];
                // 获取属性值.
                for (int i = 0; i < ColumnCount; i++) {
                    // 获取一列
                    columnStr[i] = rs.getString(i + 1);
                    // 计算当前列的最大长度
                    columnMaxLengths[i] = Math.max(columnMaxLengths[i], (columnStr[i] == null) ? 0 : columnStr[i].length());
                }
                // 缓存这一行.
                results.add(columnStr);
            }
            printSeparator(columnMaxLengths);
            printColumnName(resultSetMetaData, columnMaxLengths);
            printSeparator(columnMaxLengths);
            // 遍历集合输出结果
            Iterator<String[]> iterator = results.iterator();
            String[] columnStr;
            while (iterator.hasNext()) {
                columnStr = iterator.next();
                for (int i = 0; i < ColumnCount; i++) {
                    // System.out.printf("|%" + (columnMaxLengths[i] + 1) + "s", columnStr[i]);
                    System.out.printf("|%" + columnMaxLengths[i] + "s", columnStr[i]);
                }
                System.out.println("|");
            }
            printSeparator(columnMaxLengths);
        }
    
        /**
         * 输出列名.
         *
         * @param resultSetMetaData 结果集的元数据对象.
         * @param columnMaxLengths  每一列最大长度的字符串的长度.
         * @throws SQLException
         */
        private static void printColumnName(ResultSetMetaData resultSetMetaData, int[] columnMaxLengths) throws SQLException {
            int columnCount = resultSetMetaData.getColumnCount();
            for (int i = 0; i < columnCount; i++) {
                // System.out.printf("|%" + (columnMaxLengths[i] + 1) + "s", resultSetMetaData.getColumnName(i + 1));
                System.out.printf("|%" + columnMaxLengths[i] + "s", resultSetMetaData.getColumnName(i + 1));
            }
            System.out.println("|");
        }
    
        /**
         * 输出分隔符.
         *
         * @param columnMaxLengths 保存结果集中每一列的最长的字符串的长度.
         */
        private static void printSeparator(int[] columnMaxLengths) {
            for (int i = 0; i < columnMaxLengths.length; i++) {
                System.out.print("+");
                // for (int j = 0; j < columnMaxLengths[i] + 1; j++) {
                for (int j = 0; j < columnMaxLengths[i]; j++) {
                    System.out.print("-");
                }
            }
            System.out.println("+");
        }
    
    }
    
    

    测试

    package tools;
    import java.sql.*;
    
    public class Test {
        private static String driver = "com.mysql.cj.jdbc.Driver";
        private static String URL = "jdbc:mysql://127.0.0.1:3306/university?serverTimezone=UTC";
        private static String user = "root";
        private static String password = "root";
    
        /**
         * JDBC测试.
         */
        private static void JDBCexample() {
            // 1.加载数据库驱动
            try {
    
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            testStatement();
        }
    
        /**
         * 测试Statement的用法.
         */
        private static void testStatement() {
            try (// 2.打开数据库连接
                 Connection conn = DriverManager.getConnection(URL, user, password);
                 // 3.创建语句
                 Statement stmt = conn.createStatement()) {
                // 模拟SQL注入
                testSqlInjecton(stmt);
    
            } catch (SQLException sqle) {
                System.out.println("SQLException : " + sqle);
            }
        }
    
        /**
         * 模拟SQL注入.
         *
         * @param stmt Statement对象.
         * @throws SQLException
         */
        private static void testSqlInjecton(Statement stmt) throws SQLException {
            String name = "X' or 'Y' = 'Y";
            String sql = "select * from instructor where name = '" + name + "'";
            ResultSet rs = stmt.executeQuery(sql);
            ResultSetPrinter.printResultSet(rs);
        }
    
        public static void main(String[] args) {
            JDBCexample();
        }
    }
    

    运行结果

    +-----+----------+----------+---------+
    |   ID|      name| dept_name|   salary|
    +-----+----------+----------+---------+
    |10101|Srinivasan|Comp. Sci.| 65000.00|
    |12121|        Wu|   Finance| 90000.00|
    |15151|    Mozart|     Music| 40000.00|
    |22222|  Einstein|   Physics| 95000.00|
    |25566|     Brown|   Biology|100000.00|
    |30765|     Green|     Music|     null|
    |32343|   El Said|   History| 60000.00|
    |33456|      Gold|   Physics| 87000.00|
    |45565|      Katz|Comp. Sci.| 75000.00|
    |58583| Califieri|   History| 62000.00|
    |76543|     Singh|   Finance| 80000.00|
    |76766|     Crick|   Biology| 72000.00|
    |77987|       Kim|   Physics| 98000.00|
    |83821|    Brandt|Comp. Sci.| 92000.00|
    |88877|     Perry|   Finance|125000.00|
    |88878|     Perry|   Finance|125000.00|
    |98345|       Kim|Elec. Eng.| 80000.00|
    +-----+----------+----------+---------+
    

    原文链接: java打印表格 将ResultSet中的数据打印成表格

    展开全文
  • java实现控制台打印表格

    千次阅读 2020-11-12 17:20:30
    背景 ...在实现该功能的过程中,对我来说最麻烦的是要在控制台输出表格,难点在于表格列宽相等以及表格内容要居中对齐。 效果 最终实现效果如下: 核心代码分享 分享此内容的目的有二: 为要实现

    背景

    判断给定数据库是否可以连接,习惯做法是安装一个客户端,输入连接信息后连接测试。但是客户现场通常只提供一个linux系统,没有相关客户端。因此,需要一个能在linux上运行的数据库连接测试工具。我的实现思路:使用jdbc连接目标服务器,并执行一条给定的sql语句,能够连接成功则在控制台输出执行结果,连接失败则打印异常信息。
    在实现该功能的过程中,对我来说最麻烦的是要在控制台输出表格,难点在于控制表格列宽相等(涉及中英文长度不一致)以及表格内容要居中对齐

    效果

    最终实现效果如下:
    在这里插入图片描述

    核心代码分享

    分享此内容的目的有二:

    1. 为要实现同样功能的童鞋提供参考
    2. 请大佬们从实现思路或者具体方法上指点一下是否有更佳实现方式

    主要写了一个PrintTable类:
    在这里插入图片描述

    定义了一个Table内部类,实现以下方法:

    1. buildTable(List<List< String>> content): 传入二维list,构建表格
    2. getLimitTable():限制宽度,最大条数后的表格
    3. getMaxWidthLenList(Table table):得到表格的每列最大宽度,用于实现列宽相等
    4. getFormatTable(Table table, String symbol):根据指定分隔符得到最终格式化后的表格
    5. printTable(String… symbols):打印表格,指定分隔符

    PrintTable:

    package com.sw.utils;
    
    import lombok.Data;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.stream.Collectors;
    
    @Data
    public class PrintTable {
    
        private Table table;
        //最大列宽:sql查询结果某列内容可能过大,不想完全显示,因此限制最大列宽
        private Integer maxWidth;
        //最大条数:sql查询结果可能有非常多,通常不必完全显示,因此限制最大条数
        private Integer maxLength;
    
        public PrintTable(List<List<String>> content, Integer maxWidth, Integer maxLength) {
            this.table = buildTable(content);
            this.maxLength = maxLength;
            this.maxWidth = maxWidth;
        }
    
    
        public PrintTable(List<List<String>> content) {
            this.table = buildTable(content);
            this.maxLength = 10;
            this.maxWidth = 40;
        }
    
        /**
         * 创建Table实例
         *
         * @param content
         * @return
         */
    
        private Table buildTable(List<List<String>> content) {
            return new Table(content);
        }
    
        /**
         * 打印表格
         */
        public void printTable(String... symbols) {
            String symbol = symbols.length == 0 ? "|" : symbols[0];
            //按照最大列宽、最大数据量过滤后的表格
            Table limitTable = getLimitTable();
            //设置表格的最大宽度:得到每列宽度,再求和
            List<Integer> originMaxWidthList = getMaxWidthLenList(limitTable);
            limitTable.setMaxWidthList(originMaxWidthList);
    
            //得到格式化后的表格数据
            Table formatTable = getFormatTable(limitTable, symbol);
            Integer totalColSize = formatTable.getTotalColSize();
            //打印首行分割符号
            System.out.println(StringUtils.getRepeatChar("-", totalColSize));
            formatTable.getContent()
                    .forEach(row -> {
                        row.forEach(System.out::print);
                        System.out.println();
                        //打印每行分割符号
                        System.out.println(StringUtils.getRepeatChar("-", totalColSize));
                    });
        }
    
    
        /**
         * 格式化表格
         *
         * @param symbol 定义每列间隔符号
         * @return
         */
        private Table getFormatTable(Table table, String symbol) {
            //获取原表每列最大宽度
            List<Integer> originMaxWidthList = table.getMaxWidthList();
            //除了间隔符号外,固定在每个单元格前后加两个空格
            int symbolLen = symbol.length() + 2;
            //遍历原table,将每个单元格填充到该列最大长度
            List<List<String>> formatList = table.getContent().stream().map(
                    row -> {
                        //用于流在遍历每行的过程中,获取列序号
                        AtomicInteger atomicInteger = new AtomicInteger(0);
                        return row.stream().map(cell -> {
                            //当前遍历的列序号
                            int j = atomicInteger.getAndIncrement();
                            //原表该列的最大宽度+间隔符号宽度-双字节出现的次数
                            int cellSize = originMaxWidthList.get(j) + symbolLen - StringUtils.getZHCharCount(cell);
                            //如果是首行,还需要再前面加一个分割符号|,故长度加1
                            cellSize = j == 0 ? cellSize + 1 : cellSize;
                            //返回原始字符串按照指定symbol填充到指定长度cellSize,并居中对齐的字符
                            return StringUtils.getPadString(cell, cellSize, symbol, j);
                        }).collect(Collectors.toList());
                    }
            ).collect(Collectors.toList());
            //存储格式化后的表格数据
            Table formatTable = buildTable(formatList);
            //设置格式化表格的总宽度:原始宽度+自定义分割符号的总宽度(列数*符号宽度)+首列前面的符号宽度
            int totalColSize = table.getTotalColSize() + table.getColCount() * symbolLen + 1;
            formatTable.setTotalColSize(totalColSize);
            return formatTable;
        }
    
     	/**
         * @return 获取经过条件过滤的表格
         */
        private Table getLimitTable() {
            List<List<String>> limitContent = table.getContent().stream()
                    .limit(maxLength)
                    .map(row -> row.stream()
                    	//去除内容中含制表符时对结果展示的影响
                            .map(cell -> cell == null ? null : cell.replaceAll("\t", " "))
                            .map(cell -> cell != null && cell.length() > maxWidth ? cell.substring(0, maxWidth) : cell)
                            .collect(Collectors.toList())
                    ).collect(Collectors.toList());
            return buildTable(limitContent);
        }
    
        /**
         * 计算table每行的最大宽度
         * 要使列宽相等,就需要将每个单元格宽度设置为该列最大宽度,二计算每行最大宽度相对容易些
         * 故将content转置后得到的每行最大宽度即为所求
         * 需要考虑单双字节的情况,比如有数组arr:{"aabb","sql表格","编程学习"},
         * 按照String.length计算,arr[1]最长,但是实际上arr[2]看起来才是最宽的
         * 因此计算宽度时,将双字节字符看做2个单位长度,即:每出现一个双字节字符,长度+1
         *
         * @return
         */
        private List<Integer> getMaxWidthLenList(Table table) {
            //得到转置数组每个元素的长度,一个中文算两个长度
            return Arrays.stream(table.transpose())
                    .map(rows -> Arrays.stream(rows)
                            .mapToInt(s -> {
                                //sql查询结果如果为null,则认为长度为4
                                if (s == null) {
                                    return 4;
                                } else {
                                    //加上双字节字符出现的次数,最短为null,四个字符
                                    return s.length() + StringUtils.getZHCharCount(s);
                                }
                            }).max().orElse(0)
                    ).collect(Collectors.toList());
        }
    
        @Data
        private class Table {
            /**
             * 表格内容(含表头)
             */
            private List<List<String>> content = new ArrayList<>();
    
            /**
             * 表格列总字符长度:便于打印行分割符号
             */
            private Integer totalColSize;
            /**
             * 每列最大宽度
             */
            private List<Integer> maxWidthList;
    
    
            Integer getTotalColSize() {
                if (totalColSize == null && maxWidthList != null && maxWidthList.size() != 0) {
                    this.totalColSize = maxWidthList.stream().reduce(Integer::sum).get();
                }
                return totalColSize;
            }
    
            //private限制只能通过外部类构造
            private Table(List<List<String>> content) {
                this.content = content;
            }
    
            //获取表格行数
            int getRowCount() {
                return content.size();
            }
    
            //获取表格列数,0行代表表头,默认认为content中至少含有表头
            int getColCount() {
                return content.get(0).size();
            }
    
            /**
             * 转置二维数组
             *
             * @return
             */
            private String[][] transpose() {
                int rowCount = getRowCount();
                int colCount = getColCount();
                String[][] result = new String[colCount][rowCount];
    
                for (int i = 0; i < rowCount; i++) {
                    for (int j = 0; j < colCount; j++) {
                        result[j][i] = content.get(i).get(j);
                    }
                }
                return result;
            }
        }
    
    }
    
    

    用到的工具类:StringUtils

    package com.sw.utils;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import java.util.stream.IntStream;
    
    public class StringUtils {
    
        /**
         * 判断字符串是否为空
         *
         * @param str
         * @return
         */
        public static boolean isEmpty(String str) {
            return str == null || "".equals(str);
        }
    
        /**
         * 将content按照正则匹配,返回可以匹配的字符串列表
         *
         * @param reg
         * @param content
         * @return
         */
        public static List<String> extractMessage(String reg, String content) {
            Pattern compile = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);
            Matcher matcher = compile.matcher(content);
            List<String> list = new ArrayList<>();
            while (matcher.find()) {
                list.add(matcher.group());
            }
            return list;
        }
    
    
        /**
         * 将str重复count次,返回结果
         *
         * @param str
         * @param count
         * @return
         */
        public static String getRepeatChar(String str, int count) {
            StringBuilder res = new StringBuilder();
            IntStream.range(0, count).forEach(i -> res.append(str));
            return res.toString();
        }
    
        /**
         * 将字符串填充到指定长度并居中对齐
         *
         * @param str
         * @param len
         * @return
         */
        public static String getPadString(String str, Integer len) {
            StringBuilder res = new StringBuilder();
            str = str.trim();
            if (str.length() < len) {
                int diff = len - str.length();
                int fixLen = diff / 2;
                String fix = getRepeatChar(" ", fixLen);
                res.append(fix).append(str).append(fix);
                if (res.length() > len) {
                    return res.substring(0, len);
                } else {
                    res.append(getRepeatChar(" ", len - res.length()));
                    return res.toString();
                }
            }
            return str.substring(0, len);
        }
    
        /**
         * 此方法主要为表格的单元格数据按照指定长度填充并居中对齐并带上分割符号
         *
         * @param str    原始字符串
         * @param len    输出字符串的总长度
         * @param symbol 分割符号
         * @param index  传入的cell在list的索引,如果为第一个则需要在前面增加分割符号
         * @return
         */
        public static String getPadString(String str, Integer len, String symbol, int index) {
            String origin = str + "  ";
            if (index == 0) {
                String tmp = getPadString(origin, len - 2);
                return symbol + tmp + symbol;
            } else {
    
                String tmp = getPadString(origin, len - 1);
                return tmp + symbol;
            }
        }
    
        /**
         * 得到一个字符串中单字节出现的次数
         *
         * @param cell
         * @return
         */
        public static Integer getENCharCount(String cell) {
            if (cell == null) {
                return 0;
            }
            String reg = "[^\t\\x00-\\xff]";
    //        String reg = "|[^\t\\x00-\\xff]";
            return cell.replaceAll(reg, "").length();
        }
    
        /**
         * 得到制表符长度,每个\t显示四个长度
         *
         * @param cell
         * @return
         */
        public static Integer getTableCount(String cell) {
            if (cell == null) {
                return 0;
            }
            String reg = "\t";
    //        String reg = "|[^\t\\x00-\\xff]";
            return cell.length() - cell.replaceAll(reg, "").length();
        }
    
        /**
         * 得到一个字符串中双字节出现的次数
         *
         * @param cell
         * @return
         */
        public static Integer getZHCharCount(String cell) {
            if (cell == null) {
                return 0;
            }
            return cell.length() - getENCharCount(cell);
        }
    
        public static void main(String[] args) {
            String test = "ab\t哈哈嘻嘻";
            String reg = "[^\t\\x00-\\xff]";
            System.out.println(test.replaceAll(reg, "").length());
            test.replaceAll("\t|[^\\x00-\\xff]", "");
            System.out.println(test.length());
            System.out.println(StringUtils.getZHCharCount(test));
            System.out.println(StringUtils.getENCharCount(test));
        }
    }
    
    

    调用方法:
    将sql得到的rsultSet封装成二维list,再调用PrintTable即可完成控制台打印
    在这里插入图片描述

    展开全文
  • 首先查看Formatted Strings。 String.format和printf共享相同的格式规则 所以,像... System.out.printf("%15s", "Name:");... 总之,这将打印出... Name: Age: Gender: Bob 18 Male Mary 25 Female
  • 先把表格画在Jpanel上,实现在JPanel可调整表格左右,上下移动,然后实现打印类的一个方法,利用Graphics在这个方法画出表格,调用这个打印打印表格
  • java打印Excel表格

    千次阅读 2018-03-26 11:14:46
    这里用servlet简单介绍一下java打印报表 1.无合并行/列 package weaver.xhyy.servlet; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; ...
  • Java Console/控制台 打印表格

    万次阅读 2018-01-07 19:24:58
    功能:控制台打印表格,支持字段动态长度,左对齐,右对齐,居中,设置最大列长,设置列间隔符,设置最多打印多少行。类下载地址:http://download.csdn.net/download/j506825719/10211082简单使用方法:在new的时候,...
  • java打印html

    2017-10-16 15:39:21
    Java API实现HTML(HTML5)打印服务(事先设置好window默认打印机)
  • //是一个表格模型 JScrollPane jsp=null; JPanel jp1=null; try { if(e1.getActionCommand()=="查看学生信息") { ps=ct.createStatement(); rs=ps.executeQuery("select * from Student ");...
  • Java打印Excel表格

    热门讨论 2010-03-24 11:10:00
    打印Excel表格一直是Java技术中难解的问题,在这里我写了一个打印Excel表格的实例,比较实用。与大家共享一下,有什么不对的地方还希望各位多多指教
  • //遍历数据,往Excel表格写数据 while (ite.hasNext()) { Map.Entry entry1 = ite.next(); entry1.getKey(); String val = Tools.filterNull(entry1.getValue()); Cell cell = row.createCell(j++); cell....
  • 主要介绍了JAVA实现打印ascii码表代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java swing表格JTable

    2014-08-20 07:21:59
    JTabel的一些方法,表格的设置,按钮的添加,界面的布局,只是一些简单的小玩意
  • 在报表软件和报表工具领域,报表套打是最为常见的一个用户需求,例如发票、支票、信封、对账单、保单以及各类证件表格打印都需要根据既定的表格样式快速批量打印出结果。报表套打功能也是各种报表工具必备的功能之...
  • Java开发斑马打印机打印标签,支持中文打印,导入即可运行
  • java表格输出

    2021-03-11 08:06:31
    以空格或多个制表符调节文本位置以达到表格效果 public class Str { public static void main(String[] args) { println(); } private static void println() { //表头 System.out.println("星期一\t星期二\t...
  • 后台java代码连接数据库后根据格式生成excel表格并返回给前台界面下载。eclipse+maven+springmvc+springjdbc
  • 使用java代码基于Eclipse开发环境实现爬虫抓取网页中的表格数据,将抓取到的数据在控制台打印出来,需要后续处理的话可以在打印的地方对数据进行操作。包解压后导入Eclipse就可以使用,在TestCrawTable中右键运行就...
  • 在调试java调试程序时,将log以表格形式输出到控制台,察看起来更加直观。 j-text-utils为我们提供了这样的功能。j-text-utils依赖于commons-lang,使用时注意导入。 使用方式: TextTable tt = new TextTable...
  • Java实现Web报表打印功能.

    热门讨论 2007-05-30 17:04:27
    Java实现Web报表打印功能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,938
精华内容 18,775
关键字:

java打印表格

java 订阅
友情链接: tdbundle.rar