- 添加依赖
implementation'com.google.code.gson:gson:2.8.6'
- 1、数组序列化与反序列化
public class ArrayUnitTest {
//数据Gson序列化和反序列化
@Test
public void testArray(){
User2[] user2 = new User2[3];
//Java对象数组
user2[0] = new User2("big","18","male");
user2[1] = new User2("pig","19","female");
user2[2] = new User2("google","19","unknown");
Gson gson = new Gson();
String json = gson.toJson(user2);
System.out.println("数组序列化后的结果为："+json);
//注意此处，后面的类型为User2[].class，数组类型
User2[] user2s = gson.fromJson(json,User2[].class);
System.out.println("反序列化后的数据:"+user2s[0]);
System.out.println("反序列化后的数据:"+user2s[1]);
System.out.println("反序列化后的数据:"+user2s[2]);
}
}
输出结果为：
数组序列化后的结果为：[{"name":"big","age":"18","sex":"male"},{"name":"pig","age":"19","sex":"female"},{"name":"google","age":"19","sex":"unknown"}]
反序列化后的数据:User2{name='big', age='18', sex='male'}
反序列化后的数据:User2{name='pig', age='19', sex='female'}
反序列化后的数据:User2{name='google', age='19', sex='unknown'}
- 2、关键字序列化，如果序列化的字段中含有class、public关键字
第一步，使用@SerializedName注解来处理需要序列化的成员变量
public class ControlBean {
//使用 @SerializedName注解来处理
@SerializedName("class")
private int cls;
//使用 @SerializedName注解来处理
@SerializedName("public")
private int open;
public ControlBean(int cls, int open) {
this.cls = cls;
this.open = open;
}
public int getCls() {
return cls;
}
public void setCls(int cls) {
this.cls = cls;
}
public int getOpen() {
return open;
}
public void setOpen(int open) {
this.open = open;
}
@Override
public String toString() {
return "ControlBean{" +
"cls=" + cls +
", open=" + open +
'}';
}
}
第二步，开始序列化：
@Test
public void controlKeyTest(){
ControlBean bean = new ControlBean(1,2);
Gson gson = new Gson();
String json = gson.toJson(bean);
//实现了替换的作用
System.out.println("序列化后的数据为："+json);
}
序列化后的结果为：
序列化后的数据为：{"class":1,"public":2}
- 3、单个类序列化和类嵌套序列化
3.1单个类序列化：
//单个类序列化与反序列化
@Test
public void testGson2(){
User2 user2 = new User2("big","19","男");
Gson gson = new Gson();
String json = gson.toJson(user2);
System.out.println("序列化的数据为："+json);
User2 user21 = gson.fromJson(json, User2.class);
System.out.println("反序列化的数据为："+user21.toString());
}
结果为：
序列化的数据为：{"name":"big","age":"19","sex":"男"}
反序列化的数据为：User2{name='big', age='19', sex='男'}
3.2类嵌套序列化：
//类嵌套序列化与反序列化
@Test
public void testGson(){
User user = new User("bigzing","18","male");
Job job = new Job("10000","3"); //Job类是User的成员属性之一
user.setJob(job);
Gson gson = new Gson();
String json = gson.toJson(user);
System.out.println("序列化的数据为："+json);
User user1 = gson.fromJson(json, User.class);
System.out.println("反序列化后数据为："+user1.toString());
}
序列化结果为：
序列化的数据为：{"name":"bigzing","age":"18","sex":"male","job":{"salary":"10000","year":"3"}}
反序列化后数据为：User{name='bigzing', age='18', sex='male', job=Job{salary='10000', year='3'}}
-4、List序列化
@Test
public void testListObject(){
List list = new ArrayList<>();
list.add(new User2("big","18","male"));
list.add(new User2("pig","18","female"));
Gson gson = new Gson();
String json = gson.toJson(list);
System.out.println("序列化后的数据为:"+json);
//反序列化，因为有泛型擦除的影响，导致反序列化的时候不能直接传List.class,要采用Type的形式
Type type = new TypeToken>(){}.getType();
List list1 = gson.fromJson(json,type);
System.out.println("反序列化后的数据为："+list1.get(0).getName());
System.out.println("反序列化后的数据为："+list1.get(1).getName());
}
序列化后的结果为:
序列化后的数据为:[{"name":"big","age":"18","sex":"male"},{"name":"pig","age":"18","sex":"female"}]
反序列化后的数据为：big
反序列化后的数据为：pig
- 5、Map和Set集合序列化与反序列化
5.1 Map集合序列化与反序列化:
@Test
public void mapGsonTest(){
Map map = new HashMap<>();
map.put("1",new User2("big","18","male"));
map.put("2",new User2("pig","18","female"));
Gson gson = new Gson();
String json = gson.toJson(map);
System.out.println("map序列化后的数据为："+json);
//反序列化，和前面list集合一样，都有泛型擦除的影响，所以要使用type来处理
Type type = new TypeToken>(){}.getType();
Map map1 = gson.fromJson(json, type);
System.out.println("反序列化后的数据为:"+map1.get("1").getName());
System.out.println("反序列化后的数据为:"+map1.get("2").getName());
}
结果为：
map序列化后的数据为：{"1":{"name":"big","age":"18","sex":"male"},"2":{"name":"pig","age":"18","sex":"female"}}
反序列化后的数据为:big
反序列化后的数据为:pig
5.2 Set集合序列化和反序列化
@Test
public void setGsonTest(){
//HashSet结构的数据序列化之后，和List集合序列化之后出来的数据是一模一样的，所以反序列化的时候要使用List集合来接收
Set set = new HashSet<>();
set.add(new User2("big","18","male"));
set.add(new User2("pig","18","female"));
Gson gson = new Gson();
String json = gson.toJson(set);
System.out.println("set集合序列化后为:"+json);
//反序列化，和List集合一样，由于泛型擦除(Java在编译生成Json数据的时候，会抹除掉泛型)的影响，要使用Type
//可以反序列化为一个List集合
Type type = new TypeToken>(){}.getType();
List set1 = gson.fromJson(json,type);
System.out.println("反序列化后的数据为："+set1.get(0).getName());
System.out.println("反序列化后的数据为："+set1.get(1).getName());
//如果是非要反序列化为Set集合，要使用迭代器
Type type1 = new TypeToken>(){}.getType();
Set set2 = gson.fromJson(json,type1);
//迭代器，遍历打印
Iterator iterator = set2.iterator();
while (iterator.hasNext()){
User2 user2 = iterator.next();
System.out.println("反序列化Set:"+user2.getName());
}
}
最终结果为：
set集合序列化后为:[{"name":"big","age":"18","sex":"male"},{"name":"pig","age":"18","sex":"female"}]
反序列化后的数据为：big
反序列化后的数据为：pig
反序列化Set:big
反序列化Set:pig
- 6、变量值为Null的时候序列化
//变量值为null的，使用Gson如何序列化与反序列化
//1.集合和数组里面的元素如果为Null,Gson是不会忽略的
//2.类的成员变量为null的时候，Gson序列化时会忽略掉这个属性，不会将其序列化
@Test
public void testNull(){
User user = new User("big","18",null);
user.setJob(null);
Gson gson = new Gson();
String json = gson.toJson(user);
System.out.println("序列化后的数据为："+json);
}
结果是:
序列化后的数据为：{"name":"big","age":"18"}
可以看出只有两个字段
- 额外补充：
Gson在对Bean在序列化和反序列化时，所有的成员变量都是默认均可以的，若是要加以控制，这可以采取下面的方法:
//默认类型会参与序列化和反序列化
@Expose
private String name;
@Expose
private String age;
@Expose
private String sex;
//加上@Expose可以在里面单独指定能序列化，不能反序列化
@Expose(serialize = true,deserialize = false)
private String salary;