<-开发笔记-> --持续更新ing...

<-开发笔记-> --持续更新ing...

String类型数据操作

一.字符串类型时间 转换 显示格式 (比如 HH:mm:ss 格式换成 HH:mm)

//格式化时间
​
//1.获取时间
String str = "8:00:00";
​
Date date = null;
try {
​
    //2.字符串时间转换成date类型
    date = (Date) new SimpleDateFormat("HH:mm:ss").parse(str);
​
} catch (ParseException e) {
    e.printStackTrace();
}
​
//3.设置日期格式
SimpleDateFormat df = new SimpleDateFormat("HH:mm");
​
//4.在转换成String类型
str= df.format(date);

 

 

二.字符串类型判空

null != str && str.equals("1")

 

StrUtil.isNotBlank(str) && sort.equals(str)

 

三.去除字符串前后空格, 替换

.trim()

把字符串中a替换成b

.replaceAll("a","b")

四.字符串类型 数字比较大小

 public int calculate(String s) {
     BigDecimal a = BigDecimal.valueOf(Double.valueOf(s));
     Double b = Double.valueOf(s);
     BigDecimal c = new BigDecimal(s);
     // 将temp乘以1000
     a = a.multiply(BigDecimal.valueOf(1000));
     int result = a.intValue();
​
     return result;
 }

集合的操作

一.List

List获取 交集, 差集, 并集, 去重并集

public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
    list1.add("1");
    list1.add("2");
    list1.add("3");
    list1.add("5");
    list1.add("6");
List<String> list2 = new ArrayList<String>();
list2.add("2");
list2.add("3");
list2.add("7");
list2.add("8");
​
// 交集
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(toList());
System.out.println("---交集 intersection---");
intersection.parallelStream().forEach(System.out :: println);
​
// 差集 (list1 - list2)
List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(toList());
System.out.println("---差集 reduce1 (list1 - list2)---");
reduce1.parallelStream().forEach(System.out :: println);
​
// 并集
List<String> listAll = list1.parallelStream().collect(toList());
List<String> listAll2 = list2.parallelStream().collect(toList());
listAll.addAll(listAll2);
System.out.println("---并集 listAll---");
listAll.parallelStream().forEachOrdered(System.out :: println);
​
// 去重并集
List<String> listAllDistinct = listAll.stream().distinct().collect(toList());
System.out.println("---得到去重并集 listAllDistinct---");
listAllDistinct.parallelStream().forEachOrdered(System.out :: println);
​
System.out.println("---原来的List1---");
list1.parallelStream().forEachOrdered(System.out :: println);
System.out.println("---原来的List2---");
list2.parallelStream().forEachOrdered(System.out :: println);
}

List集合删除数据

(推荐使用迭代器, for循环会改变集合结构, 迭代器无需关心这个问题)

1.使用迭代器 2.for循环倒着删除 3.正向删除每次集合长度要减一

Iterator<String> it = list.iterator();
     while(it.hasNext()){
         String str = it.next();
                 it.remove();
     }

 

List集合排序

 

  1. 去重加顺序排序, TreeSet特性(有序不重复集合) *数据类型String 或者int

List<String> listTime = new ArrayList(new TreeSet(thisExecTimes));

 

  1. 先根据 Name属性 排序再根据Age属性排序 , 升序如下, java8新特性

list.sort(Comparator.comparing(User::getName).thenComparing(User::getAge));

降序

list.sort(Comparator.comparing(User::getName).thenComparing(User::getAge).reversed());

 

  1. 复杂的方法,原生

Collections.sort(list, new Comparator<TestA>() {
         @Override
         public int compare(TestA o1, TestA o2) {
             //升序
             return o1.getAge().compareTo(o2.getAge());
         }
     });

 

自定义Comparator

// 4.排序
/* 按巡视时间排序时，优先倒序排序已到巡视时间的患者，剩余患者按床号排序
按床号排序时，只按床号排序 */
String sort = req.getSort();
Comparator<PatrolIntervalPack> sortComparat = null;
final String bed = "bed";
if (StrUtil.isNotBlank(sort) && sort.equals(bed)) {
sortComparat = Comparator.comparing(PatrolIntervalPack::getBedName)
      .thenComparing(PatrolIntervalPack::getTimeInterval);
} else {
sortComparat = Comparator.comparing(PatrolIntervalPack::getTimeInterval)
      .thenComparing(PatrolIntervalPack::getBedName);
}
​
patrolIntervalPackList = patrolIntervalPackList.stream()
  .sorted(sortComparat)
  .collect(Collectors.toList());

 

  1. 字符串复杂排序整合(工具类)

 

list.sort((o1, o2) -> {
             LetterNumberComparator letterNumberComparator = new LetterNumberComparator();
             return letterNumberComparator.compare(o1.getBedName(), o2.getBedName());
         });
package unicom.mobile.nersu.console.util;
​
import cn.hutool.core.util.StrUtil;
​
import java.util.Comparator;
​
/**
 * @author Kit
 * @date 2020/6/11 16:38
 */
public class LetterNumberComparator implements Comparator<String> {
​
    /**
     * ASCII编码 0
     */
    private static final Integer MIN_NUMBER = 48;
​
    /**
     * ASCII编码 9
     */
    private static final Integer MAX_NUMBER = 57;
​
    @Override
    public int compare(String s1, String s2) {
        if (StrUtil.isAllBlank(s1, s2)) {
            return 0;
        }
        if (StrUtil.isBlank(s1)) {
            return 1;
        }
        if (StrUtil.isBlank(s2)) {
            return -1;
        }
        // 特殊字符开头
        char s1Index = s1.charAt(0);
        char s2Index = s2.charAt(0);
        boolean flag;
        // s1字符 s2数字
        flag = (s1Index < MIN_NUMBER || s1Index > MAX_NUMBER) && (s2Index >= MIN_NUMBER && s2Index <= MAX_NUMBER);
        if (flag) {
            return s1.compareTo(s2);
        }
        flag = (s2Index < MIN_NUMBER || s2Index > MAX_NUMBER) && (s1Index >= MIN_NUMBER && s1Index <= MAX_NUMBER);
        // s1数字 s2字符
        if (flag) {
            return s1.compareTo(s2);
        }
        // s1字符 s2字符
        flag = (s2Index < MIN_NUMBER || s2Index > MAX_NUMBER) && (s1Index < MIN_NUMBER || s1Index > MAX_NUMBER);
        if (flag) {
            return s1.compareTo(s2);
        }
//      [^(0-9)]+   这个正则含义: 不是数字的所有内容视为一个整体替换成 _
        String[] str1Arr = s1.replaceAll("[^(0-9)]+", "_").split("[^(0-9)]");
        String[] str2Arr = s2.replaceAll("[^(0-9)]+", "_").split("[^(0-9)]");
​
        int lim = Math.min(str1Arr.length, str2Arr.length);
        for (int i = 0; i < lim; i++) {
            int int1 = Integer.parseInt(str1Arr[i]);
            int int2 = Integer.parseInt(str2Arr[i]);
            if (int1 != int2) {
                return int1 - int2;
            }
        }
​
        return 0;
    }
​
}

 

二.Map

 

遍历

 

public static void main(String[] args) {
      Map<Integer, String> map = new HashMap<Integer, String>();
     map.put(1, "a");
     map.put(2, "b");
     map.put(3, "ab");
     map.put(4, "ab");
     map.put(4, "ab");// 和上面相同 ， 会自己筛选
     System.out.println(map.size());

 

    System.out.println("第一种：通过Map.keySet遍历key和value：");
    for (Integer in : map.keySet()) {
        //map.keySet()返回的是所有key的值
        String str = map.get(in);//得到每个key多对用value的值
        System.out.println(in + "     " + str);
   }
​
​
System.out.println("第二种：通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<Integer, String> entry = it.next();
    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}
​
// 第三种：推荐，尤其是容量大时
System.out.println("第三种：通过Map.entrySet遍历key和value");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    //Map.entry<Integer,String> 映射项（键-值对）  有几个方法：用上面的名字entry
    //entry.getKey() ;entry.getValue(); entry.setValue();
    //map.entrySet()  返回此映射中包含的映射关系的 Set视图。
    System.out.println("key= " + entry.getKey() + " and value= "
                + entry.getValue());
    }
​
    System.out.println("第四种：通过Map.values()遍历所有的value，但不能遍历key");
    for (String v : map.values()) {
        System.out.println("value= " + v);
    }
​
}

 

 

 

 

实体类操作: 拷贝对象属性

a拷贝到b

BeanUtils.copyProperties(a, b);

 

 

MySql

 

一.调优

 

sql语句 gruop by 用来分组, 一般用来求和 大量数据会导致查询变慢,如果无意义 可以删除

MybatisPlus框架

 

一.排序

使用方法是在查询条件中添加,一共三个

1.默认升序

//升序
.orderByAsc(PatientTemperature::getTime)
//降序
.orderByDesc(PatientTemperature::getInputTime)
//默认
.orderBy(true,true,PatientTemperature::getTime)
posted @ 2021-12-09 18:36  StarryForest  阅读(27)  评论(0)    收藏  举报