Java基础 json知识点

最新推荐文章于 2022-03-04 21:04:41 发布
最新推荐文章于 2022-03-04 21:04:41 发布
阅读量255 收藏
点赞数
分类专栏： # java 文章标签： java json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l547319765/article/details/97383512
版权
这篇博客主要介绍了Jackson的使用，包括注解、依赖配置、对象映射、时间格式化、非空字段处理等，并介绍了如何访问非默认路径下的静态页面。接着简单提到了Fastjson，推荐了一个详细的CSDN文章链接供读者深入学习。
摘要由CSDN通过智能技术生成
jackjson

  1. jackson在springboot的使用
    1.1 各种注解的使用

    • 返回结果测试
      @JsonIgnore：json序列化时忽略，可用于密码
      @JsonProperty()：json序列化时，取一个别名
      @JsonFormat(pattern=“yyyy-MM-dd hh:mm:ss”,local=“zh”,timezone=“GMT+8”):用于规范时间格式
      @JsonInclude(Include.NOT_NULL) :json字段不为空
    • 访问不是默认路径下的静态页面

    1.2 导入依赖

    	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
	</dependency>

    1.3 通过访问controller，然后进行静态页面的跳转

  2. jackson基础转载自
    2.1 jackson基本实现类：ObjectMapper

    import java.io.IOException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;

public class JacksonTester {
   public static void main(String args[]){
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";

      //map json to student
      try {
         Student student = mapper.readValue(jsonString, Student.class);
         System.out.println(student);
         mapper.enable(SerializationConfig.Feature.INDENT_OUTPUT);
         jsonString = mapper.writeValueAsString(student);
         System.out.println(jsonString);

      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   private String name;
   private int age;
   public Student(){}
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

    2.2 将json序列化到文件以及反序列化

    	import java.io.File;
import java.io.IOException;

import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         Student student = new Student();
         student.setAge(10);
         student.setName("Mahesh");
         tester.writeJSON(student);

         Student student1 = tester.readJSON();
         System.out.println(student1);

      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   private void writeJSON(Student student) throws JsonGenerationException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();	
      mapper.writeValue(new File("student.json"), student);
   }

   private Student readJSON() throws JsonParseException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();
      Student student = mapper.readValue(new File("student.json"), Student.class);
      return student;
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

    2.3 json数据与java类型之间的转换

    import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
         try {
            ObjectMapper mapper = new ObjectMapper();
			//创建map
            Map<String,Object> studentDataMap = new HashMap<String,Object>(); 
            //创建数组
            int[] marks = {1,2,3};
			//创建学生对象
            Student student = new Student();
            student.setAge(10);
            student.setName("Mahesh");
            // JAVA Object
            studentDataMap.put("student", student);
            // JAVA String
            studentDataMap.put("name", "Mahesh Kumar");   		
            // JAVA Boolean
            studentDataMap.put("verified", Boolean.FALSE);
            // Array
            studentDataMap.put("marks", marks);

            mapper.writeValue(new File("student.json"), studentDataMap);
            //result student.json
			//{ 
            //   "student":{"name":"Mahesh","age":10},
            //   "marks":[1,2,3],
            //   "verified":false,
            //   "name":"Mahesh Kumar"
            //}
            studentDataMap = mapper.readValue(new File("student.json"), Map.class);

            System.out.println(studentDataMap.get("student"));
            System.out.println(studentDataMap.get("name"));
            System.out.println(studentDataMap.get("verified"));
            System.out.println(studentDataMap.get("marks"));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
            e.printStackTrace();
      }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

    2.4 json全数据绑定

    	import java.io.File;
import java.io.IOException;

import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         Student student = new Student();
         student.setAge(10);
         student.setName("Mahesh");
         tester.writeJSON(student);

         Student student1 = tester.readJSON();
         System.out.println(student1);

      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   private void writeJSON(Student student) throws JsonGenerationException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();	
      mapper.writeValue(new File("student.json"), student);
   }

   private Student readJSON() throws JsonParseException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();
      Student student = mapper.readValue(new File("student.json"), Student.class);
      return student;
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

    2.5 Jackson数据绑定泛型

    import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
         try {
            ObjectMapper mapper = new ObjectMapper();

            Map userDataMap = new HashMap();
            UserData studentData = new UserData(); 
            int[] marks = {1,2,3};

            Student student = new Student();
            student.setAge(10);
            student.setName("Mahesh");
            // JAVA Object
            studentData.setStudent(student);
            // JAVA String
            studentData.setName("Mahesh Kumar");
            // JAVA Boolean
            studentData.setVerified(Boolean.FALSE);
            // Array
            studentData.setMarks(marks);
            TypeReference ref = new TypeReference>() { };
            userDataMap.put("studentData1", studentData);
            mapper.writeValue(new File("student.json"), userDataMap);
            //{
            //   "studentData1":
            //	 {
            //		"student":
            //		{
            //			"name":"Mahesh",
            //			"age":10
            //      },
            //      "name":"Mahesh Kumar",
            //      "verified":false,
            //      "marks":[1,2,3]
            //   }
            //}
            userDataMap = mapper.readValue(new File("student.json"), ref);

            System.out.println(userDataMap.get("studentData1").getStudent());
            System.out.println(userDataMap.get("studentData1").getName());
            System.out.println(userDataMap.get("studentData1").getVerified());
            System.out.println(Arrays.toString(userDataMap.get("studentData1").getMarks()));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
            e.printStackTrace();
      }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

class UserData {
   private Student student;
   private String name;
   private Boolean verified;
   private int[] marks;

   public UserData(){}

   public Student getStudent() {
      return student;
   }
   public void setStudent(Student student) {
      this.student = student;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public Boolean getVerified() {
      return verified;
   }
   public void setVerified(Boolean verified) {
      this.verified = verified;
   }
   public int[] getMarks() {
      return marks;
   }
   public void setMarks(int[] marks) {
      this.marks = marks;
   }		
}

    2.6 json可创建一颗树并返回根节点

    //Create an ObjectMapper instance
ObjectMapper mapper = new ObjectMapper();	
String jsonString = "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
//create tree from JSON
JsonNode rootNode = mapper.readTree(jsonString);
// 遍历模型
JsonNode nameNode = rootNode.path("name");
System.out.println("Name: "+ nameNode.getTextValue());
JsonNode marksNode = rootNode.path("marks");
Iterator iterator = marksNode.getElements();

    2.6.1 树到JSON转换

    import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ArrayNode;
import org.codehaus.jackson.node.ObjectNode;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         ObjectMapper mapper = new ObjectMapper();

         JsonNode rootNode = mapper.createObjectNode();
         JsonNode marksNode = mapper.createArrayNode();
         ((ArrayNode)marksNode).add(100);
         ((ArrayNode)marksNode).add(90);
         ((ArrayNode)marksNode).add(85);
         ((ObjectNode) rootNode).put("name", "Mahesh Kumar");
         ((ObjectNode) rootNode).put("age", 21);
         ((ObjectNode) rootNode).put("verified", false);
         ((ObjectNode) rootNode).put("marks",marksNode);

         mapper.writeValue(new File("student.json"), rootNode);

         rootNode = mapper.readTree(new File("student.json"));

         JsonNode nameNode = rootNode.path("name");
         System.out.println("Name: "+ nameNode.getTextValue());

         JsonNode ageNode = rootNode.path("age");
         System.out.println("Age: " + ageNode.getIntValue());

         JsonNode verifiedNode = rootNode.path("verified");
         System.out.println("Verified: " + (verifiedNode.getBooleanValue() ? "Yes":"No"));

         JsonNode marksNode1 = rootNode.path("marks");
         Iterator<JsonNode> iterator = marksNode1.getElements();
         System.out.print("Marks: [ ");
         while (iterator.hasNext()) {
            JsonNode marks = iterator.next();
            System.out.print(marks.getIntValue() + " "); 
         }
         System.out.println("]");
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

    2.6.2 从树到Java对象转换

    import java.io.File;
import java.io.IOException;
import java.util.Arrays;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ArrayNode;
import org.codehaus.jackson.node.ObjectNode;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         ObjectMapper mapper = new ObjectMapper();

         JsonNode rootNode = mapper.createObjectNode();
         JsonNode marksNode = mapper.createArrayNode();
         ((ArrayNode)marksNode).add(100);
         ((ArrayNode)marksNode).add(90);
         ((ArrayNode)marksNode).add(85);
         ((ObjectNode) rootNode).put("name", "Mahesh Kumar");
         ((ObjectNode) rootNode).put("age", 21);
         ((ObjectNode) rootNode).put("verified", false);
         ((ObjectNode) rootNode).put("marks",marksNode);

         mapper.writeValue(new File("student.json"), rootNode);

         rootNode = mapper.readTree(new File("student.json"));

         Student student = mapper.treeToValue(rootNode, Student.class);

         System.out.println("Name: "+ student.getName());
         System.out.println("Age: " + student.getAge());
         System.out.println("Verified: " + (student.isVerified() ? "Yes":"No"));
         System.out.println("Marks: "+Arrays.toString(student.getMarks()));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

class Student {
   String name;
   int age;
   boolean verified;
   int[] marks;
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public boolean isVerified() {
      return verified;
   }
   public void setVerified(boolean verified) {
      this.verified = verified;
   }
   public int[] getMarks() {
      return marks;
   }
   public void setMarks(int[] marks) {
      this.marks = marks;
   }
}

    2.7 流式API
    2.7.1 写入

    import java.io.File;
import java.io.IOException;
import java.util.Map;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {        	
         JsonFactory jasonFactory = new JsonFactory();

         JsonGenerator jsonGenerator = jasonFactory.createJsonGenerator(new File(
            "student.json"), JsonEncoding.UTF8);
         // {
         jsonGenerator.writeStartObject();
         // "name" : "Mahesh Kumar"
         jsonGenerator.writeStringField("name", "Mahesh Kumar"); 
         // "age" : 21
         jsonGenerator.writeNumberField("age", 21);
         // "verified" : false
         jsonGenerator.writeBooleanField("verified", false); 
         // "marks" : [100, 90, 85]
         jsonGenerator.writeFieldName("marks"); 
         // [
         jsonGenerator.writeStartArray(); 
         // 100, 90, 85
         jsonGenerator.writeNumber(100); 
         jsonGenerator.writeNumber(90); 
         jsonGenerator.writeNumber(85); 
         // ]
         jsonGenerator.writeEndArray(); 
         // }
         jsonGenerator.writeEndObject(); 
         jsonGenerator.close();       	 

         //result student.json
         //{ 
         //   "name":"Mahesh Kumar",
         //   "age":21,
         //   "verified":false,
         //   "marks":[100,90,85]
         //}
         ObjectMapper mapper = new ObjectMapper();
         Map<String,Object> dataMap = mapper.readValue(new File("student.json"), Map.class);

         System.out.println(dataMap.get("name"));
         System.out.println(dataMap.get("age"));
         System.out.println(dataMap.get("verified"));
         System.out.println(dataMap.get("marks"));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

    2.7.2 使用JsonParser 读取JSON

    import java.io.File;
import java.io.IOException;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonToken;
import org.codehaus.jackson.map.JsonMappingException;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {        	
         JsonFactory jasonFactory = new JsonFactory();

         JsonGenerator jsonGenerator = jasonFactory.createJsonGenerator(new File(
            "student.json"), JsonEncoding.UTF8);
         jsonGenerator.writeStartObject();
         jsonGenerator.writeStringField("name", "Mahesh Kumar"); 
         jsonGenerator.writeNumberField("age", 21);
         jsonGenerator.writeBooleanField("verified", false); 
         jsonGenerator.writeFieldName("marks"); 
         jsonGenerator.writeStartArray(); // [
         jsonGenerator.writeNumber(100); 
         jsonGenerator.writeNumber(90); 
         jsonGenerator.writeNumber(85); 
         jsonGenerator.writeEndArray(); 
         jsonGenerator.writeEndObject(); 
         jsonGenerator.close();       	 

         //result student.json
         //{ 
         //   "name":"Mahesh Kumar",
         //   "age":21,
         //   "verified":false,
         //   "marks":[100,90,85]
         //}

         JsonParser jsonParser = jasonFactory.createJsonParser(new File("student.json"));
         while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
            //get the current token
            String fieldname = jsonParser.getCurrentName();
            if ("name".equals(fieldname)) {
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getText());        	 
            }
            if("age".equals(fieldname)){
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getNumberValue());        	 
            }
            if("verified".equals(fieldname)){
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getBooleanValue());        	 
            }
            if("marks".equals(fieldname)){
               //move to [ 
               jsonParser.nextToken();
               // loop till token equal to "]"
               while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                  System.out.println(jsonParser.getNumberValue()); 
               }
            }
         }
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}
Fastjson

转载来源：https://blog.csdn.net/srj1095530512/article/details/82529759
这个文章 fastjson讲的很清楚，而且有对应的源码分析，我就不多加总结了，有兴趣的小哥可以去看看。
下面只是单纯取出测试类以及测试代码

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
 
 
public class MyJson {
	
	public static void main(String[] args) {
		
		List<Student> list=new ArrayList<>();
		Student student=new Student("bob",24);
		Student student12=new Student("lily", 23);
		list.add(student);
		list.add(student12);
		System.out.println("*******javaBean  to jsonString*******");
		String str1=JSON.toJSONString(student);
		System.out.println(str1);
		System.out.println(JSON.toJSONString(list));
		System.out.println();
		
		System.out.println("******jsonString to javaBean*******");
		//Student stu1=JSON.parseObject(str1,new TypeReference<Student>(){});
		Student stu1=JSON.parseObject(str1,Student.class);
		System.out.println(stu1);
		System.out.println();
		
		System.out.println("******javaBean to jsonObject******");
		JSONObject jsonObject1=(JSONObject)JSON.toJSON(student);
		System.out.println(jsonObject1.getString("name"));
		System.out.println();
		
		System.out.println("******jsonObject to javaBean******");
		Student student2=JSON.toJavaObject(jsonObject1, Student.class);
		System.out.println(student2);
		System.out.println();
		
		System.out.println("*******javaBean to jsonArray******");
		List<Student> stulist=new ArrayList<>();
		for(int i=0;i<5;i++){
			stulist.add(new Student("student"+i, i));
			
		}
		JSONArray jsonArrays=(JSONArray)JSON.toJSON(stulist);
		for(int i=0;i<jsonArrays.size();i++){
		System.out.println(jsonArrays.getJSONObject(i));
		}
		System.out.println();
		
		System.out.println("*****jsonArry to javalist******");
		List<Student> myList=new ArrayList<>();
		for(int i=0;i<jsonArrays.size();i++){
			
		Student student3=JSON.toJavaObject(jsonArrays.getJSONObject(i), Student.class);
			myList.add(student3);
		}
		for(Student stu:myList){
			System.out.println(stu);
		}
		
	        System.out.println();
		
		System.out.println("*****jsonObject to jsonString*****");
		String str4=JSON.toJSONString(jsonObject1);
		System.out.println(str4);
		System.out.println();
		
		System.out.println("*******jsonString to jsonObject*****");
		JSONObject jso1=JSON.parseObject(str1);
		System.out.println(jso1.getString("name"));
		System.out.println();
		
		System.out.println("*****jsonString to jsonArray*****");
		JSONArray jArray=JSON.parseArray(JSON.toJSONString(stulist));
		for(int i=0;i<jArray.size();i++){
		System.out.println(jArray.getJSONObject(i));
		}
		System.out.println();
	}
 
}


public class Student {
	
	private String name;
	private int age;
	
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	public void setName(String name){
		this.name=name;
		
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age=age;
	}
	
	public int getAge(){
		return age;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "student [name="+name+" , "+"age="+age+"]";
	}
Little-小样
关注
专栏目录
json基础知识点
KOBEZANG的博客
05-20 300
一、什么是JSON JSON全称JavaScript Object Notation（JS对象标记），是一种轻量级的数据交换格式。它相对于XML更小、更易于人阅读和编写，同时也易于机器解析和生存，并有效地提高网络传输效率。 二、JSON数据格式 1、整体结构 String json1 = {"name" : "Jack","sex" : "男"} String json2 = [{"name" : "Jack","sex" : "男"},{"name" : "Vincent","sex
Java 开发 json 数据的jar 涉及的相关包 Java_json_lib_2.4.zip
11-11
以下是一些关于如何使用此库进行JSON操作的知识点： 1. **序列化与反序列化**： - **序列化**：将Java对象转换为JSON字符串。例如，你可以使用`net.sf.json.JSONObject.fromObject()`方法将Java对象转换成JSON对象...
JSON重要知识点
pf503603的博客
09-03 316
1.什么是JSON * JSON:(JavaScript Object Notation) 是一种轻量级的数据交换格式 他可以直接被JS所解析(JS能够直接识别) 2.JSON的作用 * 前后台的数据交互. * 安卓和后台数据交互 * 系统之间的数据交换. 3.JSON数据格式 *{“属性名”:属性值,”属性名”:属性值,…} ...
Java知识点——JSON文件
qq_42581682的博客
03-21 256
JSON 1.1 JSON格式概述 JSON JavaScript JavaScript Object Notation （JavaScript Object Notation，JavaScript对象表示法，读作/ˈdʒeɪsən/）是一种由道格拉斯·克罗克福特构想和设计、轻量级的数据交换语言，该语言以易于让人阅读的文字为基础，用来传输由属性值或者序列性的值组成的数据对象。尽管JSON是J...
json知识点
dpy521的博客
12-10 147
1） 与JavaScript的对象字面量相比，JSON对象有两个不同的地方，首先json中没有变量的概念。其次，没有末尾的分号（因为不是JavaScript语句）。对象的属性必须是双引号 ，不能是单引号。 { "name":"ding", "age":23, "school":{ "name":"Merrimarck Collage", "loc
JSON知识点
weixin_45720894的博客
04-09 103
1.json字符串 var user1 = '{ "name": "李三", "sex": "man" }'; 2.json对象 var user2= { "name": "李三", "sex": "男" }; 3.字符串转为json对象 var obj = JSON.parse(user1); 4.json对象转为字符串 var lstr=JSON.stringify(user2); 5.@ResponseBody注解：使用它就不会走视图解析器，会直接返回一个字符串 ...
Java读取本地json文件及相应处理方法
10-18
下面将详细解释相关的知识点。 首先，使用Java类加载器（ClassLoader）获取资源路径是读取本地资源文件的一种方法。代码示例中的`getClass().getClassLoader().getResource("menu.json").toString();`就是实现该...
java服务端生成json（json服务端）
03-02
总结来说，Java服务端生成JSON涉及的主要知识点包括： 1. JSON数据格式的理解及其在数据交换中的作用。 2. 使用Gson或FastJson库进行JSON序列化和反序列化。 3. 结合HTTP服务器框架处理JSON响应。 4. 调试和测试JSON...
json知识点说明.zip
02-22
除了JavaScript的内建方法外，许多编程语言（如Python、Java、C#等）都提供了相应的库来处理JSON的序列化和反序列化。 5. JSON的优缺点： 优点：轻量级、易读易写、解析速度快、支持多种编程语言，使得JSON成为...
Java解析Json.pdf
最新发布
06-09
### Java解析JSON知识点详解 #### 一、引言 在现代软件开发中，尤其是在Web应用和服务端编程领域，JSON（JavaScript Object Notation）已经成为了一种非常流行的数据交换格式。它以其简洁、轻量且易于阅读的特点，...
JSON 知识点
wangqingxun的专栏
03-03 450
文章引用自：http://www.w3school.com.cn/json/index.asp JSON：JavaScript 对象表示法（JavaScriptObject Notation）。 JSON 是存储和交换文本信息的语法。类似 XML。 JSON 比 XML 更小、更快，更易解析。 什么是 JSON ？ JSON 指的是 JavaScript 对
JSON相关知识点
天森爱自由
05-26 543
JSON是工作中经常会遇到的一种数据结构，下面来讲讲与他相关的一些知识点。JSON简介：JSON: JavaScript Object Notation(JavaScript 对象表示法) JSON 是存储和交换文本信息的语法,类似 XML。 JSON 比 XML 更小、更快，更易解析。JSONObject与JSONArray的使用：Json有两种结构：JSONObject与JSONArray。
json知识点整理
strayyiyi的博客
02-04 673
JSON的全称是javascript object notation （javascript对象表示法） 在json的名称-值对中，名称始终被双引号包裹 json的媒体类型是application/json json中的数据类型包括：对象、字符串、数字、布尔值、null和数组 json值中如有双引号，加反斜线来进行转义。 反斜线需要另一个反斜线来转义 在
Json知识点学习
静水流深
12-20 363
前言 无论是前端解析后端的数据还是做全栈的技术需要，你都可能多少需要知道些json的技术点，从json的标准格式到json的格式转换与传输，再到中转的处理。本文小编与你一起回顾json的最强知识点攻略。 概念 javascript的对象表示法（javascript object notation）.json是用于存储和交换文本信息的语法，类似于xml，但是比xml更小、更快、更易解析。 语
Json知识点详解
supershuyun的博客
02-03 699
一、json是什么？ 直白点Json就是一种前后端进行数据交换的格式，就是一串字符串。 json原本是javascript里的内容，有时后端要传各种各样的数据格式来适应前端，所以需要用到json来转换，用它来表示各种各样复杂的数据，如对象，数组，集合，以及集合的集合等数据。 格式：{} 双括号表示对象，[] 中括号表示数组，”” 双引号内是属性或值，: 冒号表示后者是前者的值(这个值可以是字符串、数字、也可以是另一个数组或对象)。 二、为什么要用json? 服务端传递这种格式的数据，客户端js可.
JSON知识点梳理
zhoudawei1995的博客
09-22 307
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 JSON是一种轻量化的数据编码方式它不依赖于编程语言是独立的文本格式。和xml相比JSON具有格式简洁，转译速度快的特点，因此现在被广泛使用。JSON的本质是字符串，采用了特定的分隔方式对字符串进行分隔。 提示：以下是本篇文章正文内容，下面案例可供参考 一、JSON的语法 JSON对象语法有对象、数组和二者混合等方式。 1、对象语法 JSON对象的属性储存类似于键...
12、java中JSON知识
ANDY___Q的博客
09-15 153
一、JSON的简介 （多用于单纯的前后端数据交换） JSON：轻量级的文本数据交换样式 具有自我描述性 比XML文件传输速度快 JSON最初用来表示JavaScript中的对象。但目前已独立于JavaScript成为最常用的数据格式之一 JSON语法规则： 两种数据结构：数组和对象 大括号內是为对象，中括号为数组 对象中的数据由名称/值对构成 值的类型可分为字符串、数字、布尔值、null、数组、对象 数据之间用逗号隔开 数组中的数据类型同名称/值对中值的类型 FastJson简介： 由阿里开源的JSON解析
JSON 基础知识点梳理
CodeDoraemon的博客
03-04 8063
文章目录1、什么是JSON2、JSON 的作用3、JSON 的基础语法4、JSON 和 Java 对象的转换4.1 转换代码 1、什么是JSON JavaScript Object Notation JavaScript 对象表示法 2、JSON 的作用 语法简单，层次结构是比较鲜明的，多用于数据的载体，在网络中进行数据的传输 3、JSON 的基础语法 <script> // 定义 JSON var json = {
java基础知识点大全
04-02
Java基础知识点大全包括以下内容： 1. Java语言概述 2. Java环境搭建 3. Java基本语法 4. 数据类型 5. 变量 6. 运算符 7. 控制流程 8. 数组 9. 方法 10. 类与对象 11. 继承与多态 12. 接口 13. 异常处理 14. 文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值