精华内容
下载资源
问答
  • java解析Excel使用hutool工具类

    千次阅读 2019-05-09 16:47:24
    hutool包,真是好用,方便,强烈...然后使用Excel的工具类,还需要引入poi-ooxml包版本的话,报错里面有 自己确认一下就好了 <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml --> <depe...

    hutool包,真是好用,方便,强烈推荐…
    https://hutool.cn/docs/index.html#/
    然后使用Excel的工具类,还需要引入poi-ooxml包版本的话,报错里面有
    自己确认一下就好了

     <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>3.17</version>
            </dependency>
    

    一行代码搞定:常用的就是read方法了.

            ExcelReader reader = ExcelUtil.getReader(FileUtil.file("C:\\Users\\stack\\Desktop\\hanke\\aaa.xlsx"));
    

    在这里插入图片描述

    展开全文
  • Gson+JsonPath+泛型 java json解析工具类

    千次阅读 2015-11-13 17:37:32
    Json解析工具类完善一下,使用GSON+JsonPath+泛型来提高自己写JSON解析的效率 如下 关于JsonPath http://www.7mdm.com/1374.html https://github.com/jayway/JsonPath 为json解析轻松加上Integer Double String ...

    代码下载:点击打开链接

    Json解析工具类完善一下,使用GSON+JsonPath+泛型来提高自己写JSON解析的效率 如下关于JsonPath

    http://www.7mdm.com/1374.html

    https://github.com/jayway/JsonPath

    为json解析轻松加上Integer Double String  List<String> 以及 T   List<T>的泛型功能

    比如这段json

    {
        "store": {
            "book": [
                {
                    "category": "reference",
                    "author": "Nigel Rees",
                    "title": "Sayings of the Century",
                    "price": 8.95
                },
                {
                    "category": "fiction",
                    "author": "Evelyn Waugh",
                    "title": "Sword of Honour",
                    "price": 12.99,
                    "isbn": "0-553-21311-3"
                }
            ],
            "bicycle": {
                "color": "red",
                "price": 19.95
            }
        }
    }
    




    Java获取所有作者  

    List<String> list = JsonPathGeneric.getGenericList(json,"$.store.book[*].author", String.class)

    输出=====> [Nigel Rees, Evelyn Waugh]

    Double d = JsonPathGeneric.getGeneric(json,"$.store.bicycle.price",Double.class);

    输出=====>19.95



    如果单纯想要获得单本书
    public class BeanBook implements Serializable {
    	public String author;
    	public Double price;
    	public String category;
    	public String title;
    	@Override
    	public String toString() {
    		return "Book [author=" + author + ", price=" + price + ", category="
    				+ category + ", title=" + title + "]";
    	}
    
        
    }


    BeanBook bean=JsonPathGeneric.getGenericObject(json,"$.store.book[0]", BeanBook.class);

    输出=====>Book [author=Evelyn Waugh, price=12.99, category=fiction, title=Sword of Honour]



    除了静态的方法还有指定继承关系的json泛型强转

    来一个开发的例子如下

    json1

    {
        "status": "success",
        "result": {
            "user_id": ​4,
            "nickname": "",
            "xiaoqu_id": ​1
        }
    }

    json2

    {
        "status": "success",
        "result": [
            {
                "user_id": ​4,
                "nickname": "",
                "xiaoqu_id": ​1
            },
            {
                "user_id": 5,
                "nickname": "",
                "xiaoqu_id": ​3
            }
        ]
    }



    public class BeanUser {
    	   public String xiaoqu_id  ;
    	   public String user_id  ;
    	   public String nickname  ;
    }
    


    java代码
    	System.out.println(JsonPathGeneric.getGeneric(json1, "$.status", String.class));       
    		{
    			System.out.println(json1);
    			String id = new Generic<BeanUser>(json1, "$.result") {
    			}.getJsonBean().user_id;
    			System.out.println("user_id=" + id);
    		}
    		{
    			System.out.println(json2);
    			List<BeanUser> list = new Generic<List<BeanUser>>(json2, "$.result") {
    			}.getJsonBean();
    			System.out.println("user_id=" + list.get(1).user_id);
    		}


    打印结果

    success

    user_id=​4

    user_id=5



    以下是工具类代码:

    package org.utils.json;
    
    import java.lang.reflect.Type;
    import java.util.List;
    
    import com.google.gson.Gson;
    import com.google.gson.reflect.TypeToken;
    import com.jayway.jsonpath.JsonPath;
    
    public class JsonPathGeneric<T> {
    
    	@SuppressWarnings("unchecked")
    	public static <T> T getGeneric(String json, String jsonPath, Class<T> clazz) {
    		
    		return new JsonPathGeneric<T>(clazz, json, jsonPath).getObject();
    	}
    
    	@SuppressWarnings("unchecked")
    	public static <T> T getGenericObject(String json, String jsonPath,
    			Class<T> clazz) {
    		String jsonResult =null;
    		if(jsonPath==null||"".equals(jsonPath))
    		{
    			jsonResult=json;
    		}else
    		{
    	        jsonResult = JsonPath.read(json, jsonPath).toString();
    		}
    		if (String.class.equals(clazz)) {
    			return (T) jsonResult;
    		}
    		return (T) new Gson().fromJson(jsonResult, clazz);
    
    	}
    
    	@SuppressWarnings("unchecked")
    	public static <T> List<T> getGenericList(String json, String jsonPath,
    			Class<T> clazz) {
    		String jsonResult =null;
    		if(jsonPath==null||"".equals(jsonPath))
    		{
    			jsonResult=json;
    		}else
    		{
    	        jsonResult = JsonPath.read(json, jsonPath).toString();
    		}
    	
    		Type listtype = new TypeToken<List<T>>() {
    		}.getType();
    		return (List<T>) new Gson().fromJson(jsonResult, listtype);
    	}
    
    	public JsonPathGeneric() {
    	}
    
    	private String json;
    	private String jsonPath;
    	private String jsonResult;
    	private Type type;
    	private T object;
    
    	/**继承关系时注意父类传值*/
    	public JsonPathGeneric(Object obj, String json, String jsonPath) {
    		if (obj instanceof Type) {
    			parse((Type) obj, json, jsonPath);
    		} else {
    			parse(ReflectionUtil.getParameterizedTypes(obj)[0], json, jsonPath);
    		}
    	}
    
    	public JsonPathGeneric(Type type, String json, String jsonPath) {
    		parse(type, json, jsonPath);
    	}
    
    	public JsonPathGeneric(String json, String jsonPath) {
    		Type[] parameterizedTypes = ReflectionUtil.getParameterizedTypes(this);
    		type = parameterizedTypes[0];
    		parse(type, json, jsonPath);
    	}
    
    	@SuppressWarnings("unchecked")
    	public void parse(Type type, String json, String jsonPath) {
    		this.json = json;
    		this.jsonPath = jsonPath;
    		this.type = type;
    		if(jsonPath==null||"".equals(jsonPath))
    		{
    			jsonResult=json;
    		}else{
    			this.jsonResult = JsonPath.read(json, jsonPath).toString();
    		}
    		Class<T> clazz = null;
    		try {
    			clazz = (Class<T>) ReflectionUtil.getClass(type);
    		} catch (ClassNotFoundException e) {
    		}
    
    		if (clazz != null) {
    			if (String.class.equals(clazz)) {
    				object = (T) jsonResult;
    			} else {
    				object = new Gson().fromJson(jsonResult, clazz);
    			}
    		} else {
    			object = new Gson().fromJson(jsonResult, type);
    		}
    //		System.out.println("-------------------------------");
    //		System.err.println(jsonResult);
    //		System.err.println(object.getClass().getSimpleName());
    //		System.err.println(object);
    //		System.out.println("-------------------------------");
    	}
    
    	public String getJson() {
    		return json;
    	}
    
    	public JsonPathGeneric<T> setJson(String json) {
    		this.json = json;
    		return this;
    	}
    
    	public String getJsonPath() {
    		return jsonPath;
    	}
    
    	public JsonPathGeneric<T> setJsonPath(String jsonPath) {
    		this.jsonPath = jsonPath;
    		return this;
    	}
    
    	public String getJsonResult() {
    		return jsonResult;
    	}
    
    	public Type getType() {
    		return type;
    	}
    
    	public JsonPathGeneric<T> setType(Type type) {
    		this.type = type;
    		return this;
    	}
    
    	public T getObject() {
    		return object;
    	}
    
    }


    public class Generic<T> {
    
    	public Generic(String json, String jsonPath) {
    		// TODO Auto-generated constructor stub
    		/**继承关系时注意父类传值this*/
    		jsonBean = new JsonPathGeneric<T>(this, json, jsonPath).getObject();
    	}
    
    	public T jsonBean;
    
    	public T getJsonBean() {
    		return jsonBean;
    	}
    
    	public void setJsonBean(T jsonBean) {
    		this.jsonBean = jsonBean;
    	}
    
    }
    



    代码下载:点击打开链接


    展开全文
  • 解析xml工具类

    千次阅读 2017-12-17 15:56:15
    java解析xml工具类(SAXReader解析) 需要的jar包 需要的两个jar包 点我下载 http://download.csdn.net/download/weixin_39549656/10162229 工具类 XmlUtil.java(这个是工具类) public class XmlUtil { //...

    java解析xml工具类(SAXReader解析)

    需要的jar包

    需要的两个jar包
    点我下载
    http://download.csdn.net/download/weixin_39549656/10162229
    工具类
    XmlUtil.java(这个是工具类)

    public class XmlUtil {
    
        //定义解析器和文档对象
        private SAXReader saxReader;
        private Document document;
    
        public XmlUtil(String path){
            //获取解析器
            saxReader = new SAXReader();
            try {
                //获取文档对象
                document = saxReader.read(path);
            } catch (DocumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
        /**
         * 根据节点名称获取内容
         * @param name 节点名称
         * @return 节点内容
         */
        public String getElementText(String name){
            //定位根节点
            Element root = document.getRootElement();
            //根据名称定位节点
            Element element = root.element(name);
            //返回节点内容
            return element.getText();
        }
    

    别解析文件

    db.xml(这是需要解析的文件)

    <?xml version="1.0" encoding="UTF-8"?>
    <db>
        <driver>com.mysql.jdbc.Driver</driver>
        <url>jdbc:mysql://127.0.0.1:3366/bjpowernode</url>
        <username>root</username>
        <pwd>111</pwd>
    </db>

    测试代码

    下面的代码用于测试

    //获取配置文件路径
                String dbpath = getServletContext().getRealPath("/config/db.xml");
                //通过路径  使用工具类获取数据库连接信息
                XmlUtil  xmlUtil = new XmlUtil(dbpath);
                String driver = xmlUtil.getElementText("driver");
                String url = xmlUtil.getElementText("url");
                String dbname = xmlUtil.getElementText("username");
                String dbpwd = xmlUtil.getElementText("pwd");
                System.out.println(driver);
                System.out.println(url);
                System.out.println(dbname);
                System.out.println(dbpwd);

    请求转发与重定向代码

    其他跳转问题(请求转发,重定向代码)

    //请求转发
    request.getRequestDispatcher("/success.html").forward(request, response);
    //需要保存数据的话建议用重定向,不然会出现重复提交的问题
    response.sendRedirect("/cookie/success.html");
    展开全文
  • java自带的xml解析工具类

    千次阅读 2019-10-02 02:20:15
    1 public class JaxbUtil { 2 3 /** 4 * java对象转换为xml文件 5 * 6 * @param xmlPath xml文件路径 7 * @param load java对象.Class 8 * @return xml文件的Strin...
      1 public class JaxbUtil {
      2 
      3     /**
      4      * java对象转换为xml文件
      5      * 
      6      * @param xmlPath xml文件路径
      7      * @param load    java对象.Class
      8      * @return xml文件的String
      9      * @throws JAXBException
     10      */
     11     public static String beanToXml(Object obj, Class<?> load) throws JAXBException {
     12         JAXBContext context = JAXBContext.newInstance(load);
     13         Marshaller marshaller = context.createMarshaller();
     14         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, false);
     15         StringWriter writer = new StringWriter();
     16         marshaller.marshal(obj, writer);
     17         return writer.toString();
     18     }
     19 
     20     /**
     21      * xml文件配置转换为对象
     22      * 
     23      * @param xmlPath xml文件路径
     24      * @param load    java对象.Class
     25      * @return java对象
     26      * @throws JAXBException
     27      * @throws IOException
     28      */
     29     @SuppressWarnings("unchecked")
     30     public static <T> T xmlToBean(String xmlPath, Class<T> load) throws JAXBException, IOException {
     31         JAXBContext context = JAXBContext.newInstance(load);
     32         Unmarshaller unmarshaller = context.createUnmarshaller();
     33         return (T) unmarshaller.unmarshal(new StringReader(xmlPath));
     34     }
     35 
     36     /**
     37      * JavaBean转换成xml 默认编码UTF-8
     38      * 
     39      * @param obj
     40      * @param writer
     41      * @return
     42      */
     43     public static String convertToXml(Object obj) {
     44         return convertToXml(obj, "UTF-8");
     45     }
     46 
     47     /**
     48      * JavaBean转换成xml
     49      * 
     50      * @param obj
     51      * @param encoding
     52      * @return
     53      */
     54     public static String convertToXml(Object obj, String encoding) {
     55         String result = null;
     56         try {
     57             JAXBContext context = JAXBContext.newInstance(obj.getClass());
     58             Marshaller marshaller = context.createMarshaller();
     59             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
     60             marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
     61             //去掉生成xml的默认报文头  
     62              marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true); 
     63             StringWriter writer = new StringWriter();
     64             writer.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "\n    ");
     65             marshaller.marshal(obj, writer);
     66             result = writer.toString();
     67         } catch (Exception e) {
     68             e.printStackTrace();
     69         }
     70         return result;
     71     }
     72 
     73     /**
     74      * JavaBean转换成xml去除xml声明部分
     75      * 
     76      * @param obj
     77      * @param encoding
     78      * @return
     79      */
     80     public static String convertToXmlIgnoreXmlHead(Object obj, String encoding) {
     81         String result = null;
     82         try {
     83             JAXBContext context = JAXBContext.newInstance(obj.getClass());
     84             Marshaller marshaller = context.createMarshaller();
     85             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
     86             marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
     87             marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
     88             StringWriter writer = new StringWriter();
     89             marshaller.marshal(obj, writer);
     90             result = writer.toString();
     91         } catch (Exception e) {
     92             e.printStackTrace();
     93         }
     94         return result;
     95     }
     96 
     97     /**
     98      * xml转换成JavaBean
     99      * 
    100      * @param xml
    101      * @param c
    102      * @return
    103      */
    104     @SuppressWarnings("unchecked")
    105     public static <T> T converyToJavaBean(String xml, Class<T> c) {
    106         T t = null;
    107         try {
    108             JAXBContext context = JAXBContext.newInstance(c);
    109             Unmarshaller unmarshaller = context.createUnmarshaller();
    110             t = (T) unmarshaller.unmarshal(new StringReader(xml));
    111         } catch (Exception e) {
    112             e.printStackTrace();
    113         }
    114         return t;
    115     }
    116 
    117     private static OutputFormat createPrettyPrint() {
    118         OutputFormat format = new OutputFormat();
    119         //format.setIndentSize(2);
    120         format.setNewLineAfterDeclaration(false);
    121         format.setNewlines(true);
    122         format.setTrimText(false);
    123         format.setPadText(false);
    124         return format;
    125     }
    126 
    127     /**
    128      * 
    129      * @Title: formatXml
    130      * @author:humingbo
    131      * @date:2019年7月18日上午11:35:08
    132      * @Description: 格式化xml方法
    133      * @param str
    134      * @return
    135      * @throws Exception
    136      */
    137     public static String formatXml(String str) throws Exception {
    138         Document document = null;
    139         document = DocumentHelper.parseText(str);
    140         // 格式化输出格式
    141         OutputFormat format = createPrettyPrint();
    142         format.setEncoding("UTF-8");
    143         StringWriter writer = new StringWriter();
    144         // 格式化输出流
    145         XMLWriter xmlWriter = new XMLWriter(writer, format);
    146         // 将document写入到输出流
    147         xmlWriter.write(document);
    148         xmlWriter.close();
    149         return writer.toString();
    150     }
    151 }

     

    转载于:https://www.cnblogs.com/huzi007/p/11334765.html

    展开全文
  • 简单的html解析工具类

    千次阅读 2017-08-16 16:43:31
    最近在做一个项目,要求解析html报告里的数据,报告的规格也都不一样。就写了个简单的工具类 用到的技术是结合了 jsoup、sipsoup包的使用
  • java世界中几种html解析工具

    万次阅读 2016-11-09 17:27:33
    HTML分析是一个比较复杂的工作,Java世界主要有几款比较方便的分析工具: Jsoup Jsoup是一个集强大和便利于一体的HTML解析工具。它方便的地方是,可以用于支持用jquery中css selector的方式选取元素,这对于熟悉js...
  • Java Document 工具类

    千次阅读 2019-09-02 11:36:35
    Java 对本地HTML文件的读取和写入的工具类,可以用来修改静态HTML的内容。 2、Maven包 需要引入jsoup包 <dependency> <groupId>org.jsoup</groupId> <artifactId>jsoup</...
  • Java Utils工具类大全

    万次阅读 2019-01-21 23:06:10
    另外希望身为Java牛牛的你们一起测试和完善,欢迎入群263641914 一起封装和完成常用的Java代码。 节约撸码时间以方便有更多的时间去把妹子~ #开发环境 Win7x64 JDK1.7 IDEA14 #项目结构 │ README.m...
  • JAVA常用工具类

    万次阅读 多人点赞 2018-09-11 22:28:32
    JAVA常用工具类(根据GITHUB代码统计) 从Google你能搜索到大量的关于Struts,Spring,Hibernate,iBatis等比较大的框架的资料,但是很少有人去关注一些小的工具包,但是当你真正知道了这些包的用处之后,你会发现它能很...
  • java 之 xml 解析工具

    千次阅读 2017-07-04 10:42:43
    java 解析 xml 文件转载自 :http://www.cnblogs.com/lanxuezaipiao/archive/2013/05/17/3082949.htm
  • JAVA AST 解析JAVA类文件

    千次阅读 2016-11-30 12:30:53
    参考教程:http://www.cnblogs.com/lifesting/tag/%E7%BC%96%E8%AF%91%E5%99%A8%20%E8%A7%A3%E9%87%8A%E5%99%A8%20Java%20AST%20%E8%AF%AD%E6%B3%95%E6%A0%91/default.html?page=2 ...
  • Java 爬虫工具Jsoup解析

    万次阅读 2017-04-25 10:46:49
    Jsoup是一款 JavaHTML 解析器,可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API,可通过 DOM,CSS 以及类似于 jQuery 的操作方法来取出和操作数据。 jsoup 的主要功能如下: 1. 从一个 ...
  • Java 读取HTML页面源代码工具类

    万次阅读 2013-08-14 12:12:02
    以前抓淘宝数据和抓取优酷、土豆的源视频地址的时候需要通过IO流获取它们的HTML的源代码,为了方便所以写了这个工具类。  package com.hanyastar.util; import java.io.BufferedInputStream; import java.io....
  • java一个意想不到的工具类 StringUtils

    千次阅读 2018-07-06 10:04:38
    java一个意想不到的工具类 StringUtilspackage fmc.eq.common.utils; import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map...
  • Java工具类之配置文件读取

    千次阅读 2016-02-20 15:18:11
    在项目中,经常会用到很多的工具类,比如读取配置文件,上传下载,导入导出,json解析,排序等一些工具类。以前用到了很多,但是没有记录,等到下次工作的时候,要么就是在网上找,要么就是问同事要。现在准备总结...
  • java工具类mht转html格式文件

    千次阅读 2016-11-02 11:29:14
    [相关/方法] * @since [产品/模块版本] */ public class Mht2HtmlUtil { public static void main (String[] args) { Mht2HtmlUtil. mht2html ( "d: \\ 51job_111.mht" , "d: \\ test...
  • Java类加载器 ClassLoader的解析

    千次阅读 2016-04-21 10:13:49
    Java类加载器 ClassLoader的解析
  • WebUtils工具类解析

    千次阅读 2018-06-01 15:09:33
    WebUtils根据名称,知道是Spring当中一个工具类,主要用于Web应用程序,供各种框架使用。其下有一些方法,如下:1.将一个系统性质设置到上下文根路径 public static void setWebAppRootSystemProperty...
  • Java解析HTML之HTMLParser使用与详解

    千次阅读 2017-08-07 09:43:18
    官方文档:http://htmlparser.sourceforge.NET/samples.html API:http://htmlparser.sourceforge.net/javadoc/index.html 其它HTML 解释器:jsoup等。由于HtmlParser自2006年以后就再没更新,目前很多人推荐...
  • Java XML解析工具 dom4j介绍及使用实例

    千次阅读 2018-04-21 09:48:13
    Java 有哪些优秀的类库及工具便于程序员对 XML 进行处理 ?大名鼎鼎的 DOM绿色环保的 SAX默默无闻的 Digester三种解析方式比较DOM优缺点:实现 W3C 标准,有多种编程语言支持这种解析方式,并且这种方法本身操作上...
  • java —— token的使用工具类

    千次阅读 2019-05-09 14:46:10
    所以后来有了session出现来...但是随着用户量增大,session所占的内存也越来越大,服务器的压力也大,所有后面出现了token,它把session的数据加密,可以保存进redis或者本地数据库,需要用户验证的时候再拿出来解析...
  • Java解析 PDF

    千次阅读 2013-03-21 13:22:00
    1、使用PDFBox处理PDF文档 PDF全称Portable Document Format,是Adobe公司开发的电子文件格式。这种文件格式与操作系统平台无关,可以...如果要抽取其中的文本信息,需要根据它的文件格式来进行解析。幸好目前已经有
  • Java工具类--通过HttpClient发送http请求

    万次阅读 多人点赞 2015-11-27 15:17:34
    在写网络程序的时候,经常会有从网址获取数据的需求,上一篇解析JSON就需要从百度获取天气数据,本文介绍一种模拟发送http请求的工具–HttpClient。HttpClient的介绍 The most essential function of HttpClient is...
  • java图片处理工具类: package com.pinker.util; import java.awt.Color; import java.awt.Graphics; import java.awt.Image; import java.awt.image.BufferedImage; import java.io.File; import java.
  • Java7中新增的Files和Paths工具类

    千次阅读 2018-04-10 18:24:38
    为了简化开发,Java提供了很多的工具类,此前的文章也提到了一些其他方面的工具类,这篇文章将学习一下Java7中新增的Files类和Paths类。Paths类:这个类有一个静态方法get()可以接收一个或多个字符串参数,这些...
  • java判断时间差年月日工具类

    千次阅读 2019-05-15 09:59:52
    一、Java 时间比较需求 1.A时间到B时间,相差多少年,月,日。 如:2011-02-02到 2017-03-02,结果为: * 相差 6年,1个月,0天 2.A时间到B时间, 相差年,月,日各是多少。 如:2011-02-02到 2017-03-02,结果...
  • 看到这个题目是不是大部分人都不屑一顾,的确基本上每个java程序猿都写过json工具类,也有很多人都使用json-lib.jar封装过类似的功能,但是我这里使用了正则来支持xml与json的互转,减少了jar包的引入。基本上满足了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,558
精华内容 52,623
关键字:

java解析html工具类

java 订阅