ini复制代码输入： num = 16
输出： true

ini复制代码输入： num = 14
输出： false

Kotlin复制代码class Solution {
    fun isPerfectSquare(num: Int): Boolean {
        var left = 0L
        var right = (num / 2).toLong() + 1
        var target = num.toLong()
        while (left <= right) {
            val mind: Long = (left + right) / 2
            val square = mind * mind
            when {
                square == target -> return true
                square < target -> left = mind + 1
                else -> right = mind - 1
            }
        }
        return false
    }
}

java复制代码public abstract sealed class Shape
    permits Circle, Polygon, OtherShape { ... }

public sealed class Circle extends Shape
    permits Round, Oval { ... }
public final class Round extends Circle { ... }
public final class Oval extends Circle { ... }

public sealed class Polygon extends Shape
    permits Triangle, Quadrilateral { ... }
public final class Triangle extends Polygon { ... }
public final class Quadrilateral extends Polygon { ... }

public non-sealed class OtherShape extends Shape { ... }

java复制代码module sealed_class_demo {
    exports org.example.sealed.package1;
    exports org.example.sealed.package2;
}

java复制代码public abstract sealed class SupperClass permits A, B, C {
}

public final class A extends SupperClass {
}

public final class B extends SupperClass {
}

public final class C extends SupperClass {
}

java复制代码public abstract sealed class SupperClass permits A, B, C {
}

public final class A extends SupperClass {
}

public final class B extends SupperClass {
}

public final class C extends SupperClass {
}

java复制代码public abstract sealed class SupperClass {
    final class A extends SupperClass{}
    final class B extends SupperClass{}
    final class C extends SupperClass{}
}

java复制代码// 密封类SupperClass 指定子类 A B C
public abstract sealed class SupperClass permits A, B, C {
}

// A不能被继承
public final class A extends SupperClass {
}

// B 继承SupperClass，并指定子类D
public sealed class B extends SupperClass permits D{
	
}

// D 继承B
public sealed class D extends B{
	
}

// C 可以被任意其他类继承
public non-sealed class C extends SupperClass {
}

public class Other extends C{}

java复制代码public sealed interface Inter permits A,B,C{
}

public final class A implements Inter{
}

public final class B implements Inter{
}

public final class C implements Inter{
}

java复制代码public sealed interface ConstantDesc
        permits ClassDesc,
                MethodHandleDesc,
                MethodTypeDesc,
                Double,
                DynamicConstantDesc,
                Float,
                Integer,
                Long,
                String { ... }

java复制代码sealed interface S permits A, B, C {}
final class A implements S {}
final class B implements S {}
final class C implements S {} 

// 错误
static void switchStatementComplete(S s) {
    switch (s) {    // 编译错误，缺少类型B,自动提示
        case A a :
            System.out.println("A");
            break;
        case C c :
            System.out.println("C");
            break;
    };
}
// 正确
static int testSealedCoverage(S s) {
    return switch (s) {
        case A a -> 1;
        case B b -> 2;
        case C c -> 3;
    };
}

yaml复制代码
bind 0.0.0.0

protected-mode no

port 26379

daemonize yes

sentinel monitor mymaster 127.0.0.1 6378 3 //设置 主节点名称 ip 端口 参加选举的哨兵数

sentinel failover-timeout mymaster 3000 //主从切换超时时间

sentinel down-after-milliseconds mymaster 3000 // sentinel心跳检测3秒内无响应，视为挂掉，开始切换其他从为主。

bash复制代码
./redis-server ../sentinel/sentinel-26377.conf --sentinel

arduino复制代码
daemonize yes //开启守护线程

logfile "6379.log"

dbfilename "dump-6379.rdb"

protected-mode no //关闭代表外部网络可以直接访问，开启需配置bind ip或者访问密码

port 6379

bind 0.0.0.0

pidfile /var/run/redis_6379.pid //pidfile文件

cluster-enabled yes //开启集群

cluster-config-file nodes_6379.conf //集群的配置 配置文件首次启动自动生成

cluster-node-timeout 15000 //请求超时，默认15秒

bash复制代码
./redis-server ../cluster/redis-6380-master.conf

./redis-server ../cluster/redis-6381-master.conf

./redis-server ../conf/redis-6379-master.conf

css复制代码
redis-cli --cluster create 192.168.121.133:6379 192.168.121.133:6380 192.168.121.133:6381 192.168.121.133:6376 192.168.121.133:6377 192.168.121.133:6378 --cluster-replicas 1

ruby复制代码
./redis-cli -p 6380 -c

127.0.0.1:6379> cluster info 查询集群信息

127.0.0.1:6379> cluster nodes 差群集群有多少节点

csharp复制代码mysql> select SQL_CACHE * from T where ID=10；

csharp复制代码select * from T where ID=10;

java复制代码public int[] twoSum(int[] nums, int target) {
        int a[] = new int[2];
        a[0] = a[1] = 0;
        for(int i=0;i< nums.length;i++)
        {
            for(int j=i+1;j< nums.length;j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    a[0] = i;
                    a[1] = j;
                    return a;
                }
            }
        }
        
        return a;
    }

java复制代码public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i< nums.length;i++)
        {
            map.put(nums[i],i);
        }
        for(int i=0;i< nums.length;i++)
        {
            int comp = target - nums[i];
            if(map.containsKey(comp)&&map.get(comp)!=i)
            {
                int a[] = new int[2];
                a[0] = i;
                a[1] = map.get(comp);
                return a;
            }
        }
        return new int[2];
    }

java复制代码    public static List<List<Integer>> Twosum(int start,int end,int nums[],int value)
    {
        List<List<Integer>> list = new ArrayList<>();
        while(start<end)
        {
            if(start<end)
            {
                int a = nums[start];
                int b = nums[end];
                while(nums[start]+nums[end]>(0-value)&&start<end)
                {
                    end--;
                }
                while(nums[start]+nums[end]<(0-value)&&start<end)
                {
                    start++;
                }
                if(nums[start]+nums[end]==(0-value)&&start<end)
                {
                    List<Integer> alist = new ArrayList<>();
                    alist.add(value);
                    alist.add(nums[start]);
                    alist.add(nums[end]);
                    list.add(alist);
                    //防止重复
                    while(start!= nums.length-1&&nums[start+1]==nums[start])
                        start++;
                    while(end!=0&&nums[end]==nums[end-1])
                        end--;
                    if(start>=end)
                        break;
                    start++;
                    end--;
                }
            }

        }
        return list;
    }



    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);

        for(int i=0;i< nums.length;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            List<List<Integer>> alist = Twosum(i+1, nums.length-1,nums,nums[i]);
            for (int j=0;j<alist.size();j++)
                list.add(alist.get(j));

        }

        

        return list;
    }

java复制代码public static List<List<Integer>> Twosum(int start,int end,int nums[],int value,int target)
    {
        List<List<Integer>> list = new ArrayList<>();
        while(start<end)
        {
            if(start<end)
            {
                int a = nums[start];
                int b = nums[end];
                while(nums[start]+nums[end]>(target)&&start<end)
                {
                    end--;
                }
                while(nums[start]+nums[end]<(target)&&start<end)
                {
                    start++;
                }
                if(nums[start]+nums[end]==(target)&&start<end)
                {
                    List<Integer> alist = new ArrayList<>();
                    alist.add(value);
                    alist.add(nums[start]);
                    alist.add(nums[end]);
                    list.add(alist);
                    //防止重复
                    while(start!= nums.length-1&&nums[start+1]==nums[start])
                        start++;
                    while(end!=0&&nums[end]==nums[end-1])
                        end--;
                    if(start>=end)
                        break;
                    start++;
                    end--;
                }
            }

        }
        return list;
    }



    public static List<List<Integer>> threeSum(int[] nums,int target) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);

        for(int i=0;i< nums.length;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            List<List<Integer>> alist = Twosum(i+1, nums.length-1,nums,nums[i],target - nums[i]);
            for (int j=0;j<alist.size();j++)
                list.add(alist.get(j));

        }
        return list;
    }

    public static List<List<Integer>> fourSum(int[] nums,int target)
    {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);

        for (int i=0;i< nums.length-2;i++)
        {
            if(i>0&&nums[i]==nums[i-1])
                continue;
            int a[] = new int[nums.length-i-1];
            for (int j = 0;j<a.length;j++)
            {
                a[j] = nums[i+j+1];
            }
            List<List<Integer>> alist = threeSum(a,target-nums[i]);
            for (int j=0;j<alist.size();j++)
            {
                List<Integer> list = new ArrayList<>();
                list.add(nums[i]);
                for (int t=0;t<alist.get(j).size();t++)
                {
                    list.add(alist.get(j).get(t));
                }
                res.add(list);
            }
        }
        return res;
    }

toml复制代码[lib]
proc-macro = true
path = "src/lib.rs"

rust复制代码#[proc_macro]
pub fn my_proc_macro(input: TokenStream) -> TokenStream{
    // ...
}

rust复制代码#[proc_macro_derive(MyDerive)]
pub fn my_proc_macro_derive(input: TokenStream) -> TokenStream{
    // ...
}

rust复制代码#[proc_macro_attribute]
pub fn my_attribute_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
    // ...
}

rust复制代码#[handler(blog(::hxl::com))]
fn fake(a: i32) {
    println!("hello proc-derive -> fake func args: {}", a);
}

rust复制代码#[proc_macro_attribute]
pub fn handler(attr: TokenStream, item: TokenStream) -> TokenStream {
    eprintln!("attr: {:#?}", attr);
    eprintln!("item: {:#?}", item);
    item
}

rust复制代码
#[proc_macro_attribute]
pub fn handler(attr: TokenStream, item: TokenStream) -> TokenStream {
    let args: AttributeArgs = parse_macro_input!(attr as AttributeArgs);
    eprintln!("args: {:#?}", args);

    let body = parse_macro_input!(item as Item);
    eprintln!("body: {:#?}", body);
    quote!(#body).into()
}

js复制代码JDK1.8
SpringBoot 2.3.0.RELEASE
mybatis-plus 3.3.0

js复制代码 <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.4.0</version>
        </dependency>

js复制代码@Component
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

js复制代码@ApiModel(value = "com-example-demo-module-User")
@TableName("user")
public class User {

    @TableId(value = "id", type = IdType.INPUT)
    private Integer id;
    @TableField(value = "name")
    private String name;
    @TableField(value = "age")
    private int age;
    @Version
    private int version;
}

js复制代码    @Test
    void TestUser(){
        User user = new User();
        user.setName("测试1");
        user.setAge(12);
        userMapper.insert(user);
    }

js复制代码     @Test
    void TestUser(){
        User user = userService.getById(19);
        System.out.println(user);
        //开始更新一次
        userService.updateByTest(user);
        user.setName("测试32222");
        userService.updateById(user);
        User user1 = userService.getById(user.getId());
        System.out.println("第二个更新的方法：" +user1);
    }

js复制代码User{id=19, name='测试32222', age=12, version=0}
第一个更新的方法：User{id=19, name='123456', age=12, version=1}
第二个更新的方法：User{id=19, name='测试32222', age=12, version=2}

java复制代码public interface ILift {
    //电梯的4个状态
    //开门状态
    public final static int OPENING_STATE = 1;
    //关门状态
    public final static int CLOSING_STATE = 2;
    //运行状态
    public final static int RUNNING_STATE = 3;
    //停止状态
    public final static int STOPPING_STATE = 4;

    //设置电梯的状态
    public void setState(int state);

    //电梯的动作
    public void open();
    public void close();
    public void run();
    public void stop();
}

public class Lift implements ILift {
    private int state;

    @Override
    public void setState(int state) {
        this.state = state;
    }

    //执行关门动作
    @Override
    public void close() {
        switch (this.state) {
            case OPENING_STATE:
                System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
                this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
                break;
            case CLOSING_STATE:
                //do nothing //已经是关门状态，不能关门
                break;
            case RUNNING_STATE:
                //do nothing //运行时电梯门是关着的，不能关门
                break;
            case STOPPING_STATE:
                //do nothing //停止时电梯也是关着的，不能关门
                break;
        }
    }

    //执行开门动作
    @Override
    public void open() {
        switch (this.state) {
            case OPENING_STATE://门已经开了，不能再开门了
                //do nothing
                break;
            case CLOSING_STATE://关门状态，门打开:
                System.out.println("电梯门打开了。。。");
                this.setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                //do nothing 运行时电梯不能开门
                break;
            case STOPPING_STATE:
                System.out.println("电梯门开了。。。");//电梯停了，可以开门了
                this.setState(OPENING_STATE);
                break;
        }
    }

    //执行运行动作
    @Override
    public void run() {
        switch (this.state) {
            case OPENING_STATE://电梯不能开着门就走
                //do nothing
                break;
            case CLOSING_STATE://门关了，可以运行了
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);//现在是运行状态
                break;
            case RUNNING_STATE:
                //do nothing 已经是运行状态了
                break;
            case STOPPING_STATE:
                System.out.println("电梯开始运行了。。。");
                this.setState(RUNNING_STATE);
                break;
        }
    }

    //执行停止动作
    @Override
    public void stop() {
        switch (this.state) {
            case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
                //do nothing
                break;
            case CLOSING_STATE://关门时才可以停止
                System.out.println("电梯停止了。。。");
                this.setState(STOPPING_STATE);
                break;
            case RUNNING_STATE://运行时当然可以停止了
                System.out.println("电梯停止了。。。");
                this.setState(STOPPING_STATE);
                break;
            case STOPPING_STATE:
                //do nothing
                break;
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Lift lift = new Lift();
        lift.setState(ILift.STOPPING_STATE);//电梯是停止的
        lift.open();//开门
        lift.close();//关门
        lift.run();//运行
        lift.stop();//停止
    }
}

java复制代码//抽象状态类
public abstract class LiftState {
    //定义一个环境角色，也就是封装状态的变化引起的功能变化
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }

    //电梯开门动作
    public abstract void open();

    //电梯关门动作
    public abstract void close();

    //电梯运行动作
    public abstract void run();

    //电梯停止动作
    public abstract void stop();
}

//开启状态
public class OpenningState extends LiftState {

    //开启当然可以关闭了，我就想测试一下电梯门开关功能
    @Override
    public void open() {
        System.out.println("电梯门开启...");
    }

    @Override
    public void close() {
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }

    //电梯门不能开着就跑，这里什么也不做
    @Override
    public void run() {
        //do nothing
    }

    //开门状态已经是停止的了
    @Override
    public void stop() {
        //do nothing
    }
}

//运行状态
public class RunningState extends LiftState {

    //运行的时候开电梯门？你疯了！电梯不会给你开的
    @Override
    public void open() {
        //do nothing
    }

    //电梯门关闭？这是肯定了
    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        //do nothing
    }

    //这是在运行状态下要实现的方法
    @Override
    public void run() {
        System.out.println("电梯正在运行...");
    }

    //这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
    @Override
    public void stop() {
        super.context.setLiftState(Context.stoppingState);
        super.context.stop();
    }
}

//停止状态
public class StoppingState extends LiftState {

    //停止状态，开门，那是要的！
    @Override
    public void open() {
        //状态修改
        super.context.setLiftState(Context.openningState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().open();
    }

    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }

    //停止状态再跑起来，正常的很
    @Override
    public void run() {
        //状态修改
        super.context.setLiftState(Context.runningState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().run();
    }

    //停止状态是怎么发生的呢？当然是停止方法执行了
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }
}

//关闭状态
public class ClosingState extends LiftState {

    @Override
    //电梯门关闭，这是关闭状态要实现的动作
    public void close() {
        System.out.println("电梯门关闭...");
    }

    //电梯门关了再打开，逗你玩呢，那这个允许呀
    @Override
    public void open() {
        super.context.setLiftState(Context.openningState);
        super.context.open();
    }


    //电梯门关了就跑，这是再正常不过了
    @Override
    public void run() {
        super.context.setLiftState(Context.runningState);
        super.context.run();
    }

    //电梯门关着，我就不按楼层
    @Override
    public void stop() {
        super.context.setLiftState(Context.stoppingState);
        super.context.stop();
    }
}

//环境角色
public class Context {
    //定义出所有的电梯状态
    public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
    public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
    public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
    public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行


    //定义一个当前电梯状态
    private LiftState liftState;

    public LiftState getLiftState() {
        return this.liftState;
    }

    public void setLiftState(LiftState liftState) {
        //当前环境改变
        this.liftState = liftState;
        //把当前的环境通知到各个实现类中
        this.liftState.setContext(this);
    }

    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(new ClosingState());

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}