文章目录
- 一、命名规约
- 二、集合篇
- 1. 栈、队列、双端队列
- 2. List的升序倒序
- 3. Map的升序降序
- 4. 二维数组排序
- 5. 集合之间的转换
- 6. Map键值对遍历
- 三、并发篇
- 1. 创建线程池
- 2. ThreadLocal的使用
- 四、时间篇
- 1. LocalDateTime的使用
- 2. String、Date、LocalDateTime转换
- 五、控制块
- 1. switch
- 2. 三目运算
- 3. 循环体
- 4. try-catch-finally-return
- 六、其他
- 1. 正则表达式
- 2. BeanUtil的copy
一、命名规约
A) 各类命名方法
类名:UserController、UserService、UserMapper
模型名:User、UserDTO、UserVO
对象名:userController
常量名:USER_NAMEB) Service/DAO 层方法命名规约
1) 获取单个对象的方法用 get 做前缀。
2) 获取多个对象的方法用 list 做前缀,复数结尾,如:listObjects。
3) 获取统计值的方法用 count 做前缀。
4) 插入的方法用 save/insert 做前缀。
5) 删除的方法用 remove/delete 做前缀。
6) 修改的方法用 update 做前缀。注意:POJO 类中布尔类型的变量,都不要加 is 前缀,否则部分框架解析会引起序列化错误。
二、集合篇
1. 栈、队列、双端队列
Stack<Integer> stack = new Stack<>(); // 栈stack.push(1); // 压入stack.pop(); // 弹出stack.peek(); // 获取但不弹出Queue<Integer> queue = new ArrayDeque<>(); //队列queue.offer(1); //压入queue.poll(); // 弹出queue.peek(); // 获取但不弹出Deque<Integer> deque = new ArrayDeque<>(); // 双端队列deque.offerFirst(1); // 压入队头deque.offerLast(2); // 压入对尾deque.pollFirst(); // 弹出队头deque.pollLast(); // 弹出队尾deque.peekFirst(); // 获取队头但不弹出deque.peekLast(); // 获取队尾但不弹出
2. List的升序倒序
List<Integer> list = Arrays.asList(10,1,6,4,8,7,9,3,2,5);System.out.println("原始数据:");list.forEach(n ->{System.out.print(n+", ");});System.out.println("");System.out.println("升序排列:");Collections.sort(list); // 升序排列list.forEach(n ->{System.out.print(n+", ");});// 降序的话:需要先升序再倒序,才能有降序的结果System.out.println("");System.out.println("降序排列:");Collections.reverse(list); // 倒序排列list.forEach(n ->{System.out.print(n+", ");});
3. Map的升序降序
Map<Integer, String> map = new HashMap<>();map.put(100, "I'am a");map.put(99, "I'am c");map.put(2, "I'am d");map.put(33, "I'am b");// 按照value进行倒排,如果要根据key进行排序的话使用Map.Entry.comparingByKey()map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).forEach(System.out::println);// 根据value进行正序排序,根据key进行排序的话使用comparingByKey()map.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(System.out::println);// 如果要将排序的结果返回的话,我们可以使用下面的方法(注意:要使用LinkedHashMap进行保存,linkedHashMap可以保存插入顺序)Map<Integer, String> resultMap1 = map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (s, s2) -> s,LinkedHashMap::new));// 下面的这种写法同上面的写法,只不过是将简写展开了,这样更易于理解Map<Integer, String> resultMap = map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(Collectors.toMap(new Function<Map.Entry<Integer, String>, Integer>() {@Overridepublic Integer apply(Map.Entry<Integer, String> integerStringEntry) {return integerStringEntry.getKey();}}, new Function<Map.Entry<Integer, String>, String>() {@Overridepublic String apply(Map.Entry<Integer, String> integerStringEntry) {return integerStringEntry.getValue();}}, new BinaryOperator<String>() {@Overridepublic String apply(String s, String s2) {return s;}}, new Supplier<Map<Integer, String>>() {@Overridepublic Map<Integer, String> get() {return new LinkedHashMap<>();}}));// 同样如果需要将排序的将结果作为Map进行返回我们还可以使用下面的方法,但是不推荐这种方式(effectivejava 178页中说:foreach操作应该只用于报告stream计算的结果,而不是执行计算)Map<Integer, String> result2 = new LinkedHashMap<>();map.entrySet().stream().sorted(Map.Entry.comparingByValue()).forEach(new Consumer<Map.Entry<Integer, String>>() {@Overridepublic void accept(Map.Entry<Integer, String> integerStringEntry) {result2.put(integerStringEntry.getKey(), integerStringEntry.getValue());}});
4. 二维数组排序
Arrays.sort(intervals, new Comparator<int[]>() {public int compare(int[] interval1, int[] interval2) {return interval1[0] - interval2[0];}});
5. 集合之间的转换
// Object转基本元素
List<String> tableNames=list.stream().map(User::getMessage).collect(Collectors.toList());// Object转Map
Map<String, Account> map = accounts.stream().collect(Collectors.toMap(Account::getUsername, Function.identity(), (key1, key2) -> key2));// Object转Map
/** * 1. 避免key重复* 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时,一定要使* 用含有参数类型为 BinaryOperator,参数名为 mergeFunction 的方法,否则当出现相同 key* 值时会抛出 IllegalStateException 异常。* 说明:参数 mergeFunction 的作用是当出现 key 重复时,自定义对 value 的处理策略* 2. 避免值为null* 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时,一定要注* 意当 value 为 null 时会抛 NPE 异常。
**/
Map<Long, String> getIdNameMap = accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsernamee, (v1, v2) -> v2));// String转Long
List<Long>=stringList.stream().map(Long::valueOf).collect(Collectors.toList());// Long转String
List<String>=longList.stream().map(String::valueOf).collect(Collectors.toList());// Integer转Long
List<Long> listLong = JSONArray.parseArray(listInt.toString(),Long.class);// Long 转Integer
List<Integer> integerList = JSONArray.parseArray(LongList.toString(), Integer.class);
// 或者
List<Integer> integerList = longList.stream().map(x -> Integer.valueOf(String.valueOf(x))).collect(Collectors.toList());// JSONArray转List
JSONArray jsonArray = updateApplicationSchemaDTO.getJSONArray("configTrophyDTOList");
configTrophyDTOList = jsonArray.toJavaList(ConfigTrophyDTO.class);// List转数组
String[] array = list.toArray(new String[0]);// 数组转List
List list = Arrays.asList(strArray);
6. Map键值对遍历
System.out.println("====4、通过entrySet()获得key-value值——使用迭代器遍历====");
Set set1 = hashMap.entrySet();
Iterator iterator1 = set1.iterator();
while(iterator1.hasNext()){Object itset = iterator1.next();Map.Entry entry = (Map.Entry) itset;System.out.println(entry.getKey()+"-"+entry.getValue());
}
三、并发篇
1. 创建线程池
ThreadPoolExecutor 参数介绍
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {}
参数 1:corePoolSize
核心线程数,线程池中始终存活的线程数。
参数 2:maximumPoolSize
最大线程数,线程池中允许的最大线程数,当线程池的任务队列满了之后可以创建的最大线程数。
参数 3:keepAliveTime
最大线程数可以存活的时间,当线程中没有任务执行时,最大线程就会销毁一部分,最终保持核心线程数量的线程。
参数 4:unit:
单位是和参数 3 存活时间配合使用的,合在一起用于设定线程的存活时间 ,参数 keepAliveTime 的时间单位有以下 7 种可选:
TimeUnit.DAYS:天
TimeUnit.HOURS:小时
TimeUnit.MINUTES:分
TimeUnit.SECONDS:秒
TimeUnit.MILLISECONDS:毫秒
TimeUnit.MICROSECONDS:微妙
TimeUnit.NANOSECONDS:纳秒
参数 5:workQueue
一个阻塞队列,用来存储线程池等待执行的任务,均为线程安全,它包含以下 7 种类型:较常用的是 LinkedBlockingQueue 和 Synchronous,线程池的排队策略与 BlockingQueue 有关。
ArrayBlockingQueue:一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue:一个由链表结构组成的有界阻塞队列。
SynchronousQueue:一个不存储元素的阻塞队列,即直接提交给线程不保持它们。
PriorityBlockingQueue:一个支持优先级排序的无界阻塞队列。
DelayQueue:一个使用优先级队列实现的无界阻塞队列,只有在延迟期满时才能从中提取元素。
LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。与SynchronousQueue类似,还含有非阻塞方法。
LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。
参数 6:threadFactory
线程工厂,主要用来创建线程,默认为正常优先级、非守护线程。
参数 7:handler
拒绝策略,拒绝处理任务时的策略,系统提供了 4 种可选:默认策略为 AbortPolicy。
AbortPolicy:拒绝并抛出异常。
CallerRunsPolicy:使用当前调用的线程来执行此任务。
DiscardOldestPolicy:抛弃队列头部(最旧)的一个任务,并执行当前任务。
DiscardPolicy:忽略并抛弃当前任务。
ThreadPoolExecutor执行流程
ThreadPoolExecutor 关键节点的执行流程如下:
- 当线程数小于核心线程数时,创建线程。
- 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
- 当线程数大于等于核心线程数,且任务队列已满:若线程数小于最大线程数,创建线程;若线程数等于最大线程数,抛出异常,拒绝任务。
ThreadPoolExecutor自定义拒绝策略
public static void main(String[] args) {// 任务的具体方法Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("当前任务被执行,执行时间:" + new Date() +" 执行线程:" + Thread.currentThread().getName());try {// 等待 1sTimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}};// 创建线程,线程的任务队列的长度为 1ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),new RejectedExecutionHandler() {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {// 执行自定义拒绝策略的相关操作System.out.println("我是自定义拒绝策略~");}});// 添加并执行 4 个任务threadPool.execute(runnable);threadPool.execute(runnable);threadPool.execute(runnable);threadPool.execute(runnable);
}
2. ThreadLocal的使用
/**
ThreadLocal的api很简单,就4个* get——获取threadlocal局部变量* set——设置threadlocal局部变量* initialvalue——设置局部变量的初始值* remove——删除该局部变量
**/
public class SequenceNumber { // ThreadLocal 对象使用 static 修饰,ThreadLocal 无法解决共享对象的更新问题。private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){ public Integer initialValue(){ return 0; } }; public int getNextNum() { seqNum.set(seqNum.get() + 1); return seqNum.get(); } public static void main(String[] args) { SequenceNumber sn = new SequenceNumber(); TestClient t1 = new TestClient(sn); TestClient t2 = new TestClient(sn); TestClient t3 = new TestClient(sn); t1.start(); t2.start(); t3.start(); t1.print(); t2.print(); t3.print(); }
}private static class TestClient extends Thread { private SequenceNumber sn; public TestClient(SequenceNumber sn ) { this.sn = sn; } public void run() { for(int i=0; i< 3; i++) { System.out.println( Thread.currentThread().getName() + " --> " + sn.getNextNum()); } } public void print() { for(int i=0; i< 3; i++) { System.out.println( Thread.currentThread().getName() + " --> " + sn.getNextNum()); } }
}
Thread-2 --> 1
Thread-2 --> 2
Thread-2 --> 3
Thread-0 --> 1
Thread-0 --> 2
Thread-0 --> 3
Thread-1 --> 1
Thread-1 --> 2
Thread-1 --> 3
main --> 1
main --> 2
main --> 3
main --> 4
main --> 5
main --> 6
main --> 7
main --> 8
main --> 9
结论:可以发现,static的ThreadLocal变量是一个与线程相关的静态变量,即一个线程内,static变量是被各个实例共同引用的,但是不同线程内,static变量是隔开的。
四、时间篇
1. LocalDateTime的使用
// 获取当前时间
LocalDateTime now = LocalDateTime.now();// 获取指定时间
LocalDateTime localDateTime = LocalDateTime.of(2021, 6, 16, 16, 37, 20, 814 * 1000 * 1000);
LocalDateTime ldt = LocalDateTime.now().withYear(2021).withMonth(6).withDayOfMonth(16).withHour(10).withMinute(10).withSecond(59).withNano(999 * 1000 * 1000);// 获取指定时区时间
LocalDateTime datetime = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
LocalDateTime datetime2 = LocalDateTime.now(ZoneId.of("+8"));// 获取年月日信息
LocalDateTime now = LocalDateTime.now();
int year = now.getYear();
int month = now.getMonthValue();
int dayOfYear = now.getDayOfYear();
int dayOfMonth = now.getDayOfMonth();
int hour = now.getHour();
int minute = now.getMinute();
int second = now.getSecond();
int nano = now.getNano();// 日期计算
LocalDateTime now = LocalDateTime.now();
LocalDateTime tomorrow = now.plusDays(1L);
tomorrow = tomorrow.plusHours(2L);
tomorrow = tomorrow.plusMinutes(10L);LocalDateTime yesterday = now.minus(Duration.ofDays(1));
yesterday = yesterday.plusHours(2L);
yesterday = yesterday.plusMinutes(10L);// 时间格式化,DateTimeFormatter是线程安全的类。
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = LocalDateTime.now().format(df);
2. String、Date、LocalDateTime转换
// LocalDateTime转Date
public static Date localDateTime2Date(LocalDateTime localDateTime) {return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}// LocalDateTime转String
private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public static String localDateTime2String(LocalDateTime localDateTime) {return localDateTime.format(DATE_TIME_FORMATTER);
}// String 转 LocalDateTime,DateTimeFormatter是线程安全的类,可以将此类放到常量中。
private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
public static LocalDateTime string2LocalDateTime(String str) {return LocalDateTime.parse(str, DATE_TIME_FORMATTER);
}// String 转 Date,SimpleDateFormat是非线程安全的类,在多线程操作时会报错。
public static Date string2Date(String str) throws ParseException {SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");return simpleDateFormat.parse(str);
}// Date 转 LocalDateTime
public static LocalDateTime date2LocalDateTime(Date date) {return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}// Date 转 String
public static String date2String(Date date) {SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");return formatter.format(date);
}
五、控制块
1. switch
public class SwitchString {public static void main(String[] args) {method("sth");}public static void method(String param) {// 1. 当 switch 括号内的变量类型为 String 并且为外部参数时,必须先进行 null判断。if(StringUtils.isEmpty(param)){return;}switch(param){case"sth": System.out.printin("it's sth"); break;case"sb": System.out.println("it's sb"); break;// 2. 在一个 switch 块内,都必须包含一个 default语句并且放在最后default: System.out.println("default"); break;}}
}
2. 三目运算
三目运算符 condition? 表达式 1 : 表达式 2 中,高度注意表达式 1 和 2 在类型对齐 时,可能抛出因自动拆箱导致的 NPE 异常。
// 反例
Integer a = 1;
Integer b = 2;
Integer c = null;
Boolean flag = false;
// a*b 的结果是 int 类型,那么 c 会强制拆箱成 int 类型,抛出 NPE 异常
Integer result=(flag? a*b : c);
3. 循环体
1. 循环体中的语句要考量性能,以下操作尽量移至循环体外处理,如定义对象、变量、 获取数据库连接,进行不必要的 try-catch 操作(这个 try-catch 是否可以移至循环体外)
4. try-catch-finally-return
- return的执行优先级高于finally的执行优先级,但是return语句执行完毕之后并不会马上结束函数,而是将结果保存到栈帧中的局部变量表中,然后继续执行finally块中的语句;
- 如果finally块中包含return语句,则不会对try块中要返回的值进行保护,而是直接跳到finally语句中执行,并最后在finally语句中返回,返回值是在finally块中改变之后的值
// return 1
public static int test1() {int x = 1;try {return x;} finally {x = 2;}
}// return 2
public static int test2() {int x = 1;try {return x;} finally {x = 2;return x;}
}
六、其他
1. 正则表达式
在使用正则表达式时,利用好其预编译功能,可以有效加快正则匹配速度。
// 反例
public void addSyncConfigToCache(String configName, ESSyncConfig config) {Pattern pattern = Pattern.compile(".*:(.*)://.*/(.*)\\?.*$");Matcher matcher = pattern.matcher(dataSource.getUrl());
}// 正例
private static final Pattern pattern = Pattern.compile(regexRule);
public void addSyncConfigToCache(String configName, ESSyncConfig config) {Matcher matcher = pattern.matcher(dataSource.getUrl());
}
2. BeanUtil的copy
Apache BeanUtils 性能较差,可以使用其他方案比如 Spring BeanUtils, Cglib BeanCopier,注意
均是浅拷贝。
Person source = Person("Alice", 25);
Person destination = new Person();
BeanUtils.copyProperties(destination, source);