Java讀取xml工具類實現(xiàn)方式
更新時間：2026年04月07日 09:25:25 作者：無了_wule
文章介紹了自定義注解IXml工具類XmlUtils,并提供了一個示例,它解釋了如何處理XML文件,演示了相關(guān)實體類Order和OrderDetail,并給出了測試方法
xml工具類
自定義注解IXml
import java.lang.annotation.*;
/**
* @ClassName: IXml
* @Description: 注意：當前判斷新建節(jié)點映射對象是根據(jù)類成員變量所有標注當前注解的字段值都不為null，
* 所以：
* 一 ：所有nodeName都必須存在于xml文件中（區(qū)分大小寫）
* 二 ：所有相同node節(jié)點和attributeName都必須相同，個數(shù)都保持一致
* @1"<Code curCode="21000090000000011001" packLayer="3" flag="0" />"
* @2“<Code curCode="21000080000000019897" packLayer="2" flag="0" parentCode="21000090000000011001"/>”
* 1比2少一個 parentCode ，造成只讀取了2這一條數(shù)據(jù)，可以給1 添加一個parentCode=“” 空字符串即可
* 三：如果不確定某個節(jié)點或?qū)傩砸欢ㄓ兄担瑯俗⒃撟⒔獾某蓡T變量類型用String
* @Date: 2023/3/20 14:24
* @author: ph9527
* @version: 1.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface IXml {
/**
* 當前字段所屬xml的標簽名稱
*
* @return
* @注意1： 默認取值為標簽的內(nèi)容，如果是標簽的屬性值，添加“attributeName”
* @注意2： 如果不需要attribute的信息不要填寫 （不要填寫 不要填寫 不要填寫） attributeName
*/
String nodeName();
/**
* 標簽的屬性名稱
*
* @return
* @注意1： 當該字段的值為xml中的屬性描述的值時，該屬性“attributeName”必填
* @注意2: 如果不需要該值，不要填寫 不要填寫 不要填寫 不要填寫
*/
String attributeName() default "";
/**
* 是否子集，當為true時，nodeName可以填寫任何值,
*
* @return
*/
boolean isSon() default false;
/**
* 日期轉(zhuǎn)換格式
*
* @return
*/
String dateFormat() default "";
}
工具類 XmlUtils
package com.ph.xml;
import com.ph.xml.annotation.IXml;
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* @ClassName: XmlUtils
* @Description: TODO
* @Date: 2023/3/20 14:24
* @author: ph9527
* @version: 1.0
*/
public class XmlUtils {
/**
* xml結(jié)構(gòu)
*/
static class NodeXml {
//節(jié)點名稱
private String nodeName;
//節(jié)點值
private String nodeValue;
//屬性名稱
private List<Attribute> attributes;
private List<NodeXml> sonXmlNodes;
}
/**
* xml屬性
*/
static class Attribute {
//屬性名稱
private String attributeName;
//屬性值
private String attributeValue;
}
/**
* 實體類與xml映射
*/
static class ClassNode {
//node名稱
private String nodeName;
//attribute名稱
private String attributeName;
//class字段名稱
private String fieldName;
//當前字段所在clazz
private Class clazz;
//父級class對象
private Class parentClass;
//節(jié)點級別
private Integer level;
//節(jié)點的值
private String value;
//true：當前類成員變量值為node的值; false:當前成員變量值為所屬node的attribute的值
private Boolean isNode;
private List<ClassNode> sons;
}
/**
* 讀取xml文件
*
* @param xmlFile
* @param clazz
* @param <T>
* @return
*/
public static <T> List<T> readXml(File xmlFile, Class<T> clazz) {
List<T> data = new ArrayList<>();
Document document = null;
try {
// 創(chuàng)建解析器工廠
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder db = factory.newDocumentBuilder();
// 創(chuàng)建一個Document對象
document = db.parse(xmlFile);
} catch (Exception e) {
e.printStackTrace();
}
if (document != null) {
Element rootElement = document.getDocumentElement();
//獲取整個XML節(jié)點信息
NodeXml nodeXml = getNodeXMlInfo(rootElement);
//獲取當前entity的所有注解@IXml的屬性
List<ClassNode> rs = new ArrayList<>();
List<ClassNode> resourceClassNodes = getAllFieldMapForClass(clazz, null, rs, 0);
if (nodeXml != null) {
try {
setData(nodeXml, data, clazz, resourceClassNodes);
} catch (Exception e) {
e.printStackTrace();
}
}
}
return data;
}
/**
* 獲取class與node的所有映射
*
* @param clazz
* @param parentClass
* @param rs
* @param level
* @return
*/
private static List<ClassNode> getAllFieldMapForClass(Class clazz, Class parentClass, List<ClassNode> rs, Integer level) {
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
IXml ixml = field.getAnnotation(IXml.class);
if (null != ixml) {
String fieldName = field.getName();
ClassNode classnode = null;
if (!ixml.isSon()) {
//不是子集
String nodeName = ixml.nodeName();
String attributeName = ixml.attributeName();
//如果ixml.attributeName為空則field的值為node 反之值為attribute的值
if (strIsNotBlank(attributeName)) {
// field的值為attribute的值
classnode = setClassNode(fieldName, nodeName, attributeName, false, clazz, parentClass, level);
} else {
// field的值為node的值
classnode = setClassNode(fieldName, nodeName, null, true, clazz, parentClass, level);
}
} else {
level++;
//子集
classnode = setClassNodeSons(field, clazz, level);
}
if (classnode != null) {
rs.add(classnode);
}
}
}
return rs;
}
/**
* 設置classNode子集
*
* @param field
* @param parentClass
* @param level
* @return
*/
private static ClassNode setClassNodeSons(Field field, Class parentClass, Integer level) {
Class clazz = getGenericClassForList(field);
ClassNode classNode = null;
if (clazz != null) {
List<ClassNode> classNodes = new ArrayList<>();
List<ClassNode> classNodeSons = getAllFieldMapForClass(clazz, parentClass, classNodes, level);
classNode = new ClassNode();
classNode.sons = classNodeSons;
classNode.fieldName = field.getName();
}
return classNode;
}
/**
* 獲取List的泛型類型
*
* @param field
* @return
*/
private static Class getGenericClassForList(Field field) {
Class clazz = null;
if (field.getType() == List.class) {
Type genericType = field.getGenericType();
if (genericType != null && genericType instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) genericType;
clazz = (Class<?>) pt.getActualTypeArguments()[0];
}
}
return clazz;
}
/**
* 設置classNode信息
*
* @param fieldName
* @param attributeName
* @param isNode
* @param clazz
* @param parentClass
* @param level
* @return
*/
private static ClassNode setClassNode(String fieldName, String nodeName, String attributeName, Boolean isNode, Class clazz, Class parentClass, Integer level) {
ClassNode classNode = new ClassNode();
classNode.fieldName = fieldName;
classNode.attributeName = attributeName;
classNode.nodeName = nodeName;
classNode.isNode = isNode;
classNode.clazz = clazz;
classNode.parentClass = parentClass;
classNode.level = level;
return classNode;
}
/**
* 設置值
*
* @param nodeXml
* @param data
* @param sourceClazz
* @param resourceClassNodes
* @param <T>
*/
private static <T> void setData(NodeXml nodeXml, List<T> data, Class<T> sourceClazz, List<ClassNode> resourceClassNodes) throws Exception {
//當前級別對象集
List nowObjLevel = new ArrayList();
//獲取所有節(jié)點值
List<ClassNode> classNodeValuesMapping = new ArrayList<>();
getNodeValueToClassNodeValue(nodeXml, resourceClassNodes, classNodeValuesMapping);
//添加一個null,多循環(huán)一次，添加最后一個對象到list
classNodeValuesMapping.add(null);
//初始當前對象
Object nowObject = sourceClazz.newInstance();
//添加第一個級別對象
nowObjLevel.add(nowObject);
//初始子集
List sonList = getSonList(nowObject);
if (classNodeValuesMapping.size() > 1) {
for (ClassNode classNode : classNodeValuesMapping) {
if (classNode != null) {
Class nodeClazz = classNode.clazz;
//檢測當前對象是否填滿
Boolean isFill = checkNowObjectIsFill(nowObject);
if (isFill) {
if (nowObject.getClass().getTypeName().equals(sourceClazz.getTypeName())) {
data.add((T) nowObject);
} else {
if (sonList != null) {
sonList.add(nowObject);
}
}
nowObject = nodeClazz.newInstance();
//當前級別
Integer nowLevel = classNode.level;
if ((nowLevel + 1) <= nowObjLevel.size()) {
nowObjLevel.set(nowLevel, nowObject);
} else {
nowObjLevel.add(nowObject);
}
//當前對象子集對象
Class parentClass = classNode.parentClass;
//查看當前對象的父級
if (parentClass != null) {
//當前父級對象
Object nowParentObj = findParentObj(parentClass, nowObjLevel);
sonList = getSonList(nowParentObj);
}
}
//填充屬性
nodeValueToObject(classNode, classNode.value, nowObject);
} else {
if (nowObject.getClass().getTypeName().equals(sourceClazz.getTypeName())) {
data.add((T) nowObject);
} else {
if (sonList != null) {
sonList.add(nowObject);
}
}
}
}
}
}
/**
* 獲取當前對象的父級對象
*
* @param parentClass
* @param nowObjLevel
* @return
*/
private static Object findParentObj(Class parentClass, List nowObjLevel) {
String typeName = parentClass.getTypeName();
for (Object obj : nowObjLevel) {
if (obj.getClass().getTypeName().equals(typeName)) {
return obj;
}
}
return null;
}
/**
* 獲取當前對象有注解@IXml且isSon=true的list
*
* @param nowParentObj
* @return
*/
private static List getSonList(Object nowParentObj) throws Exception {
Class clazz = nowParentObj.getClass();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
IXml Ixml = field.getAnnotation(IXml.class);
if (Ixml != null && Ixml.isSon()) {
Object sonList = field.get(nowParentObj);
if (sonList != null) {
return (List) sonList;
} else {
List newSonList = new ArrayList<>();
field.set(nowParentObj, newSonList);
return newSonList;
}
}
}
return null;
}
/**
* 獲取所有字段的值
*
* @param nodeXml 當前節(jié)點
* @param resourceClassNodes
* @param classNodeValueMappings
* @param <T>
* @throws InstantiationException
* @throws IllegalAccessException
*/
private static <T> void getNodeValueToClassNodeValue(NodeXml nodeXml, List<ClassNode> resourceClassNodes, List<ClassNode> classNodeValueMappings) throws Exception {
String nodeName = nodeXml.nodeName;
List<ClassNode> classNodes = new ArrayList<>();
findClassNodeByNodeName(nodeName, resourceClassNodes, classNodes);
if (classNodes.size() > 0) {
for (ClassNode classNode : classNodes) {
String value = getValueFromXml(classNode, nodeXml);
ClassNode newClassNode = new ClassNode();
newClassNode.nodeName = classNode.nodeName;
newClassNode.fieldName = classNode.fieldName;
newClassNode.attributeName = classNode.attributeName;
newClassNode.clazz = classNode.clazz;
newClassNode.parentClass = classNode.parentClass;
newClassNode.isNode = classNode.isNode;
newClassNode.level = classNode.level;
newClassNode.value = value;
classNodeValueMappings.add(newClassNode);
}
}
List<NodeXml> sonXmlNodes = nodeXml.sonXmlNodes;
if (sonXmlNodes != null && sonXmlNodes.size() > 0) {
for (NodeXml sonXmlNode : sonXmlNodes) {
getNodeValueToClassNodeValue(sonXmlNode, resourceClassNodes, classNodeValueMappings);
}
}
}
/**
* 填充值到當前對象
*
* @param classNode
* @param value
* @param nowObject
*/
private static void nodeValueToObject(ClassNode classNode, String value, Object nowObject) {
Field field = getFieldFromClassNode(classNode, nowObject);
if (value != null && field != null) {
try {
field.setAccessible(true);
Class<?> type = field.getType();
if (type == Double.class || type == double.class) {
Double newValue = Double.valueOf(value);
field.set(nowObject, newValue);
} else if (type == Long.class || type == long.class) {
Long newValue = Long.valueOf(value);
field.set(nowObject, newValue);
} else if (type == Date.class) {
IXml iXml = field.getAnnotation(IXml.class);
if (iXml != null) {
String dateFormat = iXml.dateFormat();
if (strIsNotBlank(dateFormat)) {
SimpleDateFormat format = new SimpleDateFormat(dateFormat);
Date newValue = format.parse(value);
field.set(nowObject, newValue);
}
}
} else if (type == Integer.class || type == int.class) {
Integer newValue = Integer.valueOf(value);
field.set(nowObject, newValue);
} else {
field.set(nowObject, value);
}
} catch (IllegalAccessException | ParseException | IllegalArgumentException e) {
throw new RuntimeException("屬性：[" + classNode.fieldName + "]與value : " + value + " 類型轉(zhuǎn)換異常 " + e);
}
}
}
/**
* 獲取需要設置值的字段
*
* @param classNode
* @param nowObject
* @return
*/
private static Field getFieldFromClassNode(ClassNode classNode, Object nowObject) {
String fieldName = classNode.fieldName;
Class<?> clazz = nowObject.getClass();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (field.getName().equals(fieldName)) {
return field;
}
}
return null;
}
/**
* 從xml獲取值
*
* @param classNode
* @param nodeXml
* @return
*/
private static String getValueFromXml(ClassNode classNode, NodeXml nodeXml) {
Boolean isNode = classNode.isNode;
if (isNode) {//field值為node的值
return nodeXml.nodeValue;
} else {//field值為node屬性值
String attributeName = classNode.attributeName;
List<Attribute> attributes = nodeXml.attributes;
for (Attribute attribute : attributes) {
if (attribute.attributeName.equals(attributeName)) {
return attribute.attributeValue;
}
}
}
return null;
}
/**
* 檢測當前對象所有標有注解Ixml的屬性都已賦值（子集屬性除外）
*
* @param nowObject
* @return
*/
private static Boolean checkNowObjectIsFill(Object nowObject) throws Exception {
Class nowClass = nowObject.getClass();
Field[] fields = nowClass.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
IXml ixml = field.getAnnotation(IXml.class);
if (ixml != null && !ixml.isSon()) {
Object obj = field.get(nowObject);
if (obj == null) {
return false;
}
}
}
return true;
}
/**
* 根據(jù)nodeName查詢ClassNode
*
* @param nodeName
* @param resourceClassNodes
* @param classNodes
* @return
*/
private static void findClassNodeByNodeName(String nodeName, List<ClassNode> resourceClassNodes, List<ClassNode> classNodes) {
for (ClassNode classNode : resourceClassNodes) {
if (classNode.sons == null) {
//不是子集
if (nodeName.equals(classNode.nodeName)) {
classNodes.add(classNode);
}
} else {
//是子集
findClassNodeByNodeName(nodeName, classNode.sons, classNodes);
}
}
}
/**
* 獲取整個xml節(jié)點的信息
*
* @param rootElement
* @return
*/
private static NodeXml getNodeXMlInfo(Element rootElement) {
NodeXml nodeXml = null;
if (rootElement != null) {
nodeXml = new NodeXml();
nodeXml.nodeName = rootElement.getNodeName();
nodeXml.nodeValue = strIsNotBlank(rootElement.getNodeValue()) ? rootElement.getNodeValue() : "";
NamedNodeMap attributes = rootElement.getAttributes();
List<Attribute> attributeInfo = getAttributeInfo(attributes);
nodeXml.attributes = attributeInfo;
NodeList childNodes = rootElement.getChildNodes();
if (childNodes != null && childNodes.getLength() > 0) nodeXml.sonXmlNodes = getSonNodeInfo(childNodes);
}
return nodeXml;
}
/**
* 獲取節(jié)點相關(guān)信息
*
* @param nodeList
*/
private static List<NodeXml> getSonNodeInfo(NodeList nodeList) {
List<NodeXml> nodeXmlList = new ArrayList<>();
int nodeLength = nodeList.getLength();
for (int i = 0; i < nodeLength; i++) {
Node nodeItem = nodeList.item(i);
String nodeName = nodeItem.getNodeName();
if (checkNodeName(nodeName)) {
NodeXml nodeXml = setNodeInfo(nodeItem);
NodeList childNodes = nodeItem.getChildNodes();
if (childNodes != null && childNodes.getLength() > 0) nodeXml.sonXmlNodes = getSonNodeInfo(childNodes);
nodeXmlList.add(nodeXml);
}
}
return nodeXmlList;
}
/**
* 設置節(jié)點相關(guān)信息
*
* @param nodeItem
* @return
*/
private static NodeXml setNodeInfo(Node nodeItem) {
NodeXml nodeXml = new NodeXml();
nodeXml.nodeName = nodeItem.getNodeName();
Node firstChild = nodeItem.getFirstChild();
if (firstChild != null) {
nodeXml.nodeValue = firstChild.getNodeValue();
}
//屬性相關(guān)信息值設置
NamedNodeMap attributes = nodeItem.getAttributes();
List<Attribute> attributeList = getAttributeInfo(attributes);
nodeXml.attributes = attributeList;
return nodeXml;
}
/**
* 獲取屬性相關(guān)信息
*
* @param attributes
* @return
*/
private static List<Attribute> getAttributeInfo(NamedNodeMap attributes) {
List<Attribute> attributeList = new ArrayList<>();
int attributeLength;
if (attributes != null && (attributeLength = attributes.getLength()) > 0) {
for (int j = 0; j < attributeLength; j++) {
Node attributeNode = attributes.item(j);
Attribute attribute = new Attribute();
attribute.attributeName = attributeNode.getNodeName();
attribute.attributeValue = strIsNotBlank(attributeNode.getNodeValue()) ? attributeNode.getNodeValue() : "";
attributeList.add(attribute);
}
}
return attributeList;
}
/**
* 檢測節(jié)點名稱不為空
*
* @param nodeName
* @return
*/
private static Boolean checkNodeName(String nodeName) {
return nodeName != null && nodeName.trim() != "" && !nodeName.trim().equals("#text");
}
/**
* 檢驗字符串不為空
*
* @param str
* @return
*/
private static Boolean strIsNotBlank(String str) {
return str != null && !str.trim().equals("");
}
}
示例xml文件
<?xml version="1.0" encoding="utf-8"?>
<Document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="訂單XML Schema-3.0.xsd" License="00120-100290-002">
<Events version="3.0">
<Event name="Order">
<Order orderNo="D181101004" orderTime="2023-01-01" buyer="小明" moneyTotal="300">
<OrderDetails>
<Detail>
<GoodeName>芒果</GoodeName>
<Count>10</Count>
<Money>100</Money>
</Detail>
<Detail>
<GoodeName>香蕉</GoodeName>
<Count>20</Count>
<Money>100</Money>
</Detail>
<Detail>
<GoodeName>橘子</GoodeName>
<Count>30</Count>
<Money>100</Money>
</Detail>
</OrderDetails>
</Order>
</Event>
</Events>
</Document>示例xml相關(guān)實體類—Order
import java.util.Date;
import java.util.List;
/**
* @ClassName: Order
* @Description: TODO
* @Date: 2023/4/10 11:21
* @author: ph9527
* @version: 1.0
*/
public class Order {
@IXml(nodeName = "Order", attributeName = "orderNo")
private String orderNo;
@IXml(nodeName = "Order", attributeName = "orderTime", dateFormat = "yyyy-MM-dd")
private Date orderTime;
@IXml(nodeName = "Order", attributeName = "buyer")
private String buyer;
@IXml(nodeName = "Order", attributeName = "moneyTotal")
private Double moneyTotal;
@IXml(nodeName = "這里名稱隨便寫，或者空字符串都行", isSon = true)
private List<OrderDetail> details;
public Order(String orderNo, Date orderTime, String buyer, Double moneyTotal, List<OrderDetail> details) {
this.orderNo = orderNo;
this.orderTime = orderTime;
this.buyer = buyer;
this.moneyTotal = moneyTotal;
this.details = details;
}
public Order() {
}
public String getOrderNo() {
return orderNo;
}
public void setOrderNo(String orderNo) {
this.orderNo = orderNo;
}
public Date getOrderTime() {
return orderTime;
}
public void setOrderTime(Date orderTime) {
this.orderTime = orderTime;
}
public String getBuyer() {
return buyer;
}
public void setBuyer(String buyer) {
this.buyer = buyer;
}
public Double getMoneyTotal() {
return moneyTotal;
}
public void setMoneyTotal(Double moneyTotal) {
this.moneyTotal = moneyTotal;
}
public List<OrderDetail> getDetails() {
return details;
}
public void setDetails(List<OrderDetail> details) {
this.details = details;
}
@Override
public String toString() {
return "Order{" +
"orderNo='" + orderNo + '\'' +
", orderTime=" + orderTime +
", buyer='" + buyer + '\'' +
", moneyTotal=" + moneyTotal +
", details=" + details +
'}';
}
}
示例xml相關(guān)實體類—OrderDetail
import java.util.Date;
/**
* @ClassName: OrderDetail
* @Description: TODO
* @Date: 2023/4/10 11:25
* @author: ph9527
* @version: 1.0
*/
public class OrderDetail {
@IXml(nodeName = "GoodeName")
private String goodName;
@IXml(nodeName = "Count")
private Integer count;
@IXml(nodeName = "Money")
private Double money;
public OrderDetail(String goodName, Integer count, Double money) {
this.goodName = goodName;
this.count = count;
this.money = money;
}
public OrderDetail() {
}
public String getGoodName() {
return goodName;
}
public void setGoodName(String goodName) {
this.goodName = goodName;
}
public Integer getCount() {
return count;
}
public void setCount(Integer count) {
this.count = count;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "OrderDetail{" +
"goodName='" + goodName + '\'' +
", count=" + count +
", money=" + money +
'}';
}
}
測試方法
public static void main(String[] args) throws Exception {
File file = new File("D:\\PH\\Desktop\\工作\\測試xml\\訂單.xml");
List<Order> relations = XmlUtils.readXml(file, Order.class);
relations.stream().forEach(item -> System.out.println(item));
}
總結(jié)
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。
相關(guān)文章
本篇文章主要對struts2框架概念、優(yōu)缺點進行簡要概述。相信會對大家學習Java有所幫助，需要的朋友一起來看下吧2016-12-12
InputStream數(shù)據(jù)結(jié)構(gòu)示例解析
這篇文章主要為大家介紹了InputStream數(shù)據(jù)結(jié)構(gòu)示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
上傳文件是互聯(lián)網(wǎng)中常應用的場景之一，最典型的情況就是上傳頭像等，今天就帶著大家做一個Spring Boot上傳文件的小案例，感興趣的朋友跟隨腳本之家小編一起學習吧2018-01-01
這篇文章主要介紹了Maven之分析剔除無用的jar引用問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-09-09
springboot 使用poi進行數(shù)據(jù)的導出過程詳解
這篇文章主要介紹了springboot 使用poi進行數(shù)據(jù)的導出過程詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-09-09
spring cloud gateway中redis一直打印重連日志問題及解決
這篇文章主要介紹了spring cloud gateway中redis一直打印重連日志問題及解決,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-05-05
這篇文章主要介紹了java中關(guān)于控件JTextArea的幾個方法，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-08-08
Springboot Redis?哨兵模式的實現(xiàn)示例
本文主要介紹了Springboot Redis?哨兵模式的實現(xiàn)示例，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-01-01
這篇文章主要給大家介紹了關(guān)于Java8中CompletableFuture用法的相關(guān)資料,文中通過實例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值，需要的朋友可以參考下2022-01-01
方法引用可以認為是Lambda表達式的一種特殊形式，Lambda表達式可以讓開發(fā)者自定義抽象方法的實現(xiàn)代碼，方法引用則可以讓開發(fā)者直接引用已存在的實現(xiàn)方法，作為Lambda表達式的Lambda體(參數(shù)列表得一致),需要的朋友可以參考下2023-05-05