stream流的应用与并行流

直接使用stream流

public class Stream {public static void main(String[] args) {//ArrayList<Object> arrayList = new ArrayList<>(); //List集合不安全，stream().parallel()操作不行List<Object> arrayList = Collections.synchronizedList(new ArrayList<>());//解决方法一：集合工具类// CopyOnWriteArrayList<Object> arrayList = new CopyOnWriteArrayList<>(); //解决方法二：JUC的集合for (int i = 1; i <= 100000; i++) {arrayList.add(String.valueOf(i));}System.out.println("-------------------使用串行流--------------------");ArrayList<Object> result1 = new ArrayList<>();long start = System.currentTimeMillis();arrayList.forEach((str)->{
//        System.out.println(Thread.currentThread().getName()+"，操作中。。。");result1.add(new User(2, (String) str,22));});//  System.out.println("使用串行流，修改集合"+result1);System.out.println("花费的时间为："+(System.currentTimeMillis()-start));System.out.println("-------------------使用并行流--------------------");//这里使用的集合需要注意，不能使用常规的集合，在扩容的时候会出现数组下标越界异常，经过测试CopyOnWriteArrayList集合效率比较低下，因为CopyOnWriteArrayList，在写操作的时候会新建集合List<Object> result2 = Collections.synchronizedList(new ArrayList<>());//CopyOnWriteArrayList<Object> arrayList = new CopyOnWriteArrayList<>();start = System.currentTimeMillis();arrayList.stream().parallel().forEach((str)->{//System.out.println(Thread.currentThread().getName()+"，操作中。。。");result2.add(new User(2, (String) str,22));});//   System.out.println("使用并行流，修改集合"+result2);System.out.println("花费的时间为："+(System.currentTimeMillis()-start));
}}

add操作使用的集合需要注意，不能使用常规的集合，在扩容的时候会出现数组下标越界异常，经过测试CopyOnWriteArrayList集合效率比较低下，因为CopyOnWriteArrayList，在写操作的时候会新建集合，JUC包下的一些集合是可以用的，或者是加锁的集合，但是效率不一定会很高，数据量太大也会导致内存泄漏OOM问题

使用IntStream流

 @Testpublic void testStream(){IntStream intStream = IntStream.of(6, 1, 1, 2, 5, 2, 3, 4);long start=System.currentTimeMillis();//并行处理intStream.parallel().forEach(x->{try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+":"+x);});System.out.println("parallel time->"+(System.currentTimeMillis()-start));intStream = IntStream.of(6, 1, 1, 2, 5, 2, 3, 4);start=System.currentTimeMillis();//默认都是串行处理intStream.sequential().forEach(x->{try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+":"+x);});System.out.println("sequential time->"+(System.currentTimeMillis()-start));}

在使用并行流的时候一定要注意线程安全问题，而且并不能保证多个线程之间顺序执行，多线程还需要考虑原子性可见性指令重排等问题，而且效率也不一定会比串行流高很多，在使用的时候需要慎重考虑优劣，毕竟带来的问题还是比较多的

查询表中是否存在想要的记录：

select 1 from table where  。。。 limit 1

在queryMapper后拼接limit条件:

String 中就是sql语句例如："limit 1"

querymapper.last(String)

遇到很多个表结构差不多的情况，使用反射加上泛型就可以封装一个通用的mapper，这个就是随便写的一个Demo，不一定对，随便瞎写的，大概就是这个意思

public <T,R> R baseMapper(R request,Class<T> po){QueryMapper<T> queryMapper=new QueryMapper();
//这里使用反射获取request的属性，然后拼接mapper条件，其实就相当于写死了，然后判断属性值是否为null，来拼接sql
queryMapper.eq("name",request.hetClass().getgetDeclaredField（"name"）.get(request));
//这里如果属性是私有的话，可以setAccessible（true），来破坏私有属性
return queryMapper;}

idea当前类全局替换： ctrl+r ，还可以排除不想替换的词

idea大小写转换快捷键：ctrl+shift+u

获取ip地址，这个在多节点情况下对于排查问题时是很有必要的：

InetAddress.getLocalHost().getHostAddress()

stream流将两个集合合并成一个map，一个集合的值当key，一个集合的值为value；这里需要注意key的唯一性问题

public static void main(String[] args) {List<Integer> keyList = new ArrayList<>();List<String> valueList = new ArrayList<>();keyList.add(1);keyList.add(2);keyList.add(3);keyList.add(4);keyList.add(5);valueList.add("张三");valueList.add("李四");valueList.add("王五");valueList.add("赵六");valueList.add("钱七");//使用stream流的方式，把这两个list集合长度一样合并成一个map集合//将list转换mapMap<Object, Object> map = keyList.stream().collect(Collectors.toMap(key -> key, value -> valueList.get(keyList.indexOf(value))));System.out.println(map);//最终需要的结果 {1=张三, 2=李四, 3=王五, 4=赵六, 5=钱七}}

从一个集合中截取指定区间的数据：

ArrayList.subList（）；（左开右闭）

boolean类型的参数尽量不要用is来命名，因为某些框架会自动将Boolean类型参数的is去掉

private Boolean isShow； -> private boolean show;

将两个集合合并成一个集合

List<String> list1 = Arrays.asList("阿卫", "阿辉", "阿杰", "阿成");
List<String> list2 = Arrays.asList("阿悦", "阿楠", "阿洁", "阿锋");
Stream.concat(list1.stream(),list2.stream());

时间类型作比较

before（）和after（）方法必须格式一致

compareTo（）方法返回boolean类型

或者将时间转换为毫秒作比较 getTime（）方法

stream流分组排序

LinkedHashMap<Integer, List<Person>> ageMap = persons.stream().sorted(Comparator.comparingInt(Person::getAge)).collect(Collectors.groupingBy(Person::getAge, LinkedHashMap::new, Collectors.toList()));

多字段排序

//先以userId降序,再进行userName升序 **推荐使用该种方式**
list = list.stream().sorted(Comparator.comparing(User::getUserId,Comparator.reverseOrder()).thenComparing(User::getUserName)).collect(Collectors.toList());

数组进行翻转

Collections.reverse(arrayList)

自定义常量集合

/** 常量值列表 */
public static final List<Integer> CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3));
/** 常量值集合 */
public static final Set<Integer> CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3)));
/** 常量值映射 */
public static final Map<Integer, String> CONST_VALUE_MAP;
static {
Map<Integer, String> valueMap = new HashMap<>();
valueMap.put(1, "value1");
valueMap.put(2, "value2");
valueMap.put(3, "value3");
CONST_VALUE_MAP = Collections.unmodifiableMap(valueMap);
}

分割字符串

String dirDiveded[] = fileName.split("/"); String newName = ""; if(dirDiveded.length > 0){ newName = dirDiveded[dirDiveded.length-1]; }

String newName = fileName.substring(fileName.lastIndexOf("/")+1);

http下载

public static void download(List urlStringList) {
OutputStream os = null;
InputStream is = null;
try {
for (Object urlStringObj : urlStringList) {
String urlString = (String) urlStringObj;
// 构造URL
URL url = new URL(urlString);
// 打开连接
URLConnection con = url.openConnection();
//设置请求超时为5s
con.setConnectTimeout(5 * 1000);
// 输入流
is = con.getInputStream();
// 1K的数据缓冲
byte[] bs = new byte[1024];
// 读取到的数据长度
int len;
// 路径
String filename = urlString.substring(urlString.lastIndexOf("/"));
// System.out.println(filename);
// String str = urlString.split(filename)[0];
// System.out.println(str);
// String[] split = str.split("//");
// int i = split[1].indexOf("/");
// String substring = split[1].substring(i);
// System.out.println(substring);

// 输出的文件流
File sf = new File(savePath);
if (!sf.exists()) {
sf.mkdirs();
}
os = new FileOutputStream(sf.getPath() + filename+fileType);
// 开始读取
while ((len = is.read(bs)) != -1) {
os.write(bs, 0, len);
}
// System.out.println("下载完成");
}
// 完毕，关闭所有链接
os.close();
is.close();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if(null != os){
os.close();
}
if(null != is){
is.close();
}
}catch (Exception e){
e.printStackTrace();
}
}

}

异常处理：Cannot call sendError() after the response has been committed

原因是在流关闭之后接口还返回了数据，使接口返回void即可解决

Protocol handler start failed ：端口占用

返回流设置类型：

response.setContentType("multipart/form-data");

返回流，设置文件名称中文失效：

response.setHeader("Content-Disposition", "attachment; filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));

异常处理：getOutputStream() has already been called for this response

在getOutputStream()和getWriter（）中间，使用respomse.reset()方法

如有其他问题评论区见