Jsoup--HTML网页内容解析工具
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
- 1.Jsoup 介绍
-
- 1.1 Jsoup概述
- 1.2 快速入门案例
-
- 1.2.1 准备工作
- 1.2.1 入门案例
- 1.3 Jsoup中常用的类库
- 2.Jsoup类
- 3.Document类
- 4.选择器
- 5.Element类
- 6.综合案例
-
- 6.1 案例描述
- 6.2 开发准备
- 6.3代码演示
1.Jsoup 介绍
1.1 Jsoup概述
Java 程序在解析 HTML 文档时，相信你们都接触过 htmlparser 这个开源项目，但如今我已经再也不使用 htmlparser 了，缘由是 htmlparser 不多更新，但最重要的是有了 jsoup 。JSoup是一个用于处理HTML的Java库，它提供了一个非常方便类似于使用DOM，CSS和jquery的方法的API来提取和操作数据。
jsoup实现WHATWG HTML5规范，并将HTML解析为与现代浏览器相同的DOM。
-
从一个URL，文件或字符串中解析HTML；
-
使用DOM或CSS选择器来查找、取出数据；
-
可操作HTML元素、属性、文本；
-
jsoup是基于MIT协议发布的，可放心使用于商业项目。
jsoup旨在处理发现所有格式有差异的HTML; 从原始和验证，到无效的标签; jsoup将创建一个明智的解析树。
1.2 快速入门案例
1.2.1 准备工作
准备一个test.html文件
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Documenttitle>
<style>
h1 , h5{
text-align: center;
}
div {
text-align: center;
}
style>
head>
<body>
<h1><p id="p1">《青溪》p>h1>
<h5><p id="p2">作者：王维p>h5>
<div>
<p class="p3">言入黄花川，每逐青溪水。p>
<p class="p3"> 随山将万转，趣途无百里。p>
<p class="p3"> 声喧乱石中，色静深松里。p>
<p class="p3"> 漾漾泛菱荇，澄澄映葭苇。p>
<p class="p3"> 我心素已闲，清川澹如此。p>
<p class="p3"> 请留盘石上，垂钓将已矣。p>
div>
body>
html>
1.2.1 入门案例
案例描述 : 将上述test.html文件进行解析，把每一个p标签的内容放入集合元素中，并输出到控制台。
开发步骤
- 加载test.html文件 ------>File
- 解析html文件，并生成Document对象 ------>Document
- 查找到p标签，返回p标签的元素节点元素集。 -------->Elements
- 遍历遍历p标签节点元素集，获取每个p标签节点 -------->Element
- 获取p标签的内容 ----->String
- 将内容放入集合中 ------
List
public static void main(String[] args) throws IOException {
// 1. 加载test.html文件 ------>File
File file = new File("src\\com\\chao\\test\\test.html");
// 2. 解析html文件，并生成Document对象 ------>Document
Document document = Jsoup.parse(file);
// 3. 查找到p标签，返回p标签的元素节点元素集。 -------->Elements
Elements elements = document.select("p");
// 4. 遍历遍历p标签节点元素集，获取每个p标签节点 -------->Element
ArrayList<String> list = new ArrayList<>();
for (Element element : elements) {
// 5. 获取p标签的内容 ----->String
String text = element.text();
// 6. 将内容放入集合中 ------`List`
list.add(text);
}
System.out.println("list = " + list);
}
1.3 Jsoup中常用的类库
虽然完整的类库中有很多类，但大多数情况下，下面给出3个类是我们需要重点了解的。
-
org.jsoup.Jsoup类 : Jsoup类是任何Jsoup程序的入口点，并将提供从各种来源加载和解析HTML文档的方法。
-
org.jsoup.nodes.Document类 : 该类表示通过Jsoup库加载HTML文档。可以使用此类执行适用于整个HTML文档的操作。
-
org.jsoup.nodes.Element类 : HTML元素是由标签名称，属性和子节点组成。 使用Element类，您可以提取数据，遍历节点和操作HTML。
2.Jsoup类
soup类是任何Jsoup程序的入口点，并将提供从各种来源加载和解析HTML文档的方法。它的核心功能就是将一个HTML文件进行解析，在程序中生成一个Document对象。然后通过对Document对象对标签进行操作。那么我们来卡看看他的常用方法吧。
常用的方法
| 权限修饰符 | 返回值类型 | 方法名 | 描述 |
|---|---|---|---|
| static | Connection | connect(String url) | 使用定义的请求URL创建一个新的Connection(会话)。创建并返回URL的连接 |
| static | Document | parse(File file) | 将文件解析成HTML文档Document |
| static | Document | parse(File file ,String charsetName) | 将指定的字符集文件继续成HTML文档 |
| static | Document | parse(InputStream in, String charsetName, String baseUri) | 读入一个文件，将其解析成HTML文档Document |
| static | Document | parse(String html) | 将文件解析成HTML文档Document |
| static | Document | parse(URL url, int timeoutMillis) | 获取一个URL，并将其解析为HTML。 |
代码演示
public static void main(String[] args) throws IOException {
File file = new File("src\\com\\chao\\test\\test.html");
Document document = Jsoup.parse(file);
System.out.println("document = " + document);
System.out.println("----------------------------");
Document document2 = Jsoup.parse("1334
");
System.out.println("document2 = " + document2);
}
3.Document类
将HTML解析成一个Document之后，就可以使用类似于DOM的方法进行操作。Document类表示通过Jsoup库加载HTML文档。可以使用此类执行适用于整个HTML文档的操作。
Document方法:(常用的加粗)
| 返回值类型 | 方法名 | 描述 |
|---|---|---|
| Element | body() | 获取此文档的 |
| Charset | charset() | 返回此文档中使用的字符集。 |
| void | charset(Charset charset) | 设置此文档中使用的字符集。 |
| Document | clone() | 创建此节点及其所有子节点的独立深层副本。 |
| Connection | connection() | 创建此节点及其所有子节点的独立深层副本。 |
| Document | connection(Connection connection) | 设置用于获取此文档的连接。 |
| Element | createElement(String tagName) | 使用此文档的基本 uri 创建一个新元素。 |
| static Document | createShell(String baseUri) | 创建一个有效的、空的文档外壳，适合添加更多元素。 |
| DocumentType | documentType() | 返回此文档的文档类型 |
| Element | head() | 获取此文档的head元素。 |
| String | location() | 获取解析此文档的 URL。 |
| String | nodeName() | 获取此节点的节点名称。 |
| Document | normalise() | 规范化文档。 |
| String | outerHtml() | 获取此节点的外部 HTML。 |
| Document.OutputSettings | outputSettings() | 获取文档的当前输出设置。 |
| Document | outputSettings(Document.OutputSettings outputSettings) | 设置文档的输出设置。 |
| Parser | parser() | 获取用于解析此文档的解析器。 |
| Document | parser(Parser parser) | 设置用于创建此文档的解析器。 |
| Document.QuirksMode | quirksMode() | |
| Document | quirksMode(Document.QuirksMode quirksMode) | |
| Document | shallowClone() | 创建此节点的独立浅表副本。 |
| Element | text(String text) | 设置body此文档的文本。 |
| String | title() | 获取文档title元素的字符串内容。 |
| void | title(String title) | 获取文档title元素的字符串内容。 |
| boolean | updateMetaCharsetElement() | 返回此文档中具有字符集信息的元素是否在更改时更新 |
| void | updateMetaCharsetElement(boolean update) | 设置此文档中具有字符集信息的元素是否在更改时更新 |
代码演示
public static void main(String[] args) throws IOException {
File file = new File("src\\com\\chao\\test\\test.html");
Document document = Jsoup.parse(file);
// 1.获取body
Element body = document.body();
System.out.println("body = " + body);
// 2.获取title
String title = document.title();
System.out.println("title = " + title);
// 3.获取head头
Element head = document.head();
System.out.println("head = " + head);
// 4.获取子节点
String s = document.nodeName();
System.out.println("s = " + s);
// 5.获取字符集
Charset charset = document.charset();
System.out.println("charset = " + charset);
}
4.选择器
Jsoup elements对象支持类似于CSS (或jquery)的选择器语法，来实现非常强大和灵活的查找功能。
这个select 方法在Document, Element,或Elements对象中都可以使用。且是上下文相关的，因此可实现指定元素的过滤，或者链式选择访问。
查找元素的方式
| 查找方式 | 描述 |
|---|---|
| getElementById(String id) | 根据id查找节点 |
| getElementsByTag(String tag) | 根据标签查找节点 |
| getElementsByClass(String className) | 根据class属性查找节点 |
| getElementsByAttribute(String key) (and related methods) | 根据属性名称查找节点 |
| parent() | 查找父元素 |
| children(), child(int index) | 查找子元素 |
| select(String cssQuery) | Select方法将返回一个Elements集合，并提供一组方法来抽取和处理结果。与jQuery语法相似 |
代码演示
public static void main(String[] args) throws IOException {
File file = new File("src\\com\\chao\\test\\test.html");
Document document = Jsoup.parse(file);
Element p1 = document.getElementById("p1");
System.out.println("p1 = " + p1);
System.out.println("========================================");
Elements p3 = document.getElementsByClass("p3");
System.out.println("p3 = " + p3);
System.out.println("========================================");
Elements p = document.getElementsByAttribute("p");
System.out.println("p = " + p);
System.out.println("========================================");
Elements p2 = document.getElementsByTag("p");
System.out.println("p2 = " + p2);
System.out.println("========================================");
Elements select = document.select(".p1");
System.out.println("select = " + select);
System.out.println("========================================");
Elements p4 = document.select("p");
System.out.println("p4 = " + p4);
System.out.println("========================================");
Elements select1 = document.select("#p1");
System.out.println("select1 = " + select1);
System.out.println("========================================");
}
5.Element类
HTML元素是由标签名称，属性和子节点组成。 使用Element类，您可以提取数据，遍历节点和操作HTML。
Element的方法
Element addClass(String className) 向该元素的class属性添加类名。
Element after(String html) 在此元素之后将指定的 HTML 插入 DOM（作为后续兄弟）。
Element after(Node node) 在此节点之后将指定节点插入到 DOM 中（作为后续兄弟节点）。
Element append(String html) 将内部 HTML 添加到此元素。
Element appendChild(Node child) 在此元素的子元素的末尾插入一个节点。
Element appendChildren(Collection<? extendsNode> children)将给定节点插入到此元素的子元素的末尾。
Element appendElement(String tagName) 按标签名称创建一个新元素，并将其添加为最后一个子元素。
Element appendText(String text) 创建一个新的 TextNode 并将其附加到此元素。
Element appendTo(Element parent) 将此元素添加到提供的父元素中，作为其下一个子元素。
Element attr(String attributeKey,boolean attributeValue) 在此元素上设置一个布尔属性值。
Element attr(String attributeKey,String attributeValue) 设置此元素的属性值。
Attributes attributes() 获取元素的所有属性。
String baseUri() 获取适用于此节点的基本 URI。
Element before(String html) 在此元素之前将指定的 HTML 插入到 DOM 中（作为前面的兄弟）。
Element before(Node node) 在此节点之前将指定节点插入 DOM（作为前面的兄弟节点）。
Element child(int index) 通过从 0 开始的索引号获取此元素的子元素。
int childNodeSize() 获取该节点拥有的子节点数。
Elements children() 获取此元素的子元素。
int childrenSize() 获取此元素的子节点的数量。
String className() 获取此元素的“类”属性的字面值，其中可能包含多个类名，以空格分隔。
Set<String> classNames() 获取所有元素的类名。
Element classNames(Set<String> classNames) 将元素的class属性设置为提供的类名。
Element clearAttributes() 清除（移除）此节点中的所有属性。
Element clone() 创建此节点及其所有子节点的独立深层副本。
Element closest(String cssQuery) 查找与指定 CSS 查询匹配的父级树上最近的元素。
Element closest(Evaluator evaluator) 查找与指定评估者匹配的父级树上最近的元素。
String cssSelector() 获取将唯一选择此元素的 CSS 选择器。
String data() 获取该元素的组合数据。
List<DataNode> dataNodes() 获取此元素的子数据节点。
Map<String,String> dataset() 获取此元素的 HTML5 自定义数据属性。
protected Element doClone(Node parent)
protected void doSetBaseUri(String baseUri) 如果此节点跟踪基本 URI，则仅为此节点（而不是其后代）设置 baseUri。
int elementSiblingIndex() 获取此元素在其元素兄弟列表中的列表索引。
Element empty() 删除元素的所有子节点。
Range endSourceRange() 获取此元素的结束（结束）标记的源范围（开始和结束位置）。
protected List<Node> ensureChildNodes()
Element expectFirst(String cssQuery) 就像selectFirst(String)，但如果没有匹配，则抛
出IllegalArgumentException.
Element filter(NodeFilter nodeFilter) 通过此节点及其后代执行深度优先过滤。
Element firstElementChild() 获取此元素的第一个子元素（null如果没有元素）。
Element firstElementSibling() 获取此元素的第一个 Element 同级。
Element forEach(Consumer<? super Element> action) 在深度优先遍历期间，对此元素及其每个后代元素执
Element forEachNode(Consumer<? super Node> action) 在深度优先遍历期间，对此节点及其每个后代执行提供的操作。
Elements getAllElements() 查找此元素下的所有元素（包括 self 和 children 的children）。
Element getElementById(String id) 按 ID 查找元素，包括或在此元素下。
Elements getElementsByAttribute(String key) 查找具有命名属性集的元素。
Elements getElementsByAttributeStarting(String keyPrefix)查找属性名称以提供的前缀开头的元素。
Elements getElementsByAttributeValue(String key,String value)查找具有特定值的属性的元素。
Elements getElementsByAttributeValueContaining(String key, String match)查找具有其值包含匹配字符串的属性的元素。
Elements getElementsByAttributeValueEnding(String key, String valueSuffix)查找具有以值后缀结尾的属性的元素。
Elements getElementsByAttributeValueMatching(String key, String regex)查找具有其值与提供的正则表达式匹配的属性的元
素。
Elements getElementsByAttributeValueMatching(String key, Pattern pattern)查找具有其值与提供的正则表达式匹配的属性的元素。
Elements getElementsByAttributeValueNot(String key,String value)查找不具有此属性或具有不同值的元素。
Elements getElementsByAttributeValueStarting(String key String valuePrefix)查找具有以值前缀开头的属性的元素。
Elements getElementsByClass(String className) 查找具有此类的元素，包括或在此元素下。
Elements getElementsByIndexEquals(int index) 查找兄弟索引等于提供的索引的元素。
Elements getElementsByIndexGreaterThan(int index) 查找兄弟索引大于提供的索引的元素。
Elements getElementsByIndexLessThan(int index) 查找同级索引小于提供的索引的元素。
Elements getElementsByTag(String tagName) 查找具有指定标记名称的元素，包括并递归地在此元素下。
Elements getElementsContainingOwnText(String searchText)查找直接包含指定字符串的元素。
Elements getElementsContainingText(String searchText) 查找包含指定字符串的元素。
Elements getElementsMatchingOwnText(String regex) 查找其自身文本与提供的正则表达式匹配的元素。
Elements getElementsMatchingOwnText(Pattern pattern) 查找其自身文本与提供的正则表达式匹配的元素。
Elements getElementsMatchingText(String regex) 查找其文本与提供的正则表达式匹配的元素。
Elements getElementsMatchingText(Pattern pattern) 查找其文本与提供的正则表达式匹配的元素。
protected boolean hasAttributes() 检查此节点是否具有实际的 Attributes 对象。
protected boolean hasChildNodes() 检查是否已创建节点列表对象的内部测试。
boolean hasClass(String className) 测试这个元素是否有一个类。
boolean hasText() 测试此元素是否有任何文本内容（不仅仅是空格）。
String html() 检索元素的内部 HTML。
Element html(String html) 设置此元素的内部 HTML
Element html(String html) 设置此元素的内部 HTML。
<T extends Appendable>T html(T appendable) 将此节点及其子节点写入给定的Appendable.
String id() 获取id此元素的属性。
Element id(String id) 设置id此元素的属性。
Element insertChildren(int index, Collection<?extends Node> children)将给定的子节点插入到此元素中指定索引处。
Element insertChildren(int index, Node... children) 将给定的子节点插入到此元素中指定索引处。
boolean is(String cssQuery) 检查此元素是否与给定的SelectorCSS 查询匹配。
boolean is(Evaluator evaluator) 检查此元素是否与给定的评估者匹配。
boolean isBlock() 测试此元素是否为块级元素。
Element lastElementChild() 获取此元素的最后一个子元素，如果没有元素，则获取 @{code null}。
Element lastElementSibling() 获取此元素的最后一个元素兄弟。
Element nextElementSibling() 获取此元素的下一个同级元素。
Elements nextElementSiblings() 获取该元素之后的每个兄弟元素。
String nodeName() 获取此节点的节点名称。
String normalName() 获取此元素标签的规范化名称。
String ownText() 仅获取此元素拥有的（规范化）文本；没有得到所有孩子的组合文本。
final Element parent() 获取此节点的父节点。
Elements parents() 获取此元素的父元素和祖先元素，直到文档根。
Element prepend(String html) 将内部 HTML 添加到此元素中。
Element prependChild(Node child) 在该元素的子元素的开头添加一个节点。
Element prependChildren(Collection<? extendsNode> children)将给定节点插入此元素的子元素的开头。
Element prependElement(String tagName) 按标签名称创建一个新元素，并将其添加为第一个子元素。
Element prependText(String text) 创建一个新的 TextNode 并将其添加到此元素。
Element previousElementSibling() 获取此元素的前一个元素兄弟。
Elements previousElementSiblings() 获取此元素之前的每个元素兄弟。
Element removeAttr(String attributeKey) 从此节点中删除一个属性。
Element removeClass(String className) 从此元素的class属性中删除一个类名。
Element root() 获取该节点的根节点；也就是它的最高祖先。
Elements select(String cssQuery) 查找与SelectorCSS 查询匹配的元素，并以该元素作为起始上下文。
Elements select(Evaluator evaluator) 查找与提供的 Evaluator 匹配的元素。
Element selectFirst(String cssQuery) 找到与SelectorCSS 查询匹配的第一个元素，并以此元素作为起始上下文。
Element selectFirst(Evaluator evaluator) 查找与提供的 Evaluator 匹配的第一个元素，将此元素作为起始上下文，或者null如果不匹配。
Elements selectXpath(String xpath) 查找与提供的 XPath 表达式匹配的元素。
<T extends Node> List<T> selectXpath(String xpath, Class<T> nodeType) 查找与提供的 XPath 表达式匹配的节点。
Element shallowClone() 创建此节点的独立浅表副本。
Elements siblingElements() 获取兄弟元素。
Tag tag() 获取此元素的标签。
String tagName() 获取此元素的标签名称。
Element tagName(String tagName) 更改（重命名）该元素的标签。
String text() 获取此元素及其所有子元素 的规范化组合文本。
Element text(String text) 设置此元素的文本。
List<TextNode> textNodes() 获取此元素的子文本节点。
Element toggleClass(String className) 在此元素的属性上切换类名class：如果存在，则将其删除；否则添加它。
Element traverse(NodeVisitor nodeVisitor) 通过此节点及其后代执行深度优先遍历。
String val() 获取表单元素（输入、文本区域等）的值。
Element val(String value) 设置表单元素（输入、文本区域等）的值。
String wholeOwnText() 获取此元素的（未编码）文本，不包括任何子元素，包括原始中存在的任何换行符和空格。
代码演示（不会全演示）
public static void main(String[] args) throws IOException {
File file = new File("src\\com\\chao\\test\\test.html");
Document document = Jsoup.parse(file);
Element p1 = document.getElementById("p1");
// 获取标签内容
String text = p1.text();
System.out.println("text = " + text);
// 获取子节点名称
String s = p1.nodeName();
System.out.println("s = " + s);
// 获取标签内容
String html = p1.html();
System.out.println("html = " + html);
// 获取class属性名
String s1 = p1.className();
System.out.println("s1 = " + s1);
// 判断释放有内容
boolean b = p1.hasText();
System.out.println("b = " + b);
// 获取父节点
Element parent = p1.parent();
System.out.println("parent = " + parent);
// 获取根节点
Element root = p1.root();
System.out.println("root = " + root);
}
6.综合案例
6.1 案例描述
从服务器中读取一个类似双色球的网页，将每一期的中奖号码通过Jsoup方式解析出来，将数据存储到List集合中。网页效果如图所示:
运行结果如图所示
6.2 开发准备
1.准备一个类似双色球开奖的网页，效果如上图所示
2.将网页部署到nginx服务器上
3.在浏览器中输入地址测试是否运行成功
6.3代码演示
1.建立RequestUtils工具类
该类的作用时向服务器发送请求，获取网页中的数据。
/**
*该类的作用时向服务器发送请求，获取网页中的数据。
*/
public class RequestUtils {
public static StringBuffer sendRequst(String realUrl){
StringBuffer result = new StringBuffer();
BufferedReader reader = null;
InputStream inputStream =null;
try {
// 1.应用程序与服务器之间的连接通道URL对象
URL url = new URL(realUrl);
// 2.打开应用程序与服务器的连接
URLConnection connection = url.openConnection();
// 3.设置通用的请求属性
connection.setRequestProperty("accept", "*/*");
connection.setRequestProperty("connection", "Keep-Alive");
connection.setRequestProperty("user-agent",
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
// 4.建立实际的连接
connection.connect();
// 5.将服务器中的网页HTML文本读取到应用程序
inputStream = connection.getInputStream();
// 6.创建缓冲字符输入流,提高读取效率
reader = new BufferedReader(new InputStreamReader(inputStream));
// 7.循环读取将数据放入resul中
String line = null;
while ((line = reader.readLine()) != null){
result.append(line);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
// 8.释放资源
if (inputStream != null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
inputStream = null;
}
if (reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
reader = null;
}
}
return result;
}
}
2.创建一个事务描述类Num是存储每一期中奖号码
public class Num {
private Integer issue;
private String lotterydate;
private Integer one;
private Integer two;
private Integer tree;
private Integer four;
private Integer five;
private Integer six;
private Integer seven;
public Num() {
}
public Num(Integer issue, String lotterydate, Integer one, Integer two, Integer tree, Integer four, Integer five, Integer six, Integer seven) {
this.issue = issue;
this.lotterydate = lotterydate;
this.one = one;
this.two = two;
this.tree = tree;
this.four = four;
this.five = five;
this.six = six;
this.seven = seven;
}
/*
Getter与Setter自行创建
*/
}
3.创建ParseHtml类
该类功能就是用来解析HTML文档，将内容提取出来的。
/**
* 该类的作用专门来解析html文件的
*/
public class ParseHtml {
/**
* 该方法仅限对Table表格进行解析
* @param html
* @return
*/
public static List<Num> parseTable(String html) {
// 1.创建集合
ArrayList<Num> list = new ArrayList<>();
// 2.解析html内容，生成Document对象
Document document = Jsoup.parse(html);
// 3.获取Document对象中所有tr节点元素
Elements trElements = document.select("tr");
// 4.遍历节点元素,由于第一行第二行是标题所以直接从第三行开始遍历
for (int i = 2; i < trElements.size(); i++) {
// 5.获取每个tr节点的内容
String trText = trElements.get(i).text();
// System.out.println("text = " + text);
// 6.通过打印发现，每行内容中的每个单元格内容是通过空格来隔开的所以我们通过空格来生成数组
String[] trSplit = trText.split(" ");
// 7.通过网页观察发现前九项是我们所需的数据，循环遍历封装前九项数据
Num num = new Num(
Integer.parseInt(trSplit[0]),
trSplit[1],
Integer.parseInt(trSplit[2]),
Integer.parseInt(trSplit[3]),
Integer.parseInt(trSplit[4]),
Integer.parseInt(trSplit[5]),
Integer.parseInt(trSplit[6]),
Integer.parseInt(trSplit[7]),
Integer.parseInt(trSplit[8])
);
// 8.项集合中添加元素
list.add(num);
}
return list;
}
}
4.代码测试
public class Main {
public static void main(String[] args) {
// 发送请求，获取网页数据
StringBuffer stringBuffer = RequestUtils.sendRequst("http://localhost/webstu/2.html");
// 对返回的网页数据进行解析
List<Num> list = ParseHtml.parseTable(stringBuffer.toString());
// 遍历打印
System.out.println("期号\t\t开奖日期\t\t第一号\t\t第二号\t\t第三号\t\t第四号\t\t第五号\t\t第六号\t\t第七号");
for (Num num : list) {
System.out.println(num.getIssue()+
"\t\t"+num.getLotterydate()+
"\t\t"+num.getOne()+
"\t\t"+num.getTwo()+
"\t\t"+num.getTree()+
"\t\t"+num.getFour()+
"\t\t"+num.getFive()+
"\t\t"+num.getSix()+
"\t\t"+num.getSeven());
}
}
}