个人小计----一天一点点

最新推荐文章于 2024-04-12 09:18:55 发布

anyeoo

最新推荐文章于 2024-04-12 09:18:55 发布

阅读量486

点赞数 1

分类专栏：一天一点点文章标签： java8 小结

原文链接：https://www.cnblogs.com/loveLands/articles/9894814.html

版权

一天一点点专栏收录该内容

17 篇文章 0 订阅

订阅专栏

有些摘记网络,只是遇上做个记录罢了

1.List与String转换:

String 转list--->String str = "aaa,bbb,ccc";java.util.Arrays.aslist(str);

Arrays.asList(str.split(","))

list转String--->

List<String> list =  Arrays.asList("001", "002", "003");String.join(",", list);

2.个人比较喜欢的单例模式:

public class SingleModel {
    private volatile static SingleModel singleModel = null;
    private SingleModel(){}
    /**
     * 取得单例实现
     * @return
     */
    public static SingleModel getInstance() {
        if (singleModel ==null) {
            synchronized (SingleModel.class){
                singleModel = new SingleModel();
            }
        }
        return singleModel;
    }
}

3.枚举类型:

public enum  TestEnum {
    SPRING(1,"春天"),SUMMER(2,"夏天"),AUTUMN(3,"秋天"),WINTER(4,"冬天");
    private Integer key;
    private String value;

    private TestEnum(Integer key, String value) {
        this.key = key;
        this.value = value;
    }
    public static String getName(Integer key) {
        for (TestEnum c : TestEnum.values()) {
            if (c.getKey().equals(key)) {
                return c.value;
            }
        }
        return null;
    }
    public Integer getKey() {
        return key;
    }

    public void setKey(Integer key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

3.1枚举转map,

 Map<Integer,String> typeMap = Arrays.stream(TestEnum.values()).collect(Collectors.toMap(o->o.getKey(), o->o.getValue()));

4.java8一些工具:

list去重:

List<String> uniqueStr = strList.stream().distinct().collect(Collectors.toList());

list转map:

detail.stream().collect(Collectors.toMap(o->o.getId(),o->o.getPrice()));//通过唯一id找到对应的某个属性值
detail.stream().collect(Collectors.toMap(o->o.getId(), a -> a,(k1,k2)->k1));//通过唯一id找到对应某个对象,如果有重复,则保留k1,舍弃k2

list分组:以某个属性来分组，例如，以id分组，将id相同的放在一起

list.stream().collect(Collectors.groupingBy(o->o.getId()));
list.stream().collect(Collectors.groupingBy(App::getId));

分组并排序

默认升序，否则实现比较器

TreeMap<String,List<User>> sumList =  list.stream().collect(Collectors.groupingBy(a->a.getCreateTime(),TreeMap::new,Collectors.toList()));

之前是有序的，则

			LinkedHashMap<String,List<PageData>> pageList = list.stream().filter(o -> o.get("searchTime") != null)
					.collect(Collectors.groupingBy(a->a.getString("searchTime"),LinkedHashMap::new,Collectors.toList()));

过滤filter:从集合中过滤出来符合条件的元素

list.stream().filter(a -> a.getName().equals("条件")).collect(Collectors.toList());

求和:将集合中的数据按照某个属性求和

 list.stream().mapToInt(App::getNum).sum();
 list.stream().mapToDouble(App::getNum).sum();
 list.stream().filter(o -> o.getNumber() != null).mapToDouble(a -> a.getNumber()).sum();
//BigDecimal求和
BigDecimal bigDecimal = list.stream().map(User::getNum).reduce(BigDecimal.ZERO, BigDecimal::add);

去除不为null的再求和

list.stream().filter(o -> o.getTotal() != null).mapToDouble(a -> a.getTotal()).sum()

java8排序:

Collections.sort(names, (a, b) -> b.compareTo(a))

//单字段排序，根据id排序
list.sort(Comparator.comparing(User::getId));
//多字段排序，根据id，年龄排序
list.sort(Comparator.comparing(User::getId).thenComparing(User::getAge));

map.forEach((k,v)->System.out.println("key : " + k + "; value : " + v));java8 map循环

java8分组求和并排序,k为分组字段,v1代表第一个user,v2是第二个user

   List<User> sumList = new ArrayList<>();
        totalList.stream()
                .collect(Collectors.groupingBy(User::getName)) //分组(Name can't be null)
                .forEach((k,v) -> {
                    Optional<User> sum = v.stream().reduce((v1,v2) -> {  //合并
                        v1.setNum(v1.getNum()+v2.getNum());
                        v1.setAmount(v1.getAmount()+v2.getAmount());
                        return v1;
                    });
                    sumList.add(sum.orElse(new User()));

                });
        sumList.sort(Comparator.comparingDouble(User::getNum).reversed());

list:过滤+去重,并去除某一属性,组成新的list

list.stream().filter(o -> o.getId() != null).map(o->o.getId()).distinct().collect(Collectors.toList());

list集合中取出某一属性的方法

list.stream().map(o->o.getId()).collect(Collectors.toList());

打jar包: 将a文件下的所有文件打包为classes.jar ---- jar cvf classes.jar -C a/ .

如果本身是jar文件需加入某个文件,直接用war压缩软件打开,把需要的文件直接拖入相应的文件目录位置.

5.ajax 请求返回canceled状态

因为用easyui 框架的时候在请求还没发送出去的时候或者已经发送出去但数据结果还未返回就关闭了window窗体（iframe嵌套的请求发生在iframe嵌套的页面中）导致了请求被取消

6.查询端口占用:netstat -aon|findstr "49157"

7.Spring能够较好的处理这种问题，核心如下:

7.1 ResponseStatus(value=HttpStatus.FORBIDDEN,reason="用户不匹配")可以将某种异常映射为HTTP状态码,可修饰类或方法

ResponseStatus修饰目标方法，无论它执行方法过程中有没有异常产生，用户都会得到异常的界面。而目标方法正常执行

7.2 注解:ExceptionHandler 统一处理某一类异常，从而能够减少代码重复率和复杂度

7.3 .ControllerAdvice：异常集中处理，更好的使业务逻辑与异常处理剥离开,可以包含由@ExceptionHandler、@InitBinder 和@ModelAttribute标注的方法，可以处理多个Controller类，这样所有控制器的异常可以在一个地方进行处理。

@ControllerAdvice + @ExceptionHandler 进行全局的 Controller 层异常处理，只要设计得当，就再也不用在 Controller 层进行 try-catch 了！而且，@Validated 校验器注解的异常，也可以一起处理，无需手动判断绑定校验结果 BindingResult/Errors 了！

优点：将 Controller 层的异常和数据校验的异常进行统一处理，减少模板代码，减少编码量，提升扩展性和可维护性。
缺点：只能处理 Controller 层未捕获（往外抛）的异常，对于 Interceptor（拦截器）层的异常，Spring 框架层的异常，就无能为力了

8.@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上,

 @RequestMapping("/zyh/{type}")
 public String zyh(@PathVariable(value = "type") int type){XXXXXX}

9.IDEA合并SVN分支代码到主干上

9.1将项目切换到主干上，并把代码更新到最新，保证本地与SVN主干，完全一致,VCS --> Integrate Project

9.2在Source 1中选择主干的SVN地址(选版本号或HEAD),在Source2中选择分支的地址，并在版本号处选择HEAD(最新),如无法选择Source2请重新配置分支地址

Try merge, but make no changes选项中打勾,Depth中选择working copy,将尝试比较。最后点“OK”,检查合并结果是否正常正确

9.3当确认尝试合并无问题后,再次重复上述合并步骤的界面，但在Try merge, but make no changes选项中取消打勾，然后点击“OK”，开始合并

9.4当合并代码过程中出现文件冲突时，会弹出一个冲突列表。此时需要对冲突的文件进行一个个合并。选择一个冲突的文件，单击“Merge...”，在弹出的合并窗口中，会展示三个文件，左边是本地代码，中间是合并后的代码，右边是分支上的代码。IDEA已经将冲突的代码块标志出来，你只需要将左边和右边的代码往中间合并，然后查看中间的代码是否正确，若不正确，直接修改正确，最后点击下方的“Apply”，完成该文件的合并

9.5在确认修改的文件无误后,最后点击”Commit“，提交代码到SVN。至此合并分到主干完成

10.svn拉分支

10.1 选中某个你要拉分支的项目，右击Subversion-branch or tag

10.2如下图

10.3在选则svn上的分支路径时，需要注意如下

10.4 至此如果不报错的情况下，就代表拉分支成功，接下来要干的事，就很简单了，直接找到分支的路径，把它checkout出来即可!

11.如果SVN的IP改变,服务器ip地址更新选择此项目，然后点击：【VCS】->【Subversion】->【Relocate】

12.UrlEncodedFormEntity()的形式比较单一，只能是普通的键值对，局限性相对较大。而StringEntity()的形式比较自由，只要是字符串放进去，不论格式都可以(ContentType,APPLICATION_FORM_URLENCODED键值对)。new StringEntity中添加“UTF-8”编码设置(解决中文编码),

13.@Transient 表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性.

14.查看端口占用:netstat -aon|findstr 1099 找出占用1099端口的进程id

关闭占用该端口的进程:taskkill -f -pid 3756

15.replaceAll可以使用正则表达式替换

17.静态块,静态变量静态方法执行顺序:加载类是,加载静态变量和静态代码块(只执行一次)顺序加载,创建对象是:变量和匿名代码块顺序加载,构造函数,静态方法是在调用的时候才加载

1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。
2、执行子类的静态代码块和静态变量初始化。
3、执行父类的实例变量初始化
4、执行父类的构造函数
5、执行子类的实例变量初始化
6、执行子类的构造函数

18.不返回某个空字段给前端

get方法上加:

1.@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)

2.@JsonIgnore

属性上加:

@JsonInclude(JsonInclude.Include.NON_NULL)

7.InputStream 转byte

    public static byte[] toByteArray(InputStream input) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        byte[] buffer = new byte[4096];
        int n = 0;
        while (-1 != (n = input.read(buffer))) {
            output.write(buffer, 0, n);
        }
        output.flush();
        output.close();
        return output.toByteArray();
    }

8.mybaits只有一个参数时,如果xml有加盘点空时会报错,找不到get,set方法

   <if test='id != null and id != "" '>

多加个注解@Param("id")或者放入实体内

9.手动分页循环

final int PER_NUM = 500;
		List<User> oldList = new ArrayList<>();
		int page = oldList.size() % PER_NUM == 0 ? oldList.size() / PER_NUM : oldList.size() / PER_NUM + 1;
		List<User> tempList = null;
		for (int i = 0; i < page; i++) {
			if (i == page - 1) {
				tempList = oldList.subList(i * PER_NUM, oldList.size());
			} else {
				tempList = oldList.subList(i * PER_NUM, (i + 1) * PER_NUM);
			}
			if (CollectionUtils.isNotEmpty(tempList)) {
				//具体业务
			}
		}

10.mybaits储存过程调取


<select id="findName" statementType="CALLABLE">
    {call findName( #{username, mode=IN}, #{name, mode=OUT, jdbcType=VARCHAR} )}
</select>


/**
 * 参数和结果都在params中
 * @param params
 */
void findName(Map<String, Object> params);

测试：

//声明Map
Map<String,Object> map = new HashMap<String,Object>();
//传递入参
map.put("username","zhangsan");
//设置出参,出参的值暂时设置为null
map.put("name",null);
//调用存储过程
mapper.findName(map);
//存储过程调用之后，map中的出参就有值了
System.out.println("result:"+map.get("name"));

redis:

public String get(key) {  
      String value = redis.get(key);  
      if (value == null) { //代表缓存值过期  
          //设置3min的超时，防止del操作失败的时候，下次缓存过期一直不能load db  
          if (redis.setnx(key_mutex, 1, 3 * 60) == 1) {  //代表设置成功
               value = redis.get(key);//再次判断
                if(value != null){
                    return value;
                }
               value = db.get(key);  
                      redis.set(key, value, expire_secs);  
                      redis.del(key_mutex);  
              } else {  //这个时候代表同时候的其他线程已经load db并回设到缓存了，这时候重试获取缓存值即可  
                      sleep(50);  
                      get(key);  //重试  
              }  
          } else {  
              return value;        
          }  
 }

12.分组后多字段重新赋值返回单个对象

Map<Integer,User> sumList =  list.stream().collect(Collectors.groupingBy(a->a.getId(),Collectors.reducing(new User(), (v1,v2) -> {
                    v1.setTelephone(v1.getTelephone()+v2.getTelephone());
                    v1.setUsername(v1.getUsername()+v2.getUsername());
                    return v1;
                })));

13.时间格式化,线程安全

DateTimeFormatter类是线程安全的，可以在高并发场景下直接使用DateTimeFormatter类来处理日期的格式化操作，

也可以使用第三方处理日期时间格式化的类库joda-time

	LocalDate date = LocalDate.parse("2020-01-01",DateTimeFormatter.ofPattern("yyyy-MM-dd"));
		System.out.println(date);
		//LocalDate转date
		ZoneId zone = ZoneId.systemDefault();
		Instant instant = date.atStartOfDay().atZone(zone).toInstant();
		Date date1 = Date.from(instant);
		System.out.println(date1);

		String dateStr = "2019-10-28 10:23:12";
		//根据时间表达式生成DateTimeFormatter对象
		DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		LocalDateTime parseDateTime = LocalDateTime.parse(dateStr, dateTimeFormatter);
		System.out.println(parseDateTime);
		//LocalDateTime转date
		ZoneId zone2 = ZoneId.systemDefault();
		Instant instant2 = parseDateTime.atZone(zone2).toInstant();
		Date date2 = Date.from(instant2);
		System.out.println(date2);
		//LocalDateTime转String
		String formatLocalDate = dateTimeFormatter.format(parseDateTime);
		System.out.println(formatLocalDate);
		//设置时区
		ZoneId zone3 = ZoneId.of("GMT+8");
		Instant instant3 = LocalDateTime.now().atZone(zone3).toInstant();
		Date date3 = Date.from(instant3);
		System.out.println(date3);

排序

null排最后

list.sort(Comparator.comparing(User::getAge, Comparator.nullsLast(Integer::compareTo)).thenComparing(User::getId, Comparator.nullsLast(Integer::compareTo)));

null排前面

list.sort(Comparator.comparing(User::getAge, Comparator.nullsFirst(Integer::compareTo)).thenComparing(User::getId, Comparator.nullsFirst(Integer::compareTo)));

获取redis某个分值元素

ZSetOperations<String,User> zSetOps=redisTemplate.opsForZSet();
List<User> list = new ArrayList<User>(zSetOps.rangeByScore(Key, Double.valueOf(user.getId()), Double.valueOf(user.getId())));

按照某个字段去重

        List<User> distinctList = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getName))), ArrayList::new));

多个字段去重

        List<User> lst = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getName() + "," + o.getAge() + "," + o.getAddress()))), ArrayList::new));