Synchronized 和 Lock的概念主要概念🍑
Synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized 的目的是一次只允许一个线程进入由他修饰的代码段，从而允许他们进行自我保护。Synchronized 很像生活中的锁例子，进入由Synchronized 保护的代码区首先需要获取 Synchronized 这把锁，其他线程想要执行必须进行等待。Synchronized 锁住的代码区域执行完成后需要把锁归还，也就是释放锁，这样才能够让其他线程使用。
Lock 是 Java并发编程中很重要的一个接口，它要比 Synchronized 关键字更能直译"锁"的概念，Lock需要手动加锁和手动解锁，一般通过 lock.lock() 方法来进行加锁， 通过 lock.unlock() 方法进行解锁。与 Lock 关联密切的锁有 ReetrantLock 和 ReadWriteLock。
ReetrantLock 实现了Lock接口，它是一个可重入锁，内部定义了公平锁与非公平锁。
ReadWriteLock 一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。ReentrantReadWirteLock实现了ReadWirteLock接口，并未实现Lock接口。
Synchronized 和 Lock 的使用
下面是 Synchronized 的例子:
在方法上使用 Synchronized 方法声明时使用，放在范围操作符之后,返回类型声明之前。即一次只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候。
private int number; public synchronized void numIncrease(){ number++; } 复制 在某个代码段使用 Synchronized 你也可以在某个代码块上使用 Synchronized 关键字，表示只能有一个线程进入某个代码段。 public void numDecrease(Object num){ synchronized (num){ number++; } } 复制 使用 Synchronized 锁住整个对象 synchronized后面括号里是一对象，此时线程获得的是对象锁。 public void test() { synchronized (this) { // ... } }
什么是跨域问题?
跨域问题指的是不同站点之间，使用 ajax 无法相互调用的问题。跨域问题本质是浏览器的一种保护机制，它的初衷是为了保证用户的安全，防止恶意网站窃取数据。 但这个保护机制也带来了新的问题，它的问题是给不同站点之间的正常调用，也带来的阻碍，那怎么解决这个问题呢？接下来我们一起来看。
1.跨域三种情况
在请求时，如果出现了以下情况中的任意一种，那么它就是跨域请求：
- 协议不同，如 http 和 https；
- 域名不同；
- 端口不同。 也就是说，即使域名相同，如果一个使用的是 http，另一个使用的是 https，那么它们也属于跨域访问。
解决跨域问题
在 Spring Boot 中跨域问题有很多种解决方案，比如以下 5 个：
- 使用 @CrossOrigin 注解实现跨域；
- 通过配置文件实现跨域；
- 通过 CorsFilter 对象实现跨域；
- 通过 Response 对象实现跨域；
- 通过实现 ResponseBodyAdvice 实现跨域。
mybaitsPlus的分页方式有很多，以下就简单介绍一下
两种都很方便，说明一下使用方法
1. 第一种代码展示
请求对象实体里需要定义page 和rows ，integer类型
@Override public PageInfo<RuRuleEntity> getRuleList(RuRuleReq request) { PageHelper.startPage(request.getPage(),request.getRows()); List<RuRuleEntity> list = baseMapper.selectAllRule(request); PageInfo<RuRuleEntity> pageInfo = new PageInfo<>(list); return pageInfo; }
单一List进行操作
public class StreamDemo { List<Student> list = null; //初始化数据 @Before public void beforetest() { list = Arrays.asList(new Student("Tom", 18, 88, 90), new Student("Jerry", 20, 77, 89), new Student("Lily", 17, 98, 79), new Student("Lucy", 19, 70, 80), new Student("LiLei", 18, 88, 90), new Student("HanMeiMei", 21, 87, 79)); } @Test public void streamtest() { // filter 过滤器返回还是一个stream流对象 //查询math成绩大于80的学生并遍历输出 list.stream().filter(e->e.getMath()>80).forEach(System.out::println);//.forEach(e->System.out.println(e)) //统计数量count System.out.println(list.stream().count()); //如统计总分大于160的人数 System.out.println(list.stream().filter(e->e.getEnglish()+e.getMath()>160).count()); //limit 取前n个值 list.stream().limit(3).forEach(System.out::println); //skip 跳过前n个 list.stream().skip(2).forEach(System.out::println); //distinct 去除重复数据 list.stream().distinct().forEach(System.out::println); //map 映射元素可以对元素进行操作 例如对每个学生年龄加1 list.stream().map(e->{ e.setAge(e.getAge()+1); return e; }).forEach(System.out::println); //sorted 排序 //升序 list.stream().sorted((a,b)->{ return a.getEnglish().compareTo(b.getEnglish()); }); //降序 list.stream().sorted((a,b)->{ return b.getEnglish().compareTo(a.getEnglish()); }); //返回第一个元素 Optional<Student> first = list.stream().findFirst(); System.out.println(first.get()); //返回任意一个元素 System.out.println(list.stream().findAny().get()); //anyMatch 是否匹配任意一元素 检查是否包含名字为Tom的 System.out.println(list.stream().anyMatch(e->e.getName().equals("Tom"))); //allMatch 是否匹配所有元素 System.out.println(list.stream().allMatch(e->e.getName().equals("Tom"))); //noneMatch 是否未匹配所有元素 System.out.println(list.stream().noneMatch(e->e.getName().equals("Tom"))); //findFirst 返回元素中第一个值 Student student = list.stream().findFirst().get(); //findAny 返回元素中任意一个值 Student student1 = list.stream().findAny().get(); //max 返回最大值 查询英语成绩最高的学生 Student student2 = list.stream().max((l1,l2)->l2.getEnglish().compareTo(l1.getEnglish())).get(); //min 最小值 将上面l1，l2位置对调 Student student3 = list.stream().max((l1,l2)->l2.getEnglish().compareTo(l1.getEnglish())).get(); //将流对象转为list list.stream().filter(e->e.getMath()>80).collect(Collectors.toList()); //将流转未set list.stream().filter(e->e.getMath()>80).collect(Collectors.toSet()); //对象中的某项进行统计 IntSummaryStatistics c = list.stream().collect(Collectors.summarizingInt(Student::getEnglish)); System.out.println(c); //IntSummaryStatistics{count=6, sum=507, min=79, average=84.500000, max=90} //获取list中的某两个元素 Map<String,String> map=list.Stream.collect(Collectors.toMap(Student::Name,Student::age)) //先过滤再获取list中的某两个元素 Map<String,String> map=list.Stream.filter(i->"张三".equals(i.getName)).collect(Collectors.toMap(Student::Name,Student::age))}} //把一个list对象的内容取出来，创建一个新的对象存进去，改为一个新的list List<StringSimilarityHanLPRequest> HanLPList=provinceDictEntities.stream().map(i->StringSimilarityHanLPRequest.builder().name(i.getOperProvinceName()).code(i.getOperProvinceCode()).build()).collect(Collectors.toList()); //将某个字符串对象取出转成字符串数组 String[] pictureIds = request.getSaveMetaDataMarkList().stream().map(i->i.getMarkPictureId()).toArray(String[]::new);
问题
经常看到基本数据类型存放位置的内容,有些就说基本类型都在栈中,有些说基本类型在堆中,这其实要分变量的类型来说明.
java基本数据类型是指byte, short, int, long, float, double, char, boolean这八种类型。它们的存放位置取决于它们的声明位置和作用域。一般来说，有以下几种情况：
如果基本数据类型是局部变量，那么它们存放在栈（stack）中。栈是每个线程独享的内存区域，用于存储方法调用时的参数和临时变量。栈中的变量随着方法的执行而创建和销毁，不需要垃圾回收。
如果基本数据类型是实例变量（也叫成员变量），那么它们存放在堆（heap）中。堆是所有线程共享的内存区域，用于存储对象和数组。堆中的变量随着对象的创建和销毁而分配和回收内存，需要垃圾回收。
如果基本数据类型是类变量（也叫静态变量），那么它们存放在方法区（method area）中。方法区也是所有线程共享的内存区域，用于存储类的信息，包括静态变量和常量。方法区中的变量随着类的加载和卸载而分配和回收内存，也需要垃圾回收。
下面是一些例子：
JAVAint a = 10; //局部变量，存放在栈中
class Test { int b = 20; //实例变量，存放在堆中 static int c = 30; //类变量，存放在方法区中 }
Test t = new Test(); //对象引用，存放在栈中，指向堆中的对象
int[] arr = new int[10]; //数组引用，存放在栈中，指向堆中的数组
