String字符串，FastJson常用操作方法

JSON字符串操作

1、创建配置环境

# 引入测试包
	testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.2.6.RELEASE'
# 创建测试类
	@RunWith(SpringRunner.class)
	@SpringBootTest
	public class JsonTest {
    @Test
    public void test(){
        System.out.println("xxxxxxx");
    }
}

• 注意

  测试的时候需要更改一下idea的设置
  

2、FastJson简介

# FastJson简介
	FastJson是将Java对象转为JSON格式字符串的过程，JavaBean对象，List集合对象，Map集合应用最为广泛。
	

3、序列化

# Json的数组形式
	jsonStr = ['0','1','2','3',4]

• 测试

  @Test
  public void test(){
    // 创建数组
    String arr [] =  {"a", "b", ""};
    // 将数组转为JSON形式
    Object json = JSON.toJSON(arr);
    System.out.println("json = " + json);
  }
  

  

# 序列化：将Java对象转为JSON字符串的过程

• JSON.toJSONString(序列化java对象)

      @Test
      public void test(){
          Student student = new Student();
          student.setUserName("范浩然");
          student.setAge(12);
          student.setClassName("初二1班");
          // 将javaBean对象序列化
          String studentInfo = JSON.toJSONString(student);
          System.out.println("studentInfo = " + studentInfo);
          // 打印对象信息
          System.out.println("student = " + student);
      }
  

  

      @Test
      public void test1(){
          Student student = new Student();
          student.setUserName("范浩然");
          student.setAge(12);
          student.setClassName("初二1班");
          // 序列化集合信息
          List<Student> studentList = new ArrayList<>();
          studentList.add(student);
          // 序列化集合信息
          String students = JSON.toJSONString(studentList);
          System.out.println("students = " + students);
      }
  

  

      @Test
      public void test2(){
          Student student = new Student();
          student.setUserName("范浩然");
          student.setAge(12);
          student.setClassName("初二1班");
          HashMap<String, Student> studentMap = new HashMap<>();
          studentMap.put("1",student);
          // 序列化HashMap
          String studentInfo = JSON.toJSONString(studentMap);
          System.out.println("studentInfo = " + studentInfo);
          
      }
  

  

4、反序列化

    @Test
    public void test3(){
        //  反序列化 将Json字符串反序列化为Java对象
        String str = "{\"age\":12,\"className\":\"初二1班\",\"userName\":\"范浩然\"}";
        // 第一个参数 反序列化的字符串，Java对象的Class对象
        Student student =  JSON.parseObject(str, Student.class);
        System.out.println("student = " + student);


        //  json对象转为数组
        String str3 = " [{\"age\":12,\"className\":\"初二1班\",\"userName\":\"范浩然\"}]";
        List<Student> studentList = JSON.parseArray(str3, Student.class);
        studentList.forEach(item ->{
            System.out.println(item);
        });

        // json字符串转为集合 转换后集合泛型的class
        String str2 = "{\"1\":{\"age\":12,\"className\":\"初二1班\",\"userName\":\"范浩然\"}}";
        // 第一个参数 字符串
        // 直接进行反序列化 Map集合是没有泛型的，没有泛型的集合是不安全的，转换后的集合必须具有泛型，
        // 调用parseObject传递参数，TypeReference类型，在TypeReference类的泛型中，传递转后的Map集合
       Map<String,Student> map = JSON.parseObject(str2,new TypeReference<Map<String,Student>>(){});
        // 遍历Map
        map.entrySet().stream().forEach(item->{
            // 遍历键值对
            System.out.println("key:"+item.getKey());
            System.out.println("value:"+item.getValue());
        });

    }

5、枚举介绍

 @Test
    public void test4(){
        // 枚举介绍 是进行序列化时 自己可以定义一些特殊的需求
        // toJSONString()
        // 参数一:要序列化的对象
        // 参数二:SerializerFeature枚举类型的可变参数
        // 常见的方法
        // 1.序列化Null值的字段
        Student student = new Student();
        student.setClassName("高三一班");
        student.setBirthday(new Date());
        String studentInfo1 = JSON.toJSONString(student);
        System.out.println("studentInfo1 = " + studentInfo1);

        // 序列化空字段
        String studentInfo2 = JSON.toJSONString(student, SerializerFeature.WriteMapNullValue);
        System.out.println("studentInfo2 = " + studentInfo2);
        // 序列化字段把值序列化为双引号
        String studentInfo3 = JSON.toJSONString(student, SerializerFeature.WriteNullStringAsEmpty);
        System.out.println("studentInfo3 = " + studentInfo3);
        // 字段为空的时候 序列化为0
        String studentInfo4 = JSON.toJSONString(student, SerializerFeature.WriteNullNumberAsZero);
        System.out.println("studentInfo4 = " + studentInfo4);
        // 序列化 布尔值为null 序列化为false
        String studentInfo5 = JSON.toJSONString(student, SerializerFeature.WriteNullBooleanAsFalse);
        System.out.println("studentInfo5 = " + studentInfo5);
        // 序列化日期
        String studentInfo6 = JSON.toJSONString(student, SerializerFeature.WriteDateUseDateFormat);
        System.out.println("studentInfo6 = " + studentInfo6);
        // 格式化字符串可以接收多个
        String s = JSON.toJSONString(student, SerializerFeature.WriteNullNumberAsZero,
                                              SerializerFeature.WriteNullBooleanAsFalse,
                                              SerializerFeature.PrettyFormat);
        System.out.println("s = " + s);
    }

6、JSONField注解的使用

1、注解

# 若属性是私有的，必须有set方法，否则无法序列化、
	1.JSONField可以作用于get/set方法上面
	2.配置在字段上面

2、作用于字段上面

    @JSONField(name = "username")
    private String userName;

    @Test
    public void test5(){
        Student student = new Student();
        student.setUserName("范浩然");
        student.setClassName("高三一班");
        String studentInfo = JSON.toJSONString(student);
        System.out.println(studentInfo);
    }

3、格式化日期时间

#  使用JSONField格式化日期时间

    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;


    @Test
    public void test6(){
        Student student = new Student();
        // 赋值时间数据
        student.setCreateTime(new Date());
        // 转为JSON字符串
        String studentInfo = JSON.toJSONString(student);
        System.out.println("studentInfo = " + studentInfo);
    }

4、指定字段不序列化

# 可以指定某些字段不序列化
	1.serialize = false/deserialize

    /**
     * 指定年龄这个字段不序列化
     */
    @JSONField(serialize = false)
    private Integer age;
    
    @Test
    public void test7(){
        Student student = new Student();
        // 虽然给年龄赋值了 但是指定了年龄不序列化 所以结果中年龄只有姓名
        student.setAge(32);
        student.setUserName("张三");
        String studentInfo = JSON.toJSONString(student);
        System.out.println("studentInfo = " + studentInfo);
        
    }

5、指定字段顺序

# 可以指定某些字段的一个序列化的顺序
	1.ordinal

    @JSONField(name = "username",ordinal = 1)
    private String userName;
    @JSONField(format = "yyyy-MM-dd HH:mm:ss",ordinal = 0)
    private Date createTime;

		// 首先序列化 创建时间 在序列化姓名
    @Test
    public void test8(){
        Student student = new Student();
        student.setUserName("范浩然");
        student.setCreateTime(new Date());
        String studentInfo = JSON.toJSONString(student);
        System.out.println("studentInfo = " + studentInfo);
    }

6、自定义序列化内容

# 在fastjson 1.2.16版本之后，JSONField支持新的定制化配置serializeUsing，可以单独对某个类的某个属性定制序列化、反序列化。

指定自定义序列化的内容

    /**
     * 指定自定义序列化字段
     */
    @JSONField(serializeUsing = StudentTypeSerializable.class)
    private Boolean status;

创建实现序列化内容的类

/**
 * @author hrFan
 * @version 1.0
 * @description: 自定义序列化内容
 * @date 2022/5/9 星期一
 */
public class StudentTypeSerializable implements ObjectSerializer {
    /**
     *
     * @param serializer 序列化器
     * @param object 字段的值
     * @param fieldName 字段的名称
     * @param fieldType 字段的类型
     * @param features 特征
     * @throws IOException
     */
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        // 获取字段的值
        Boolean isStatus = (Boolean) object;
        // 判断字段的值
        String text = "";
        if (isStatus = false){
            text  = "未启用";
        }else {
            text = "已启用";
        }
        // 进行序列化
        serializer.write(text);
    }
}

测试

    @Test
    public void test9(){
        Student student = new Student();
        // 设置字段的值
        student.setStatus(false);
        String studentInfo = JSON.toJSONString(student);
        System.out.println("studentInfo = " + studentInfo);
    }

7、自定义反序列化内容

指定反序列化字段

    /**
     * 指定自定义序列化字段
     */
    @JSONField(deserializeUsing = StudentTypeDeSerializable.class)
    private Boolean status;

创建反序列化内容的类

/**
 * @author hrFan
 * @version 1.0
 * @description: 自定义序列化内容
 * @date 2022/5/9 星期一
 */
public class StudentTypeDeSerializable implements ObjectDeserializer {
    /**
     *
     * @param parser Json解析器
     * @param type 字段类型
     * @param fieldName 字段名称
     * @return 反序列化完成的内容
     */
    @Override
    public Boolean deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
        String isUse = "已启用";
        // 获取反序列化的值
        String status = parser.getLexer().stringVal();
        Boolean b = false;
        if (isUse.equals(status)){
            b = true;
        }
        // 返回字段的类型信息
        return b;
    }

    @Override
    public int getFastMatchToken() {
        return 0;
    }
}

测试

    @Test
    public void test10(){
        // 自定义序列化的内容
        String studentInfo = "{\"status\":\"已启用\"}";
        Student student = JSON.parseObject(studentInfo, Student.class);
        System.out.println("student = " + student);
    }

3、String字符串操作

1、isBlank(判断字符串是否为空)

# isBlank 空格是非空
	1.包含的有空串("")、空白符(空格""，"  "，制表符"\t"，回车符"\r"，"\n"等)以及null值；

    @Test
    public void test1(){
        // 如果为空 返回true 不为空返回false
        System.out.println("空格 ： " + StringUtils.isBlank(" "));
        System.out.println("字符 ： " + StringUtils.isBlank("s"));
        System.out.println("制表位 ： " + StringUtils.isBlank("\t"));
    }

2、remove(移除字符)

 # 移除单个字符,也可以是字符串
 	StringUtils.remove(String str, char remove)
 	StringUtils.remove(String str, String remove);
 # 移除开头/结尾匹配的字符序列
 	StringUtils.removeStart(String str, String remove);
	StringUtils.removeStartIgnoreCase(String str, String remove);
	StringUtils.removeEnd(String str, String remove);
	StringUtils.removeEndIgnoreCase(String str, String remove);

1、移除单个字符串

    @Test
    public void test2(){
        String str = "test";
        // 第一个参数 操作的字符串
        // 第二个参数 匹配删除的字符
        String afterStr = StringUtils.remove(str, "t");
        // 原字符串并不会被修改 
        System.out.println("afterStr = " + afterStr);
    }

2、移除匹配的字符串

    @Test
    public void test3(){
        String str = "testtesttestest";
        // 移除某个字符串
        String afterStr = StringUtils.remove(str, "es");
        System.out.println("afterStr = " + afterStr);
    }

3、移除首尾匹配的字符串

    @Test
    public void test4(){
        // 移除开头或者结尾匹配的字符序列
        String str = "ABCDEFG";
        String afterStr1 = StringUtils.removeStart(str, "ab");
        String afterStr2 = StringUtils.removeEnd(str, "fg");
        System.out.println("-------------------------------------------------");
        // 删除忽略大小写
        String afterStr3 = StringUtils.removeStartIgnoreCase(str, "ab");
        String afterStr4 = StringUtils.removeEndIgnoreCase(str, "fg");
        System.out.println("afterStr1 = " + afterStr1);
        System.out.println("afterStr2 = " + afterStr2);
        System.out.println("afterStr3 = " + afterStr3);
        System.out.println("afterStr4 = " + afterStr4);
    }

3、trim(去除首尾空白)

    @Test
    public void test5(){
        String str = " demo ";
        System.out.println("str = " + str);
        // 去除首尾空白的字符
        String afterStr = StringUtils.trim(str);
        System.out.println("afterStr = " + afterStr);
    }

4、strip(去掉首尾匹配字符)

    @Test
    public void test6(){
        String str = "[demoomed]";
        System.out.println("str = " + str);
        // 去除首尾的[]
        // 应用的比较广泛
        String stripStr = StringUtils.strip(str, "[]");
        System.out.println("stripStr = " + stripStr);
        
    }

5、replace(替换)

# 注意
	若被替换的字符串为null，或者被替换的字符或字符序列为null，又或者替换的字符或字符序列为null
	此次替换都会被忽略，返回原字符串；

# 替换单个字符或字符序列 
	replace(String text, String searchString, String replacement);
	replace(String text, String searchString, String replacement, int max);max是指替换最大次数，0：不替换，-1：全部替换
	replaceChars(String str, char searchChar, char replaceChar);
	replaceChars(String str, String searchChars, String replaceChars);
# 只会替换一次，后面即使匹配也不替换
	replaceOnce(String text, String searchString, String replacement);
# 指定位置进行字符序列替换，从start索引处开始(包含)到end-1索引处为止进行替换
	overlay(String str,String overlay,int start,int end);    
# 可以同时替换多个字符序列，一一对应但被替换和替换的字符序列的个数应该对应，否则会报IllegalArgumentException
	replaceEach(String text, String[] searchList, String[] replacementList);
	StringUtils.replaceEach("test", new String[] { "t", "e" }, new String[] { "T", "E" });
	StringUtils.replaceEach("test", null, new String[] { "T", "E" });
	test (存在null，不进行替换)
# IllegalArgumentException (被替换和替换的个数不对应)	     
	StringUtils.replaceEach("test", new String[] { "t", "e" }, new String[] { "T", "E", "X" }); 
# 循环替换--了解即可
	replaceEachRepeatedly(String text, String[] searchList, String[]replacementList);
	StringUtils.replaceEachRepeatedly("test", new String[] { "e", "E" }, new String[] { "E", "Y" }); 
	tYst (e被替换为E，E又被替换为Y)

1、(replace)替换单个字符或者字符序列

    @Test
    public void test7(){
        String str = "abc123abc";
        // 第一个参数 源字符串 第二个参数 需要替换的字符 三个参数 需要替换的字符串
        // 第四个参数 max是指替换最大次数，0：不替换，-1：全部替换
        String replaceStr1 = StringUtils.replace(str, "abc", "000");
        String replaceStr2 = StringUtils.replace(str, "abc", "000",1);
        // 当max设置为1时等价于只替换一次
        String replaceStr3 = StringUtils.replaceOnce(str, "abc", "000");
        System.out.println("replaceStr1 = " + replaceStr1);
        System.out.println("replaceStr2 = " + replaceStr2);
        System.out.println("replaceStr3 = " + replaceStr3);
    }

2、(overlay)替换指定位置字符串序列

    @Test
    public void test8(){
        String str = "system is very good";
        // 指定位置开始替换 直接替换除了首尾的字符
        String afterStr = StringUtils.overlay(str, "--------", 1, str.length()-1);
        System.out.println("afterStr = " + afterStr);
    }

3、(replaceEach)批量替换

    @Test
    public void test9(){
        String str = "abcdefgabcdefg";
        // 替换多个字符序列
        String [] arr1 = { "a", "b"};
        String [] arr2 = { "A", "B"};
        // 注意 替换的个数一定要一致不然报异常
        String afterStr = StringUtils.replaceEach(str, arr1, arr2);
        System.out.println("afterStr = " + afterStr);
    }

6、(reverse)反转

    @Test
    public void test10(){
        String str1 = "123456789";
        String str2 = "1-2-3-4-5-6-7-8-9";
        // 字符串反转
        String afterStr1 = StringUtils.reverse(str1);
        // 根据分隔符反转
        String afterStr2 = StringUtils.reverseDelimited(str2,'-');
        System.out.println("afterStr1 = " + afterStr1);
        System.out.println("afterStr2 = " + afterStr2);
    }

7、(substring)截取

# 截取
	1.从左到对右下标默认从0开始，从右往左下标默认从-1开始

    @Test
    public void test11(){
        String str1 = "0123456789";
        // 从第五个位置开始截取
        String afterBefore1 = StringUtils.substring(str1, 5);
        // 指定截取的开始位置和结束位置
        String afterBefore2 = StringUtils.substring(str1, 0, 5);
        System.out.println("afterBefore1 = " + afterBefore1);
        System.out.println("afterBefore2 = " + afterBefore2);
    }

# 根据指定的分隔符进行截取
# substringAfter
	从分隔符第一次出现的位置向后截取
# substringBefore
	从分隔符第一次出现的位置向前截取
# substringAfterLast
	从分隔符最后一次出现的位置向后截取
# substringBeforeLast
	从分隔符最后一次出现的位置向前截取
# substringBetween
	截取指定标记字符之间的字符序列

    @Test
    public void test12(){
        String str = "ab-cd-ef-gh-ij-kl-mn-op-qr";
        // 从分隔符第一次出现的位置向后截取
        String afterStr1 = StringUtils.substringAfter(str, "-");
        String afterStr2 = StringUtils.substringBefore(str, "-");
        System.out.println("afterStr1 = " + afterStr1);
        System.out.println("afterStr2 = " + afterStr2);
        System.out.println("------------------------------------------------");
        // 从分隔符最后一次出现的位置向前或者向后截取
        String afterStr3 = StringUtils.substringAfterLast(str, "-");
        String afterStr4 = StringUtils.substringBeforeLast(str, "-");
        System.out.println("afterStr3 = " + afterStr3);
        System.out.println("afterStr4 = " + afterStr4);
        System.out.println("------------------------------------------------");
        // 截取指定标记字符之间的序列
        String str2 = "A00000000000000000000000000000000000000A";
        String afterStr5 = StringUtils.substringBetween(str2, "A");
        System.out.println("afterStr5 = " + afterStr5);
    }

8、(containsOnly)包含

# 包含
	判断字符串中的字符是否都是出自所指定的字符数组或字符串   StringUtils.containsOnly(str, validChars);
	需要注意的是：前面的字符是否都出自后面的参数中，也是拆为数组来比较

    @Test
    public void test13(){
        String str = "Happiness is a way station between too much and too little";
        // 注意 他是拆分成字符数组比较的(所以只要有to这个字符串序列 就会匹配成功) 注意顺序
        // 判断字符序列中是否包含一个字符或一个字符序列
        // str中是否包含to这个字符序列
        boolean isExistTo1 = StringUtils.containsOnly("to",str);
        boolean isExistTo2 = StringUtils.containsOnly("ato",str);
        System.out.println("isExistToo1 = " + isExistTo1);
        System.out.println("isExistToo2 = " + isExistTo2);
        // 用于检测字符串是否以指定的前缀开始
        boolean isHappinessPrefix = StringUtils.startsWith(str,"Happiness");
        System.out.println("isHappinessPrefix = " + isHappinessPrefix);
    }

9、(indexOf)查找字符索引

# indexOf
	返回在字符串中第一次出现的位置,如果没有在字符串中出现，则返回-1
# lastIndexOf
	返回在字符串中最后一次出现的索引
# indexOfAny
	返回字符数组第一次出现在字符串中的位置
# indexOfAnyBut
	子字符串与主字符串不匹配部分的位置
	StringUtils.indexOfAnyBut("sdsfhhl0","h");//结果是0
	StringUtils.indexOfAnyBut("sdsfhhl0","s");//结果是1
	StringUtils.indexOfAnyBut("aa","aa");//结果是-1
# indexOfDifference
	统计两个字符串共有的字符个数
# difference
	去掉两个字符串相同的字符以后的字符串

    @Test
    public void test14(){
        String str = "hello,world";
        // 查找字符出现的位置
        int index1 = StringUtils.indexOf(str, "l");
        System.out.println("index1 = " + index1);
        // 查找字符最后出现的索引位置
        int index2 = StringUtils.lastIndexOf(str,"l");
        System.out.println("index2 = " + index2);
        // 查找字符串第一次出现的索引的位置
        int index3 = StringUtils.indexOfAny(str, "l");
        System.out.println("index3 = " + index3);
        // 查找字符和字符串不匹配的开始位置
        int index4 = StringUtils.indexOfAnyBut(str,"we");
        System.out.println("index4 = " + index4);
        // 统计两个字符串开始共有的字符个数
        int number = StringUtils.indexOfDifference(str,"hello");
        System.out.println("number = " + number);
        // 去除两个字符串开始共有的部门
        String afterStr = StringUtils.difference(str,"hello,java");
        System.out.println("afterStr = " + afterStr);
    }

10、首字母大小写

# capitalize
	首字母大写
# uncapitalize
	首字母小写

    @Test
    public void test15(){
        String str = "fhr";
        System.out.println("str = " + str);
        // 首字母变为大写
        String capitalize = StringUtils.capitalize(str);
        System.out.println("首字母大写 = " + capitalize);
        // 首字母变为小写
        String uncapitalize = StringUtils.uncapitalize(capitalize);
        System.out.println("首字母小写 = " + uncapitalize);
        // 全部变为大写
        String upperCase = StringUtils.upperCase(capitalize);
        System.out.println("全部变为大写 = " + upperCase);
        // 全部变为小写
        String lowerCase = StringUtils.lowerCase(upperCase);
        System.out.println("全部变为小写 = " + lowerCase);
    }

文章来源地址https://www.toymoban.com/news/detail-833571.html

到了这里，关于String字符串，FastJson常用操作方法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！