SimonFeng的木屋

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: smionf
 * @Date: 2024/04/19/16:40
 * @Description:
 */
public class LC27RemoveElement {
    public static int removeElement(int[] nums, int val) {
        int[] newNums = new int[nums.length];
        int count = 0,j=0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == val) {
                count++;
                continue;
            }
            newNums[j]=nums[i];
            j++;
        }
        nums = newNums;

        return nums.length-count;
    }

    public static void main(String[] args) {
        int[] nums = {3,2,2,3};
        int lg = removeElement(nums, 3);
        System.out.println(lg);
        System.out.println("------------");
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

public class Test{
     
    String str = new String("good");
    char[] ch = {'a','b','c'};
    int i = 10;
    public void change(String str,char ch,int i){
     
        str = "test ok";
        ch = 'g';
        this.i = i+1;   
    }
     
    public static void main(String[] args){
     
        Test tt = new Test();
        tt.change(tt.str,tt.ch[0],tt.i);
        System.out.println(tt.i);
        System.out.print(tt.str+" and ");
        System.out.println(tt.ch);    
    }
}

11

good and abc

package com.simonf.array;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: smionf
 * @Date: 2024/04/19/16:40
 * @Description:
 */
public class LC27RemoveElement {
    public static int removeElement(int[] nums, int val) {
        int slowIndex = 0;//新数值元素的更新位置
        int fastIndex ;
        for (fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] == val) {
                continue;
            }
            nums[slowIndex] = nums[fastIndex];
            slowIndex++;
        }
        return slowIndex;
    }

    public static void main(String[] args) {
        int[] nums = {3, 2, 2, 3};
        int lg = removeElement(nums, 3);
        System.out.println(lg);
        System.out.println("------------");
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }


}

System.out.println(8>>1); //4 相当于8%(2^1)
System.out.println(8>>2); //2 相当于8%(2^2)
System.out.println(8>>3); //1 相当于8%(2^3)
System.out.println(2<<1); //4 相当于2*(2^1)
System.out.println(2<<2); //8 相当于2*(2^2)
System.out.println(2<<3); //16 相当于2*(2^3)

//  获取请求对象
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
//  转化为ServletRequestAttributes
ServletRequestAttributes sra = (ServletRequestAttributes) requestAttributes;
//  获取到HttpServletRequest 对象
HttpServletRequest request = sra.getRequest();
//	获取到HttpServletResponse 对象
HttpServletResponse response = sra.getResponse();

public abstract class RequestContextHolder {
    // 得到存储进去的request
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal("Request attributes");
    //可被子线程继承的reques
    private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder = new NamedInheritableThreadLocal("Request context");			

@Nullable
public static RequestAttributes getRequestAttributes() {
    RequestAttributes attributes = (RequestAttributes)requestAttributesHolder.get();
    if (attributes == null) {
        attributes = (RequestAttributes)inheritableRequestAttributesHolder.get();
    }
    return attributes;
}

io.minio.errors.ErrorResponseException: The difference between the request time and the server's time is too large.

package com.atguigu.demojuc.chap08;

public class ThreadPoolDemo {

    public static void main(String[] args) {


        //1、基本使用
        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单一线程池
        //ExecutorService threadPool = Executors.newFixedThreadPool(3); //固定大小线程池

        //可以在线程中设置一下睡眠时间控制承受并发的能力（调整睡眠时间长短看效果）
        //ExecutorService threadPool = Executors.newCachedThreadPool(); // 无限大小线程池（遇强则强）

        try {
            for (int i = 0; i < 1000; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName() + "开始执行业务逻辑");
                    try {
                        TimeUnit.MILLISECONDS.sleep(50);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "结束");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

package com.atguigu.jucdemo.chap08;

public class ScheduledThreadPoolDemo {

    public static void main(String[] args) {

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println(new Date());

        try {

            for (int i = 0; i < 10; i++) {
                //延迟执行
                scheduledThreadPool.schedule(()->{
                    System.out.println(Thread.currentThread().getName() + " 定时任务被执行" + new Date());
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }, 5, TimeUnit.SECONDS);
            }

        } finally {
            scheduledThreadPool.shutdown();
        }
    }
}

package com.atguigu.jucdemo.chap08;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledAtFixRateDemo {

    public static void main(String[] args) {

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println(new Date());

        //try {

            for (int i = 0; i < 10; i++) {
                //延迟执行
                scheduledThreadPool.scheduleAtFixedRate(()->{
                    System.out.println(Thread.currentThread().getName() + " 定时任务被执行" + new Date());
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }, 5, 1, TimeUnit.SECONDS);
            }

        /*} finally {
            scheduledThreadPool.shutdown(); //不要销毁这个对象，因为任务会一直执行
        }*/
    }
}

package com.atguigu.demojuc.chap08;

class MyRunnable implements Runnable{

    private int param;

    public MyRunnable(int param) {
        this.param = param;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +  " Runnable......" + param);
    }
}

public class CustomizeThreadPoolDemo {

    public static void main(String[] args) {

        // 自定义连接池
        ExecutorService threadPool = new ThreadPoolExecutor(2, 5,
                2, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() //丢弃任务并抛出异常
                //new ThreadPoolExecutor.CallerRunsPolicy() //由调用线程处理该任务，谁调用谁处理
                //new ThreadPoolExecutor.DiscardOldestPolicy() //丢弃队列中等待最久的任务，添加新任务
                //new ThreadPoolExecutor.DiscardPolicy() //也是丢弃任务，但是不抛出异常。 
                /*new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.out.println("自定义拒绝策略");
                    }
                }*/
        );

        try {
            for (int i = 0; i < 9; i++) {
                threadPool.execute(() -> {
                    //threadPool.submit(() -> { //这里也可以使用submit
                    System.out.println(Thread.currentThread().getName() + "执行了业务逻辑");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }

    }
}