import com.itextpdf.html2pdf.ConverterProperties;
import com.itextpdf.html2pdf.HtmlConverter;
import com.itextpdf.layout.font.FontProvider;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Html2Pdf {
    public static void main(String[] args) throws IOException {
        File htmlSrc = new File("/Users/Biao/Desktop/x.html");
        File pdfDest = new File("/Users/Biao/Desktop/x.pdf");

        // 使用中文字体解决不显示中文问题: 字体文件可以从系统中找，也可以从网上下载
        FontProvider fontProvider = new FontProvider();
        fontProvider.addStandardPdfFonts();
        fontProvider.addFont("/Users/Biao/Desktop/Yahei.ttf");
        // fontProvider.addDirectory("..."); // 添加文件夹下的所有字体

        ConverterProperties converterProperties = new ConverterProperties();
        converterProperties.setCharset("UTF-8");
        converterProperties.setFontProvider(fontProvider);

        // HTML 中本地图片要使用 file:// 的格式，如 file:///Users/Biao/Desktop/shot.png
        HtmlConverter.convertToPdf(htmlSrc, pdfDest, converterProperties);
    }
}

// 核心: Floyd 算法计算任意 2 点之间的最短距离
final int len = distance.length;
for (int v = 0; v < len; v++) {         // 第一层: 中间点
    for (int i = 0; i < len; i++) {     // 第二层: 出发点
        for (int j = 0; j < len; j++) { // 第三层: 终结点
            if (distance[i][v] + distance[v][j] < distance[i][j]) {
                distance[i][j] = distance[i][v] + distance[v][j];
                path[i][j] = path[v][j];
            }
        }
    }
}

package graph;

import com.alibaba.fastjson.JSON;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.StringUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 图
 */
@Getter
@Setter
@Accessors(chain = true)
public class Graph {
    Map<String, List<Edge>> adjacentList = new HashMap<>(); // 邻接表存储图: key 为顶点，Edge 为此顶点和临接点构成的边

    /**
     * 获取图的顶点
     *
     * @return 返回顶点的集合
     */
    public Set<String> getVertices() {
        return adjacentList.keySet();
    }

    /**
     * 获取图的边，无向图中 2 条相同的边只输出一条
     *
     * @return 返回边的集合
     */
    public Set<Edge> getEdges() {
        return adjacentList.values().stream().flatMap(List::stream).collect(Collectors.toSet());
    }

    /**
     * 获取传入的顶点的所有边
     *
     * @param vertex 顶点
     * @return 返回边的数组
     */
    public List<Edge> getVertexEdges(String vertex) {
        return adjacentList.get(vertex);
    }

    /**
     * 使用图的边构建图，边的格式为 start-end:weight，边之间使用逗号分隔，例如 A-B:10,A-G:5
     *
     * @param edges 图的所有边
     * @return 返回图的对象
     */
    public static Graph build(String edges) {
        Graph graph = new Graph();

        for (String edgeContent : StringUtils.split(edges, ",")) {
            // 边: A-B:10
            int indexOfDash  = edgeContent.indexOf("-");
            int indexOfColon = edgeContent.indexOf(":");
            String vertex1   = edgeContent.substring(0, indexOfDash);
            String vertex2   = edgeContent.substring(indexOfDash+1, indexOfColon);
            double weight    = Double.parseDouble(edgeContent.substring(indexOfColon+1));

            // 找到顶点 vertex1 的边集，添加它的边
            graph.adjacentList.putIfAbsent(vertex1, new LinkedList<>());
            graph.adjacentList.get(vertex1).add(new Edge(vertex1, vertex2, weight));

            // 找到顶点 vertex2 的边集，添加它的边
            graph.adjacentList.putIfAbsent(vertex2, new LinkedList<>());
            graph.adjacentList.get(vertex2).add(new Edge(vertex2, vertex1, weight));
        }

        return graph;
    }

    /**
     * 图的边，由起点、终点和权重构成
     */
    @Getter
    @Setter
    @Accessors(chain = true)
    public static class Edge {
        String start;  // 边的起点
        String end;    // 边的终点
        double weight; // 边的权重

        public Edge(String start, String end, double weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;
        }

        /**
         * 2 个顶点相同的边则为同一条边
         */
        @Override
        public boolean equals(Object obj) {
            if (obj.getClass() != getClass()) {
                return false;
            }

            Edge other = (Edge) obj;

            if (this.start.equals(other.start) && this.end.equals(other.end)) {
                return true;
            }

            if (this.start.equals(other.end) && this.end.equals(other.start)) {
                return true;
            }

            return false;
        }

        @Override
        public int hashCode() {
            // start, end 从小到大排序
            if (start.compareTo(end) < 0) {
                return Objects.hash(start, end);
            } else {
                return Objects.hash(end, start);
            }
        }
    }

    public static void main(String[] args) {
        Graph graph = Graph.build("A-B:16,B-C:10,C-D:3,D-E:4,E-F:8,F-A:14,B-G:7,C-G:6,E-G:2,F-G:9,A-G:12,C-E:5");
        System.out.println(JSON.toJSONString(graph.getAdjacentList()));
        System.out.println(graph.getVertices());
        System.out.println(JSON.toJSONString(graph.getEdges()));
        System.out.println(JSON.toJSONString(graph.getVertexEdges("A"), true));
    }
}

BTPrinter.printTree("1,2,3,4,5,#,#,6,7,8,1,#,#,#,#,#,#,2,3,4,5,6,7,8,9,10,11,12,13,14,15");