直接读写文件，再把读出来的文件内容格式化成json，再用、Mybatis或者其他框架将json数据存入数据库。
假设实体类是这样的：
publicclassElectSet{
publicStringxueqi;
publicStringxuenian;
publicStringstartTime;
publicStringendTime;
publicintmenshu;
publicStringisReadDB;
//{"xueqi":,"xuenian":,"startTime":,"endTime":,"renshu":,"isReadDB":}
publicStringgetXueqi(){
returnxueqi;
}
publicvoidsetXueqi(Stringxueqi){
this.xueqi=xueqi;
}
publicStringgetXuenian(){
returnxuenian;
}
publicvoidsetXuenian(Stringxuenian){
this.xuenian=xuenian;
}
publicStringgetStartTime(){
returnstartTime;
}
publicvoidsetStartTime(StringstartTime){
this.startTime=startTime;
}
publicStringgetEndTime(){
returnendTime;
}
publicvoidsetEndTime(StringendTime){
this.endTime=endTime;
}
publicintgetMenshu(){
returnmenshu;
}
publicvoidsetMenshu(intmenshu){
this.menshu=menshu;
}
publicStringgetIsReadDB(){
returnisReadDB;
}
publicvoidsetIsReadDB(StringisReadDB){
this.isReadDB=isReadDB;
}
}有一个json格式的文件，存的信息如下：
Sets.json:
{"xuenian":"2007-2008","xueqi":"1","startTime":"2009-07-1908:30","endTime":"2009-07-2218:00","menshu":"10","isReadDB":"Y"}
具体操作：
/*
*取出文件内容，填充对象
*/
publicElectSetfindElectSet(Stringpath){
ElectSetelectset=newElectSet();
Stringsets=ReadFile(path);//获得json文件的内容
JSONObjectjo=JSONObject.fromObject(sets);//格式化成json对象
//System.out.println("------------"jo);
//Stringname=jo.getString("xuenian");
//System.out.println(name);
electset.setXueqi(jo.getString("xueqi"));
electset.setXuenian(jo.getString("xuenian"));
electset.setStartTime(jo.getString("startTime"));
electset.setEndTime(jo.getString("endTime"));
electset.setMenshu(jo.getInt("menshu"));
electset.setIsReadDB(jo.getString("isReadDB"));
returnelectset;
}
//设置属性，并保存
publicbooleansetElect(Stringpath,Stringsets){
try{
writeFile(path,sets);
returntrue;
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
returnfalse;
}
}
//读文件，返回字符串
publicStringReadFile(Stringpath){
Filefile=newFile(path);
BufferedReaderreader=null;
Stringlaststr="";
try{
//System.out.println("以行为单位读取文件内容，一次读一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次读入一行，直到读入null为文件结束
while((tempString=reader.readLine())!=null){
//显示行号
System.out.println("line"line":"tempString);
laststr=laststrtempString;
line;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
returnlaststr;
}
将获取到的字符串，入库即可。
『贰』 Java解析json数据
JSONObject dataJson=new JSONObject("你的抄Json数据“);
JSONObject response=dataJson.getJSONObject("response");
JSONArray data=response.getJSONArray("data");
JSONObject info=data.getJSONObject(0);
String province=info.getString("province");
String city=info.getString("city");
String district=info.getString("district");
String address=info.getString("address");
System.out.println(province+city+district+address);
『叁』 java校验json格式及内容
代码如下
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
public class JsonValidator {
private CharacterIterator it;
private char c;
private int col;
public JsonValidator(){
}
/**
* 验证一个字符串是否是合法的JSON串
*
* @param input 要验证的字符串
* @return true-合法 ，false-非法
*/
public boolean validate(String input) {
input = input.trim();
boolean ret = valid(input);
return ret;
}
private boolean valid(String input) {
if ("".equals(input)) return true;
boolean ret = true;
it = new StringCharacterIterator(input);
c = it.first();
col = 1;
if (!value()) {
ret = error("value", 1);
} else {
skipWhiteSpace();
if (c != CharacterIterator.DONE) {
ret = error("end", col);
}
}
return ret;
}
private boolean value() {
return literal("true") || literal("false") || literal("null") || string() || number() || object() || array();
}
private boolean literal(String text) {
CharacterIterator ci = new StringCharacterIterator(text);
char t = ci.first();
if (c != t) return false;
int start = col;
boolean ret = true;
for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {
if (t != nextCharacter()) {
ret = false;
break;
}
}
nextCharacter();
if (!ret) error("literal " + text, start);
return ret;
}
private boolean array() {
return aggregate('[', ']', false);
}
private boolean object() {
return aggregate('{', '}', true);
}
private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {
if (c != entryCharacter) return false;
nextCharacter();
skipWhiteSpace();
if (c == exitCharacter) {
nextCharacter();
return true;
}
for (;;) {
if (prefix) {
int start = col;
if (!string()) return error("string", start);
skipWhiteSpace();
if (c != ':') return error("colon", col);
nextCharacter();
skipWhiteSpace();
}
if (value()) {
skipWhiteSpace();
if (c == ',') {
nextCharacter();
} else if (c == exitCharacter) {
break;
} else {
return error("comma or " + exitCharacter, col);
}
} else {
return error("value", col);
}
skipWhiteSpace();
}
nextCharacter();
return true;
}
private boolean number() {
if (!Character.isDigit(c) && c != '-') return false;
int start = col;
if (c == '-') nextCharacter();
if (c == '0') {
nextCharacter();
} else if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
if (c == '.') {
nextCharacter();
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
if (c == 'e' || c == 'E') {
nextCharacter();
if (c == '+' || c == '-') {
nextCharacter();
}
if (Character.isDigit(c)) {
while (Character.isDigit(c))
nextCharacter();
} else {
return error("number", start);
}
}
return true;
}
private boolean string() {
if (c != '"') return false;
int start = col;
boolean escaped = false;
for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {
if (!escaped && c == '\\') {
escaped = true;
} else if (escaped) {
if (!escape()) {
return false;
}
escaped = false;
} else if (c == '"') {
nextCharacter();
return true;
}
}
return error("quoted string", start);
}
private boolean escape() {
int start = col - 1;
if (" \\\"/bfnrtu".indexOf(c) < 0) {
return error("escape sequence \\\",\\\\,\\/,\\b,\\f,\\n,\\r,\\t or \\uxxxx ", start);
}
if (c == 'u') {
if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())
|| !ishex(nextCharacter())) {
return error("unicode escape sequence \\uxxxx ", start);
}
}
return true;
}
private boolean ishex(char d) {
return "0123456789abcdefABCDEF".indexOf(c) >= 0;
}
private char nextCharacter() {
c = it.next();
++col;
return c;
}
private void skipWhiteSpace() {
while (Character.isWhitespace(c)) {
nextCharacter();
}
}
private boolean error(String type, int col) {
System.out.printf("type: %s, col: %s%s", type, col, System.getProperty("line.separator"));
return false;
}
public static void main(String[] args){
String jsonStr = "{\"website\":\"open-open.com\"}";
System.out.println(jsonStr+":"+new JsonValidator().validate(jsonStr));
}
}
『肆』 java后端怎么发送json文件给客户端
可以使用以下消闭方法将JSON文件发送给客户端：
1. 将JSON文件读取为字符串，例如：
```
String jsonString = new String(Files.readAllBytes(Paths.get("path/to/jsonFile.json")));
```
2. 将字符串设置为响应体，设置响应头为JSON格式，例如薯冲：
```
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
response.getWriter().write(jsonString);
```
3. 发拿手裂送响应，例如：
```
response.flushBuffer();
```
另外还可以使用一些框架，如Spring MVC的`@ResponseBody`注解，可以将JSON对象或实体类自动转换为JSON格式发送给客户端。
『伍』 如何java解析json数组
packagejava_email.demo;
importcom.google.gson.JsonArray;
importcom.google.gson.JsonObject;
importcom.google.gson.JsonParser;
publicclassReadJSON{
publicstaticvoidmain(Stringargs[]){
JsonParserparser=newJsonParser();//创建JSON解析器
Stringjson="{"title":"创建语音","content":[{"labels":["很好看","很好吃"],"voiceUrl":"/voice/1323423.pcm","voiceText":"很好","createDate":"2018-06-1114:29:43"},{"labels":["很好看1","很好吃"],"voiceUrl":"/voice/1323423.pcm","voiceText":"很好","createDate":"2018-07-2614:30:43"}],"enterpriseId":"20180726"}";
JsonObjectobject=(JsonObject)parser.parse(json);//创建JsonObject对象
System.out.println("title="+object.get("title"));//
System.out.println("enterpriseId="+object.get("enterpriseId"));
JsonArrayarray=object.get("content").getAsJsonArray();//得到为json的数组
System.out.println("content="+array);
for(inti=0;i<array.size();i++){
JsonObjectsubObject=array.get(i).getAsJsonObject();
System.out.println("labels="+subObject.get("labels"));
System.out.println("createDate="+subObject.get("createDate"));
}
}
}
『陆』 JAVA中json读取数组的方法
Java语言复以JSON的官方制库和JSON-lib库来写
取likes是
Stringt=转义后的{"initial":"R","name":"reiz","likes":["JavaScript","Skiing","ApplePie"]}
JSONObjectjo=newJSONObject(t);//json-lib中是jo=JSONObject.fromObject(t);
JSONArraylikes=jo.getJSONArray("likes");//得到likes数组
System.out.prinlnt(like.getString(2));//打印ApplePie
『柒』 java怎么处理json格式数据
json数据：sTotalString = {"message":"success","result":[{"surveyid":"1","surveyname":"B"}{surveyid":"2","surveyname":"C"}]};
json数据：sTotalString = {"message":"success","result":[{"surveyid":"1","surveyname":"B"}{surveyid":"2","surveyname":"C"}]};
『捌』 java如何返回json格式
publicstaticvoidreturnJson(HttpServletResponseresponse,CharSequencetext)
throwsException{
response.setContentType("application/json;charset=UTF-8");
response.setHeader("Cache-Control","no-store");
response.setHeader("Pragrma","no-cache");
response.setDateHeader("Expires",0);
response.getWriter().write(text.toString());
}
其中text这个是JSONObject或者Map
response.setContentType("application/json;charset=UTF-8");这个表示以json格式返回
前台需要eval接收到的版数据，就是权json格式了
『玖』 java对接第三方接口json数据异常如何检验
1、检查JSON数据格式是否正确。可以使用在线JSON格式验证工具或者JSON编辑器等工具对返回的JSON数据进行检验，确保JSON数据的格式符合标准格式要求。
2、检查JSON数据中的键值对是否匹配。在解析JSON数据时，需要确保JSON数据中的键值对与程序中定义的键值对匹橡世配，例如，如果程序定义了一个名为“name”的键，但是返回的JSON数据中没有这个键，就会导致解析JSON数据时出现异常。
3、检查JSON数据类型是否匹配。在解析JSON数据时，需要确保JSON数据中的各个键对应的值的类型与程序中定义的类型匹配。例如，如果程序定义了一个名为“age”的键，并且类型为整数类型，但是返回的JSON数据中“age”对应的值是一个字符串类型，就会导致解析JSON数据时出现异常。
4、检查程序中的JSON解析代码梁卖肢是否正确。在解析JSON数据时，需要确保程序中的JSON解析代码正确无误，例如，使用了正确的JSON解析库和正确的解析方法。
5、检查网络连接是否正常。如果在解析JSON数据时出现异常，有可能是网络连接出现了问题，需要检查网络连接是否配巧正常。
『拾』 java中使用json传递数据，丢失精度了，求各位大神指点一二一下如何解决json精度问题
把你传的数值类型数据转成字符串再传递就行了
现在是
{"dt":"1 ","evaporate":2,"rainfall":2.5999999046325684}
改成
{"dt":"1 ","evaporate":2,"rainfall":"2.5999999046325684"}
如果类rainwater是你自己回定义的，就比答较简单了，吧Rainfall属性的类型从double改成String
如果不是就只能在数据转json前先遍历整个集合，然后转字段类型了