发表更新java28 分钟读完 (大约4262个字)

java 多态 Polymorphic

简述

多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。
多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。用白话来说，就是多个对象调用同一个方法，得到不同的结果。

多态的语法格式

父类类名 引用名称 = new 子类类名();

当是多态时，该引用名称只能访问父类中的属性和方法，但是访问的时候，会优先访问子类重写以后的方法。

阅读更多
发表更新java20 分钟读完 (大约3037个字)

java 泛型 Generics

简述

泛型就是定义一种模板，例如ArrayList，然后在代码中为用到的类创建对应的ArrayList<类型>：

1
2
3
4
5
6
7
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

阅读更多
发表更新java1 分钟读完 (大约114个字)

读取txt文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ReadFileByLines {
	public static void main(String[] args) {
		try {
			//1.打开一个file
			File file = new File("E:/test.txt");
			//2.InputStreamReader<-FileInputStream<-file
			FileInputStream fis = new FileInputStream(file);
			InputStreamReader is = new InputStreamReader(fis);
			//3.用BufferedReader(<-InputStreamReader)的readLine()方法读取
			BufferedReader br = new BufferedReader(is);

			//4.输出
			String txtLine = null;
			while ((txtLine = br.readLine()) != null) {
				System.out.println(txtLine);
			}
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ReadFileByLines {
	public static void main(String[] args) {
		try {
			
			File file = new File("E:/test.txt");
			
			BufferedReader br = new BufferedReader(new FileReader(file));
			
			String txtLine = null;
			while ((txtLine = br.readLine()) != null) {
				System.out.println(txtLine);
			}
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
发表更新java1 分钟读完 (大约199个字)

bind header to controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import javax.servlet.http.HttpServletRequest;

import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import lombok.extern.slf4j.Slf4j;
import summer.webserver.util.SummerUtils;

@Slf4j
public class SummerArgumentResolver implements HandlerMethodArgumentResolver {

	public SummerArgumentResolver() {
		super();
	}

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return SummerHeader.class.isAssignableFrom(parameter.getParameterType());
	}

	@Override
	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
		NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
		return SummerUtils.getSummerHeader(webRequest.getNativeRequest(HttpServletRequest.class));
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Slf4j
public class SummerUtils {
	public static SummerHeader getSummerHeader(HttpServletRequest request) {
		User user = (User)request.getAttribute("user");
		String userName = Objects.isNull(user) ? request.getHeader(USER_NAME) : user.getUserName();
		String userId = Objects.isNull(user) ? request.getHeader(USER_ID) : user.getUserId();
		SummerHeader summerHeader = SummerHeader.builder()
			.userName(userName)
			.userId(userId)
			.build();

		if (log.isDebugEnabled()) {
			log.debug(summerHeader.toString());
		}
		request.setAttribute("summerHeader", summerHeader);
		return summerHeader;
	}
}

usage

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Api(tags = "User")
@RestController()
@RequestMapping(ROOT_DOMAIN + "/users")
@Slf4j
public class UserController {
	@ApiOperation(value = "delete user")
	@DeleteMapping("/{user-id}")
	@ResponseStatus(HttpStatus.OK)
	public void deleteUser(SummerHeader summerHeader,
		@ApiParam(required = true) @Length(max = 10) @PathVariable(value = "user-id") String userId) {
		userMapper.deleteById(userId);
	}
}
发表更新java2 分钟读完 (大约328个字)

some parameters that only one is not null valid

注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomValid {

}

@Documented
@Constraint(validatedBy = OnlyOneNotNullValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface OnlyOneNotNull {

	String message() default "only one filed should not be null";

	Class<?>[] groups() default {};

	Class<? extends Payload>[] payload() default {};

	String[] fieldNames();

}
阅读更多
发表更新java1 分钟读完 (大约154个字)

时间格式 注解 验证

EnumValid.java

1
2
3
4
5
6
7
8
9
10
11
12
13

@Constraint(validatedBy = DateFormatValidator.class)
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DateFormat {
	String message() default "";

	String pattern() default "yyyy-MM-dd HH:mm:ss";

	Class<?>[] groups() default {};

	Class<? extends Payload>[] payload() default {};
}
阅读更多
发表更新java2 分钟读完 (大约245个字)

枚举类型参数验证

EnumValid.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Documented
@Constraint(validatedBy = EnumValidator.class)
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface EnumValid {

	Class<? extends Enum<?>> enumClass();

	String message() default "invalid enum item value.";

	Class<?>[] groups() default {};

	Class<? extends Payload>[] payload() default {};
}
阅读更多
发表更新java5 分钟读完 (大约809个字)

GC算法 垃圾收集器

概述

jvm 中，程序计数器、虚拟机栈、本地方法栈都是随线程而生随线程而灭，栈帧随着方法的进入和退出做入栈和出栈操作，实现了自动的内存清理。

因此，我们的内存垃圾回收主要集中于 **java 堆和方法区中**，在程序运行期间，这部分内存的分配和使用都是动态的.

对象存活判断

判断对象是否存活一般有两种方式：

引用计数：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，无法解决对象相互循环引用的问题。

可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。

在Java语言中，GC Roots包括：

  • 虚拟机栈中引用的对象。
  • 方法区中类静态属性实体引用的对象。
  • 方法区中常量引用的对象。
  • 本地方法栈中JNI引用的对象。

垃圾收集算法

标记 -清除算法

“标记-清除”（Mark-Sweep）算法，如它的名字一样，算法分为“标记”和“清除”两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。之所以说它是最基础的收集算法，是因为后续的收集算法都是基于这种思路并对其缺点进行改进而得到的。

它的主要缺点有两个：一个是效率问题，标记和清除过程的效率都不高；另外一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

  1. Getting Started with the G1 Garbage Collector
  2. The Garbage First Garbage Collector
  3. 垃圾优先型垃圾回收器调优
  4. Java Hotspot G1 GC的一些关键技术
  5. 一步步图解G1
  6. 徹底解剖「G1GC」実装編
  7. Part 1: Introduction to the G1 Garbage Collector
  8. Collecting and reading G1 garbage collector logs - part 2

    参考文章

关注我

分类

标签

Kruskal1
Object Storage1
RocketMQ1
WebSockets1
ansible7
centos11
cocos1
cubrid1
dijkstra1
docker12
docker compose6
dubbo1
elasticsearch1
filebeat1
flink1
gc1
git4
go1
graph1
hexo5
http-server1
j.u.c7
java31
java锁2
jdk1
jedis3
js1
jvm2
kafka5
kibana1
kubernetes8
leetcode10
lettuce3
linux7
logstash1
maven1
metrics3
mongodb2
mq1
mybatis-plus1
mysql6
netty3
network1
nginx13
opencv2
oracle2
pulsar1
python2
quarkus1
reactive4
redis5
spring27
spring batch1
springdoc2
springfox1
study1
tomcat1
ubuntu4
unity1
unreal1
vmware5
volatile2
webflux3
wsl7
zookeeper1
串1
二分查找2
优先队列1
动态规划8
堆1
拦截/抓包工具2
数据结构和算法10
树2
链表4

最新文章

×