超级大师个人笔记

C+V工程师

已于 2022-06-09 11:39:56 修改

阅读量193

点赞数

文章标签： java

于 2021-10-29 18:22:51 首次发布

本文链接：https://blog.csdn.net/hdnhsf/article/details/121040191

版权

个人学习笔记

java

字符串替换

public static void main(String[] args) {
        String a = "5%";
        String s = a.replaceAll("%", "");
        System.out.println(s);
    }

ToCharArray( )的用法，将字符串对象中的字符转换为一个字符数组。
下标从0开始

	String s = "(){}[]";
        for(char item :s.toCharArray()){
            System.out.println(item);
        }

Trim（）去除开头结尾空格

Trim是String型数据的一个方法，作用是去掉字符串开头和结尾的空格，比如说字符串a=“__a”，其中_表示一个空格，那么a.Trim() = “a”，字符串前后的空格都被清掉了。调用这个方法后，a的值是不变的，也就是说，虽然a.Trim() = “a”，但a="__a"还是成立的。

Stack对象

Stack类的主要方法是:push(),peek(),pop(),empty(),search().

push() - 在栈顶添加元素
peek() - 返回栈顶的元素，但是不删除栈顶元素
pop() - 和peek()一样返回栈顶元素，但是要将栈顶元素移除掉
empty() - 检查栈是否为空
search() - 返回元素在堆栈中的位置

Stack<Character> temp = new Stack<>();

Character类

在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。以确定字符的类别（小写字母，数字，等等）

Character类的判断功能:

//确定指定字符是否为数字。
public static boolean isDigit(char ch)
// 确定指定字符是否为字母。
public static boolean isLetter(char ch)
//确定是否是小写字母字符
public static boolean isLowerCase(char ch)
//确定是否大写字母字符
public static boolean isUpperCase(char ch)

两个转换功能:

//使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。
public static int toLowerCase(char ch)
//使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
public static int toUpperCase(char ch)

算法题

 public static void main(String[] args) {

        String s = "([])";
        String bboo = "falst";
        if(s == null){
            bboo = "falst";
        }
        Stack<Character> temp = new Stack<>();
        for(char item :s.toCharArray()){
            if(item == '['){
                temp.push(']');
            }else if(item == '{'){
                temp.push('}');
            }else if(item == '('){
                temp.push(')');
            }else if(temp.isEmpty() || temp.pop() != item){
                //如果 还有数据 并且不是 [ { (  ,那么temp就是空的，不符合要求，或者弹出的元素不等于当前的 也不是
                bboo = "falst";
            }
        }
        System.out.println(temp);
        if(temp.isEmpty()){
            bboo = "true";
        }
        System.out.println(bboo);
//        return temp.isEmpty();

    }

获取时间

//现在时间
        Date date = new Date();
        Instant instant = date.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime newDate = instant.atZone(zoneId).toLocalDateTime();
        //七天前
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 7);
        Date today = calendar.getTime();
        Instant instants = today.toInstant();
        ZoneId zoneIds = ZoneId.systemDefault();
        LocalDateTime before = instants.atZone(zoneIds).toLocalDateTime();

list去重

        List<String> a = new ArrayList<> ();
        a.add("a");
        a.add("b");
        a.add("b");
        a.add("b");
        a.add("b");
        a.add("b");
        a.add("b");
        a.add("b");

        List list=(List) a.stream().distinct().collect(Collectors.toList());
        System.out.println(list);

										[a, b]

String 转map

Map<String , Object> map = JSONArray.parseObject(resultJson);

对象转map

#YtScoreApprova对象 
Map<Long, YtScoreApprova> map1 = selScoreApprovaAllCity.stream().collect(Collectors.toMap(YtScoreApprova ::getId, YtScoreApprova -> YtScoreApprova));

转换

//合并数据
        selScoreApprovaAll1.forEach(n -> {
            if(map1.containsKey(n.getId())){
                YtScoreApprova ytScoreApprova = map1.get(n.getId());
                n.setCity(ytScoreApprova.getCity());
            }
        });

Stream

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;
 
public class Java8Tester {
   public static void main(String args[]){
      System.out.println("使用 Java 7: ");
 
      // 计算空字符串
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("列表: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
 
      System.out.println("空字符数量为: " + count);
      count = getCountLength3UsingJava7(strings);
 
      System.out.println("字符串长度为 3 的数量为: " + count);
 
      // 删除空字符串
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("筛选后的列表: " + filtered);
 
      // 删除空字符串，并使用逗号把它们合并起来
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("合并字符串: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 
      // 获取列表元素平方数
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("平方数列表: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
 
      System.out.println("列表: " +integers);
      System.out.println("列表中最大的数 : " + getMax(integers));
      System.out.println("列表中最小的数 : " + getMin(integers));
      System.out.println("所有数之和 : " + getSum(integers));
      System.out.println("平均数 : " + getAverage(integers));
      System.out.println("随机数: ");
 
      // 输出10个随机数
      Random random = new Random();
 
      for(int i=0; i < 10; i++){
         System.out.println(random.nextInt());
      }
 
      System.out.println("使用 Java 8: ");
      System.out.println("列表: " +strings);
 
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("空字符串数量为: " + count);
 
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("字符串长度为 3 的数量为: " + count);
 
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("筛选后的列表: " + filtered);
 
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("合并字符串: " + mergedString);
 
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("列表: " +integers);
 
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
 
      System.out.println("列表中最大的数 : " + stats.getMax());
      System.out.println("列表中最小的数 : " + stats.getMin());
      System.out.println("所有数之和 : " + stats.getSum());
      System.out.println("平均数 : " + stats.getAverage());
      System.out.println("随机数: ");
 
      random.ints().limit(10).sorted().forEach(System.out::println);
 
      // 并行处理
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("空字符串的数量为: " + count);
   }
 
   private static int getCountEmptyStringUsingJava7(List<String> strings){
      int count = 0;
 
      for(String string: strings){
 
         if(string.isEmpty()){
            count++;
         }
      }
      return count;
   }
 
   private static int getCountLength3UsingJava7(List<String> strings){
      int count = 0;
 
      for(String string: strings){
 
         if(string.length() == 3){
            count++;
         }
      }
      return count;
   }
 
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings){
      List<String> filteredList = new ArrayList<String>();
 
      for(String string: strings){
 
         if(!string.isEmpty()){
             filteredList.add(string);
         }
      }
      return filteredList;
   }
 
   private static String getMergedStringUsingJava7(List<String> strings, String separator){
      StringBuilder stringBuilder = new StringBuilder();
 
      for(String string: strings){
 
         if(!string.isEmpty()){
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }
 
   private static List<Integer> getSquares(List<Integer> numbers){
      List<Integer> squaresList = new ArrayList<Integer>();
 
      for(Integer number: numbers){
         Integer square = new Integer(number.intValue() * number.intValue());
 
         if(!squaresList.contains(square)){
            squaresList.add(square);
         }
      }
      return squaresList;
   }
 
   private static int getMax(List<Integer> numbers){
      int max = numbers.get(0);
 
      for(int i=1;i < numbers.size();i++){
 
         Integer number = numbers.get(i);
 
         if(number.intValue() > max){
            max = number.intValue();
         }
      }
      return max;
   }
 
   private static int getMin(List<Integer> numbers){
      int min = numbers.get(0);
 
      for(int i=1;i < numbers.size();i++){
         Integer number = numbers.get(i);
 
         if(number.intValue() < min){
            min = number.intValue();
         }
      }
      return min;
   }
 
   private static int getSum(List numbers){
      int sum = (int)(numbers.get(0));
 
      for(int i=1;i < numbers.size();i++){
         sum += (int)numbers.get(i);
      }
      return sum;
   }
 
   private static int getAverage(List<Integer> numbers){
      return getSum(numbers) / numbers.size();
   }
}

//结果
$ javac Java8Tester.java
$ java Java8Tester
使用 Java 7:
列表: [abc, , bc, efg, abcd, , jkl]
空字符数量为: 2
字符串长度为 3 的数量为: 3
筛选后的列表: [abc, bc, efg, abcd, jkl]
合并字符串: abc, bc, efg, abcd, jkl
平方数列表: [9, 4, 49, 25]
列表: [1, 2, 13, 4, 15, 6, 17, 8, 19]
列表中最大的数 : 19
列表中最小的数 : 1
所有数之和 : 85
平均数 : 9
随机数:
-393170844
-963842252
447036679
-1043163142
-881079698
221586850
-1101570113
576190039
-1045184578
1647841045
使用 Java 8:
列表: [abc, , bc, efg, abcd, , jkl]
空字符串数量为: 2
字符串长度为 3 的数量为: 3
筛选后的列表: [abc, bc, efg, abcd, jkl]
合并字符串: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
列表: [1, 2, 13, 4, 15, 6, 17, 8, 19]
列表中最大的数 : 19
列表中最小的数 : 1
所有数之和 : 85
平均数 : 9.444444444444445
随机数:
-1743813696
-1301974944
-1299484995
-779981186
136544902
555792023
1243315896
1264920849
1472077135
1706423674
空字符串的数量为: 2

mybatis-plus使用

继承 service 、mapper

Mapper层

在这里插入图片描述

请添加图片描述

分页查询

public Map<String, Object> selCheckInApprovesaa(Integer current, Integer size) {
        //分页
        IPage page = new Page();
        page.setCurrent(current);//当前页
        page.setSize(size);//页大小
        //mybatis-plus sql条件
        LambdaQueryWrapper<VillageArea> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.in(VillageArea::getId, 1234567891234567813L, 1234567891234567891L);
        //分页查询
        IPage page1 = iVillageAreaService.page(page,lambdaQueryWrapper);
        Map<String , Object> map = new HashMap<>();
        map.put("page",page1);
        return map;
    }

定时任务

	cron表达式
	@Scheduled(cron = "0 0/30 * ? * ?")
    private void test(){
		System.out.println("定时任务执行");
    }

发送http POST/GET请求

try {
            List<NameValuePair> param = new ArrayList<NameValuePair>();
            //参数K/V
            param.add(new BasicNameValuePair("K", "V"));
            CloseableHttpClient client = getHttpsClient();
            HttpPost post = new HttpPost(uploadUrl);
            post.setEntity(new UrlEncodedFormEntity(param,Consts.UTF_8));
            try {
                CloseableHttpResponse xx = client.execute(post);
                if(HttpStatus.SC_OK == xx.getStatusLine().getStatusCode()) {
                    String result = EntityUtils.toString(xx.getEntity(), Consts.UTF_8);
                    logger.info("---返回结果：" + result);
                }
            } catch (ClientProtocolException e) {
                e.printStackTrace();
            }
        }catch (Exception e){
            e.printStackTrace();
        }

单例模式

1、懒汉式
非线程安全的

public class LHSHI {
	// 指向自己实例的私有静态引用
    private static LHSHI instance;
	//私有构造方法
    private LHSHI(){}
	// 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static LHSHI getInstance(){
    	// 被动创建，在真正需要使用时才去创建
        if (instance == null){
            instance = new LHSHI();
        }
        return instance;
    }

}

2、饿汉式
是线程安全的

public class EHSHI {
	// 指向自己实例的私有静态引用，主动创建
    private static EHSHI instance = new EHSHI();
	//私有构造方法
    private EHSHI(){}
	// 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static EHSHI getInstance(){
        return instance;
    }
}

多线程（笔记）

进程/Process（进程包含多个线程）

进程是指令和数据的有序结合，本身没有任何运行的含义，是一个静态的概念
进程则是执行程序的一次执行过程，他是一个动态的概念，是系统分配资源的单位
通常在一个进程中包含多个线程，一个进程中至少包含一个线程，不然就没有意义，线程是CPU调度和执行的单位

很多多线程是模拟出来的。真正的多线程是指多个CPU，及多核，如任务器，若果是模拟出来的线程，即在一个CPU的情况下在同一时间点CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉

线程/Thread

创建线程

继承Thread类
实现Runnable接口
实现Callable接口

继承Thread类

1继承Thread类
2.重写run方法
3.创建线程对象，调用start()方法启动线程

：注意线程开启不一定立即执行由CPU调度执行

/**
 * @author qjy
 * @Explanation
 * @create 2022-02-14 11:31
 */
//继承Thread
public class MyThread extends Thread {

    //重写run方法
    public void run(){
        for (int i=0 ; i<10 ; i++){
            System.out.println("执行run线程:"+i);
        }
    }

    //调用start()启动线程
    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread1 = new MyThread();
        //调用start()方法开启线程
        myThread1.start();
    }

}

实现Runnable接口

1.定义MyThread类实现Runnable接口
2.实现润方法编写线程知兴替
3.创建线程对象调用start()方法启动线程

/**
 * @author qjy
 * @Explanation
 * @create 2022-02-14 11:31
 */
//实现Runnable接口
public class MyThread implements Runnable {

    //重写run方法
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread1 = new MyThread();
        //创建线程对象开启线程
        new Thread(myThread1).start();
    }

}

mysql

mysql获取指定天数前的数据

SELECT * from 表明
WHERE now() > date_add(字段, interval 天数 day)

SELECT * from user
WHERE now() > date_add(addtime, interval 7 day)

创建用户并赋予最高权限

CREATE USER 'admin'@'%' IDENTIFIED BY 'pwd';
GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;

中间件

MySQL启动命令

docker run -itd --name mysql -p 3306:3306 -e JVM_XMS=40m -e JVM_XMX=80m -e MYSQL_ROOT_PASSWORD=root mysql

RabbitMQ启动命令

docker run -dit --name rabbitmq -e JVM_XMS=30m -e JVM_XMX=60m -e RABBITMQ_DEFAULT_USER=guest -e RABBITMQ_DEFAULT_PASS=guest -p 15672:15672 -p 5672:5672 rabbitmq:management

Redis启动命令

docker run -itd --name redis -p 6379:6379 -e JVM_XMS=40m -e JVM_XMX=80m redis

Nacos启动命令

docker run -d --name nacos -p 8848:8848 -p 9848:9848 -p 9849:9849 --restart=always -e JVM_XMS=128m -e JVM_XMX=128m -e MODE=standalone -e SPRING_DATASOURCE_PLATFORM=mysql -e MYSQL_SERVICE_HOST=101.33.243.233 -e MYSQL_SERVICE_PORT=3306 -e MYSQL_SERVICE_DB_NAME=ry-config -e MYSQL_SERVICE_USER=root -e MYSQL_SERVICE_PASSWORD=root -e MYSQL_SERVICE_DB_PARAM="useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8" nacos/nacos-server

MongoDb启动命令

docker run -itd --name mongo -p 27017:27017 -e JVM_XMS=40m -e JVM_XMX=80m mongo --auth

nginx配置文件


nginx配置文件

```bash
worker_processes  1;

events {
    worker_connections 1024;
}

http {

    include       mime.types;
    default_type  application/octet-stream;

    server {
        listen       80;
        server_name  www.cosmefancy.com;
        location / {
            proxy_pass   https://www.cosmefancy.com/;
        }
   #转发到后端
        location ^~/api/ {
            proxy_buffer_size 128k;
            proxy_buffers 32 32k;
            proxy_busy_buffers_size 128k;
            proxy_pass http://127.0.0.1:7999/;
            proxy_set_header Host $host;
        }
    }
    server {
         listen       443 ssl;
        server_name www.aaaa.com;域名
        //配置ssl安全证书
        ssl_certificate  /mydata/nginx/cert/6774528_www.cosmefancy.com.pem;
        ssl_certificate_key  /mydata/nginx/cert/6774528_www.cosmefancy.com.key;
        ssl_session_timeout 5m;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        include /etc/nginx/default.d/*.conf;
        #转发到前端
         location / {
            root   /var/www/cosmefancy.com/static;
            index index.html index.htm;
        }  
        
        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
	配置子配置文件
    include /etc/nginx/conf.d/nginx2.conf;

}

================子配置文件================

server {
         listen       443 ssl;
        server_name www.aaaa.com;域名
        //配置ssl安全证书
        ssl_certificate  /mydata/nginx/cert/7037828_pay.cosmefancy.com.pem;
        ssl_certificate_key  /mydata/nginx/cert/7037828_pay.cosmefancy.com.key;
        ssl_session_timeout 5m;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        include /etc/nginx/default.d/*.conf;
		//转发到那里
         location / {
           proxy_buffer_size 128k;
            proxy_buffers 32 32k;
            proxy_busy_buffers_size 128k;
            proxy_pass http://49.51.245.82:7999/;
            proxy_set_header Host $host;
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
}

部署项目到docker

dockerfile

//设置环境
FROM java:8
//过滤文件
ADD /*.yml //
ADD /*.jar //
ADD /*.crt //
ADD /*.key //
//设置镜像并赋予空间内存
ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=prod", "-Xms512m","-Xmx512m","/mall-portal-1.0-SNAPSHOT.jar"]

run.sh启动脚本

#!/usr/bin/env bash
//镜像名称
app_name='mall-portal'
docker stop ${app_name}
echo '----stop container----'
//删除镜像
docker rm ${app_name}
echo '----rm container----'
//删除容器
docker rmi `docker images | grep none | awk '{print $3}'`
echo '----rm none images----'
//build创建新的镜像
docker build -t ${app_name} .
//启动镜像并设置端口
docker run -p 8085:8085 --name ${app_name} \
-e TZ="Asia/Shanghai" \
-v /etc/localtime:/etc/localtime \
-v /mydata/app/${app_name}/logs:/var/logs \
-d ${app_name}
echo '----start container----'