Datasets:

D4vidHuang

/

LLM_Of_Babel_ZH_processed

like 0

2667b53ea0bbbf09b964bf9c2acdc7e644cb1b1f

java

Java

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把这个注释掉，参考setxxx方法实现验证 // public A() { // System.out.println("A 的构造方法"); // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value); public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } }

//可以把这个注释掉，参考setxxx方法实现验证

<fim_prefix>package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把<fim_suffix> // public A() { // System.out.println("A 的构造方法"); // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value); public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } } <fim_middle>

2667b53ea0bbbf09b964bf9c2acdc7e644cb1b1f

java

Java

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把这个注释掉，参考setxxx方法实现验证 // public A() { // System.out.println("A 的构造方法"); // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value); public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } }

// System.out.println("A 的构造方法");

<fim_prefix>package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把这个注释掉，参考setxxx方法实现验证 // public A() { // System.<fim_suffix> // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value); public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } } <fim_middle>

2667b53ea0bbbf09b964bf9c2acdc7e644cb1b1f

java

Java

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

spring-tbf/src/main/java/com/tbf/config/A.java

tang-bf/spring-framework-4.3.x

68b45d1f7768b9a827908c3b7a63b80c2b2867fa

package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把这个注释掉，参考setxxx方法实现验证 // public A() { // System.out.println("A 的构造方法"); // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value); public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } }

//在spring当做是BeanUtils.getWriteMethodParameter 执行到writeMethod.invoke(getWrappedInstance(), value);

<fim_prefix>package com.tbf.config; import org.springframework.stereotype.Component; public class A { // B b;//xml手动维护的时候，其实和属性无关，只是和set方法有关，所以属性可以不要， //可以把这个注释掉，参考setxxx方法实现验证 // public A() { // System.out.println("A 的构造方法"); // } // public void setB(B b) { // System.out.println("调用了setb"); // this.b = b; // // } //在spring当<fim_suffix> public void setTtt(B b) { System.out.println("spring 找到符合的setter"); System.out.println("和属性无关，甚至可以不要属性"); System.out.println("可以直接调用，这个A里面就没有任何属性"); } } <fim_middle>

2667f5958820dd12391214c4de51ed174ad89476

java

Java

src/main/java/niu/study/DesignPattern/singleton/StaticInnerSingle.java

chillman21/NIUstudy

8d0803534e4716441b4f980716aadde6452c78d9

src/main/java/niu/study/DesignPattern/singleton/StaticInnerSingle.java

chillman21/NIUstudy

8d0803534e4716441b4f980716aadde6452c78d9

src/main/java/niu/study/DesignPattern/singleton/StaticInnerSingle.java

chillman21/NIUstudy

8d0803534e4716441b4f980716aadde6452c78d9

package niu.study.DesignPattern.singleton; /** * 在内部类被加载和初始化时，才创建INSTANCE实例对象 * 静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独去加载和初始化的。 * */ public class StaticInnerSingle { private StaticInnerSingle(){} private static class Inner{ private static final StaticInnerSingle INSTANCE = new StaticInnerSingle(); } private static StaticInnerSingle getInstance(){ return Inner.INSTANCE; } }

/** * 在内部类被加载和初始化时，才创建INSTANCE实例对象 * 静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独去加载和初始化的。 * */

<fim_prefix>package niu.study.DesignPattern.singleton; /** * 在<fim_suffix> public class StaticInnerSingle { private StaticInnerSingle(){} private static class Inner{ private static final StaticInnerSingle INSTANCE = new StaticInnerSingle(); } private static StaticInnerSingle getInstance(){ return Inner.INSTANCE; } } <fim_middle>

266880c0fe7eebc82d9bff00e57d4325f5044a28

java

Java

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } }

//对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。

<fim_prefix>package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于�<fim_suffix> //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } } <fim_middle>

266880c0fe7eebc82d9bff00e57d4325f5044a28

java

Java

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } }

//使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。

<fim_prefix>package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预<fim_suffix> public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } } <fim_middle>

266880c0fe7eebc82d9bff00e57d4325f5044a28

java

Java

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } }

//记录进位值

<fim_prefix>package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记�<fim_suffix> while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } } <fim_middle>

266880c0fe7eebc82d9bff00e57d4325f5044a28

java

Java

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } }

//先算carry 先算是否进位

<fim_prefix>package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算car<fim_suffix> sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } } <fim_middle>

266880c0fe7eebc82d9bff00e57d4325f5044a28

java

Java

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

Assignment03/src/com/neu/AddTwoNumbers2.java

Hannah397-1/INFO6205Spring2022

47ba45af1bb629b626898725a7c0087d0369d12b

package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指针的下一个节点 curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } }

// curr指针的下一个节点

<fim_prefix>package com.neu; class ListNode { int val; ListNode next; ListNode() { } ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。 //使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。 public class AddTwoNumbers2 { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode pre = new ListNode(0); //记录的 ListNode curr = pre; //头结点 int carry = 0;//记录进位值 while(l1 != null || l2 != null){ int x = l1 != null ? l1.val : 0; int y = l2 != null ? l2.val : 0; int sum = x + y + carry; carry = sum / 10;//先算carry 先算是否进位 sum = sum % 10; // 再算取余 curr.next = new ListNode(sum);// curr指<fim_suffix> curr = curr.next; // l1和l2后移 if(l1 != null){ l1 = l1.next; } if(l2 != null){ l2 = l2.next; } } // 最后一位需要进位的情况 if(carry == 1){ curr.next = new ListNode(carry); } return pre.next; } } <fim_middle>

2668bec0117ceec74226ac286a2f212e3ea6ea6d

java

Java

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

agnes-yang/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-06-27T03:15:28.000Z

2019-12-17T15:17:42.000Z

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

dahui888/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-07-09T05:27:33.000Z

2019-10-12T07:10:48.000Z

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

dahui888/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-06-27T08:34:18.000Z

2019-12-17T03:14:46.000Z

public interface ISortAlgorithm { /** * 排序算法的名字 * * @return */ String getName(); /** * 排序算法的实现 * * @param arr 待排序数组 */ void sort(int[] arr); }

/** * 排序算法的名字 * * @return */

<fim_prefix>public interface ISortAlgorithm { /** * <fim_suffix> String getName(); /** * 排序算法的实现 * * @param arr 待排序数组 */ void sort(int[] arr); } <fim_middle>

2668bec0117ceec74226ac286a2f212e3ea6ea6d

java

Java

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

agnes-yang/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-06-27T03:15:28.000Z

2019-12-17T15:17:42.000Z

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

dahui888/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-07-09T05:27:33.000Z

2019-10-12T07:10:48.000Z

09-Priority-Queue(Heap)/06-Heap/src/ISortAlgorithm.java

dahui888/LeetCode-Solutions-in-Good-Style

acc8661338cc7c1ae067915fb16079a9e3e66847

2019-06-27T08:34:18.000Z

2019-12-17T03:14:46.000Z

public interface ISortAlgorithm { /** * 排序算法的名字 * * @return */ String getName(); /** * 排序算法的实现 * * @param arr 待排序数组 */ void sort(int[] arr); }

/** * 排序算法的实现 * * @param arr 待排序数组 */

<fim_prefix>public interface ISortAlgorithm { /** * 排序算法的名字 * * @return */ String getName(); /** * <fim_suffix> void sort(int[] arr); } <fim_middle>

266a53b9cb47a7598b7185fefbc5e868fc4b7f0b

java

Java

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } }

/* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */

<fim_prefix>package com.lrq; /* �<fim_suffix> public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } } <fim_middle>

266a53b9cb47a7598b7185fefbc5e868fc4b7f0b

java

Java

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } }

// 类似归并排序中的合并过程

<fim_prefix>package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类�<fim_suffix> ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } } <fim_middle>

266a53b9cb47a7598b7185fefbc5e868fc4b7f0b

java

Java

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } }

//生成的新的链表

<fim_prefix>package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的<fim_suffix> ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } } <fim_middle>

266a53b9cb47a7598b7185fefbc5e868fc4b7f0b

java

Java

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } }

//从比较两个链表中第一个节点的大小开始

<fim_prefix>package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比<fim_suffix> cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } } <fim_middle>

266a53b9cb47a7598b7185fefbc5e868fc4b7f0b

java

Java

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

code/src/main/java/com/lrq/lc_021.java

llllrq/LeetCode

30587f23676ebd8b52b4cda9d8fceab1ff3458b3

package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表 if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } }

// 任一为空(本来就是空链表或者原本的节点全部移到新链表中)，直接连接另一条链表

<fim_prefix>package com.lrq; /* 题目描述：将两个有序的链表合并为一个有序的链表 思路：定义一个ListNode类，实现归并排序中最后一步两两合并过程 */ public class lc_021 { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { // 类似归并排序中的合并过程 ListNode dummyHead = new ListNode(0); //生成的新的链表 ListNode cur = dummyHead; while (l1 != null && l2 != null) { if (l1.val < l2.val) { //从比较两个链表中第一个节点的大小开始 cur.next = l1; cur = cur.next; l1 = l1.next; } else { cur.next = l2; cur = cur.next; l2 = l2.next; } } // 任一<fim_suffix> if (l1 == null) { cur.next = l2; } else { cur.next = l1; } return dummyHead.next; } } <fim_middle>

266b4c0ebe922f2d6d84a226b9cb4ed0d14cd8e7

java

Java

src/main/java/com/lxk/design/pattern/visitor/Main.java

cmshome/designPattern

d8f597d018aaebf76e2e7fd7db53236fd2772aec

2020-09-08T02:30:55.000Z

2022-01-29T02:21:52.000Z

src/main/java/com/lxk/design/pattern/visitor/Main.java

cmshome/designPattern

d8f597d018aaebf76e2e7fd7db53236fd2772aec

src/main/java/com/lxk/design/pattern/visitor/Main.java

cmshome/designPattern

d8f597d018aaebf76e2e7fd7db53236fd2772aec

2020-09-17T10:05:32.000Z

2022-03-27T20:16:23.000Z

package com.lxk.design.pattern.visitor; /** * 访问者模式（Visitor Pattern）中，使用一个访问者类，它改变了元素类的执行算法。 * 通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。 * 根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 * 意图： * 主要将数据结构与数据操作分离。 * 主要解决： * 稳定的数据结构和易变的操作耦合问题。 * 何时使用： * 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。 * 如何解决： * 在被访问的类里面加一个对外提供接待访问者的接口。 * 关键代码： * 在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。 * 应用实例： * 您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。 * 优点： * 1、符合单一职责原则。 * 2、优秀的扩展性。 * 3、灵活性。 * 缺点： * 1、具体元素对访问者公布细节，违反了迪米特原则。 * 2、具体元素变更比较困难。 * 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。 * 使用场景： * 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 * 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。 * 注意事项： * 访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。 * * @author LiXuekai on 2020/7/24 */ public class Main { public static void main(String[] args) { ComputerPart computer = new Computer(); computer.accept(new ComputerPartDisplayVisitor()); } }

/** * 访问者模式（Visitor Pattern）中，使用一个访问者类，它改变了元素类的执行算法。 * 通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。 * 根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 * 意图： * 主要将数据结构与数据操作分离。 * 主要解决： * 稳定的数据结构和易变的操作耦合问题。 * 何时使用： * 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。 * 如何解决： * 在被访问的类里面加一个对外提供接待访问者的接口。 * 关键代码： * 在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。 * 应用实例： * 您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。 * 优点： * 1、符合单一职责原则。 * 2、优秀的扩展性。 * 3、灵活性。 * 缺点： * 1、具体元素对访问者公布细节，违反了迪米特原则。 * 2、具体元素变更比较困难。 * 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。 * 使用场景： * 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 * 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。 * 注意事项： * 访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。 * * @author LiXuekai on 2020/7/24 */

<fim_prefix>package com.lxk.design.pattern.visitor; /** * �<fim_suffix> public class Main { public static void main(String[] args) { ComputerPart computer = new Computer(); computer.accept(new ComputerPartDisplayVisitor()); } } <fim_middle>

266b63e7c42b8d23dd4d6181f40a6cdb86208a90

java

Java

src/ex/ex04_105021027.java

csie-asia/week04-20161017-EwigeHerz

d8c6011f1f53f5b1ceb34cebc8dd4f6e948b3a2c

src/ex/ex04_105021027.java

csie-asia/week04-20161017-EwigeHerz

d8c6011f1f53f5b1ceb34cebc8dd4f6e948b3a2c

src/ex/ex04_105021027.java

csie-asia/week04-20161017-EwigeHerz

d8c6011f1f53f5b1ceb34cebc8dd4f6e948b3a2c

package ex; import java.util.*; /* * Topic: 讓使用者輸入 一個正整數 n 及一個字元符號，然後顯示出下列圖形 (例 n = 4,字元符號= @) @@@@ @@@ @@ @ * Date: 2016/10/17 * Author: 105021027 陳宴湘 */ public class ex04_105021027 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner scn = new Scanner(System.in); System.out.println("請輸入值:"); int x = scn.nextInt(); System.out.print("請輸入你要的字元符號:"); char y = scn.next().charAt(0); for(int i =x;i>=1;i--){ for(int j=1;j<=i;j++){ System.out.print(y); } System.out.println(); } } }

/* * Topic: 讓使用者輸入 一個正整數 n 及一個字元符號，然後顯示出下列圖形 (例 n = 4,字元符號= @) @@@@ @@@ @@ @ * Date: 2016/10/17 * Author: 105021027 陳宴湘 */

<fim_prefix>package ex; import java.util.*; /* * T<fim_suffix> public class ex04_105021027 { public static void main(String[] args) { // TODO Auto-generated method stub Scanner scn = new Scanner(System.in); System.out.println("請輸入值:"); int x = scn.nextInt(); System.out.print("請輸入你要的字元符號:"); char y = scn.next().charAt(0); for(int i =x;i>=1;i--){ for(int j=1;j<=i;j++){ System.out.print(y); } System.out.println(); } } } <fim_middle>

266b9e6d9962d5260c5913ce9a37ee75a0b8d485

java

Java

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } }

// 最开始在整个区间把 0 移动到最左侧

<fim_prefix>class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开<fim_suffix> solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } } <fim_middle>

266b9e6d9962d5260c5913ce9a37ee75a0b8d485

java

Java

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } }

// 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧

<fim_prefix>class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把<fim_suffix> } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } } <fim_middle>

266b9e6d9962d5260c5913ce9a37ee75a0b8d485

java

Java

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } }

// 关键点，不要写成 0 了

<fim_prefix>class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关�<fim_suffix> for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } } <fim_middle>

266b9e6d9962d5260c5913ce9a37ee75a0b8d485

java

Java

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

Dataset/Leetcode/valid/75/214.java

kkcookies99/UAST

fff81885aa07901786141a71e5600a08d7cb4868

class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // 满足条件，则进行 swap swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } }

// 满足条件，则进行 swap

<fim_prefix>class Solution { public void XXX(int[] nums) { int n = nums.length; int idx = solve(nums, 0, n - 1, 0); // 最开始在整个区间把 0 移动到最左侧 solve(nums, idx, n - 1, 1); // 把所有 1 移动到 0 的右侧， 2 的左侧，即在 [idx, n - 1] 内把 1 移动到 2 左侧 } public int solve(int[] nums, int lo, int hi, int target) { int idx = lo; // 关键点，不要写成 0 了 for(int i = lo; i <= hi; ++i) { if(nums[i] == target) { // �<fim_suffix> swap(nums, i, idx++); } } return idx; } public void swap(int[] nums, int i, int j) { int t = nums[i]; nums[i] = nums[j]; nums[j] = t; } } <fim_middle>

266bbeb1c0a03b645f5da9ba9548dd8b381e73f0

java

Java

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:02:08.000Z

2022-02-24T09:51:10.000Z

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:03:19.000Z

2022-02-18T08:25:09.000Z

package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); }

/** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */

<fim_prefix>package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实<fim_suffix> public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); } <fim_middle>

266bbeb1c0a03b645f5da9ba9548dd8b381e73f0

java

Java

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:02:08.000Z

2022-02-24T09:51:10.000Z

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:03:19.000Z

2022-02-18T08:25:09.000Z

package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); }

/** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */

<fim_prefix>package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * <fim_suffix> IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); } <fim_middle>

266bbeb1c0a03b645f5da9ba9548dd8b381e73f0

java

Java

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:02:08.000Z

2022-02-24T09:51:10.000Z

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:03:19.000Z

2022-02-18T08:25:09.000Z

package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); }

/** * 获得实体对象注释内容 * * @return 注释内容 */

<fim_prefix>package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * <fim_suffix> String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); } <fim_middle>

266bbeb1c0a03b645f5da9ba9548dd8b381e73f0

java

Java

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:02:08.000Z

2022-02-24T09:51:10.000Z

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

src/main/java/com/github/houkunlin/vo/IEntity.java

houkunlin/Database-Generator

0a9532b928526270b855df3f0b2f7cb8585da0b0

2020-10-16T06:03:19.000Z

2022-02-18T08:25:09.000Z

package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */ EntityPackage getPackages(); }

/** * 获得需要导入的包列表（一般情况下是在实体对象中使用），该方法只返回包的完整名称。 * * @return 包列表 */

<fim_prefix>package com.github.houkunlin.vo; import com.github.houkunlin.vo.impl.EntityPackage; /** * 实体类信息 * * @author HouKunLin * @date 2020 /5/27 0027 23:54 */ public interface IEntity { /** * 获得实体类对象名称（不含后缀） * * @return 实体类对象名称（不含后缀，驼峰形式，首字母大写） */ IName getName(); /** * 获得实体对象注释内容 * * @return 注释内容 */ String getComment(); /** * <fim_suffix> EntityPackage getPackages(); } <fim_middle>

266d02fc09fef65e89c202a859bd54ee78c696b5

java

Java

src/observable/MyObservable.java

myjoybar/JavaExercise

881178f2b92f643e8665d99caebb8ca5b99b92c5

src/observable/MyObservable.java

myjoybar/JavaExercise

881178f2b92f643e8665d99caebb8ca5b99b92c5

src/observable/MyObservable.java

myjoybar/JavaExercise

881178f2b92f643e8665d99caebb8ca5b99b92c5

package observable; import java.util.Observable; /** * Created by joybar on 2017/11/27. */ public class MyObservable extends Observable { public void setData(){ setChanged(); /** * 这里的参数将作为内部Observer的undata()方法的第二个参数，而且是调用每一个Observer的updata()方法 * 在方法内部： * for (int i = arrLocal.length-1; i>=0; i--) * arrLocal[i].update(this, arg); */ notifyObservers("老子发生改变了"); } }

/** * 这里的参数将作为内部Observer的undata()方法的第二个参数，而且是调用每一个Observer的updata()方法 * 在方法内部： * for (int i = arrLocal.length-1; i>=0; i--) * arrLocal[i].update(this, arg); */

<fim_prefix>package observable; import java.util.Observable; /** * Created by joybar on 2017/11/27. */ public class MyObservable extends Observable { public void setData(){ setChanged(); /** * <fim_suffix> notifyObservers("老子发生改变了"); } } <fim_middle>

266e6b73ce16f0bfc21592200f5ebd9c64136e38

java

Java

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-02T22:39:54.000Z

2022-03-31T12:07:50.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-06T12:58:10.000Z

2022-03-23T04:52:23.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-03T13:25:19.000Z

2022-03-27T04:45:06.000Z

package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }

/* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */

<fim_prefix>package com.java2nb.common.utils; /* author：z<fim_suffix> public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }<fim_middle>

266e6b73ce16f0bfc21592200f5ebd9c64136e38

java

Java

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-02T22:39:54.000Z

2022-03-31T12:07:50.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-06T12:58:10.000Z

2022-03-23T04:52:23.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-03T13:25:19.000Z

2022-03-27T04:45:06.000Z

package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }

// 获取文件后缀名并转化为写，用于后续比较

<fim_prefix>package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获<fim_suffix> String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }<fim_middle>

266e6b73ce16f0bfc21592200f5ebd9c64136e38

java

Java

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-02T22:39:54.000Z

2022-03-31T12:07:50.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-06T12:58:10.000Z

2022-03-23T04:52:23.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-03T13:25:19.000Z

2022-03-27T04:45:06.000Z

package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }

// 创建图片类型数组0

<fim_prefix>package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创<fim_suffix> String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }<fim_middle>

266e6b73ce16f0bfc21592200f5ebd9c64136e38

java

Java

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-02T22:39:54.000Z

2022-03-31T12:07:50.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-06T12:58:10.000Z

2022-03-23T04:52:23.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-03T13:25:19.000Z

2022-03-27T04:45:06.000Z

package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }

// 创建文档类型数组1

<fim_prefix>package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创<fim_suffix> String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }<fim_middle>

266e6b73ce16f0bfc21592200f5ebd9c64136e38

java

Java

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-02T22:39:54.000Z

2022-03-31T12:07:50.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-06T12:58:10.000Z

2022-03-23T04:52:23.000Z

novel-admin/src/main/java/com/java2nb/common/utils/FileType.java

SteveZou0210/novel

3c5dcda4fbcd840d6ada46c1e989ecfdfbe2626d

2020-05-03T13:25:19.000Z

2022-03-27T04:45:06.000Z

package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创建视频类型数组2 String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }

// 创建视频类型数组2

<fim_prefix>package com.java2nb.common.utils; /* author：zss * 日期：2017年3月31日 * 功能：根据文件名称判断类型 * 接受参数类型：String * 返回参数类型：String * 备注：文件类型不完善，有需要的自行添加 */ public class FileType { public static int fileType(String fileName) { if (fileName == null) { fileName = "文件名为空！"; return 500; } else { // 获取文件后缀名并转化为写，用于后续比较 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length()).toLowerCase(); // 创建图片类型数组0 String[] img = { "bmp", "jpg", "jpeg", "png", "tiff", "gif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "wmf" }; for (int i = 0; i < img.length; i++) { if (img[i].equals(fileType)) { return 0; } } // 创建文档类型数组1 String[] document = { "txt", "doc", "docx", "xls", "htm", "html", "jsp", "rtf", "wpd", "pdf", "ppt" }; for (int i = 0; i < document.length; i++) { if (document[i].equals(fileType)) { return 1; } } // 创<fim_suffix> String[] video = { "mp4", "avi", "mov", "wmv", "asf", "navi", "3gp", "mkv", "f4v", "rmvb", "webm" }; for (int i = 0; i < video.length; i++) { if (video[i].equals(fileType)) { return 2; } } // 创建音乐类型数组3 String[] music = { "mp3", "wma", "wav", "mod", "ra", "cd", "md", "asf", "aac", "vqf", "ape", "mid", "ogg", "m4a", "vqf" }; for (int i = 0; i < music.length; i++) { if (music[i].equals(fileType)) { return 3; } } } //4 return 99; } }<fim_middle>

266edadc0d8934a1c349a68cc3862f2cb4f0ea48

java

Java

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:36:28.000Z

2019-06-14T05:36:28.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:22:42.000Z

2019-06-14T05:22:42.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } }

/** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */

<fim_prefix>package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * �<fim_suffix> public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } } <fim_middle>

266edadc0d8934a1c349a68cc3862f2cb4f0ea48

java

Java

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:36:28.000Z

2019-06-14T05:36:28.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:22:42.000Z

2019-06-14T05:22:42.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } }

/** * 所属的关联线程 */

<fim_prefix>package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * <fim_suffix> protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } } <fim_middle>

266edadc0d8934a1c349a68cc3862f2cb4f0ea48

java

Java

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:36:28.000Z

2019-06-14T05:36:28.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:22:42.000Z

2019-06-14T05:22:42.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } }

/** * 本运行器名称 */

<fim_prefix>package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * <fim_suffix> protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } } <fim_middle>

266edadc0d8934a1c349a68cc3862f2cb4f0ea48

java

Java

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:36:28.000Z

2019-06-14T05:36:28.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:22:42.000Z

2019-06-14T05:22:42.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } }

/** * 累积启动次数 */

<fim_prefix>package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * <fim_suffix> protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } } <fim_middle>

266edadc0d8934a1c349a68cc3862f2cb4f0ea48

java

Java

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:36:28.000Z

2019-06-14T05:36:28.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

2019-06-14T05:22:42.000Z

2019-06-14T05:22:42.000Z

src/org/nutz/runner/NutRunner.java

TomYule/nutz

c7322d1639f2ad0125df3e235494cf9ba5711006

package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * 本次睡眠时间 */ protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } }

/** * 本次睡眠时间 */

<fim_prefix>package org.nutz.runner; import java.util.Date; import org.nutz.lang.Times; import org.nutz.log.Log; import org.nutz.log.Logs; /** * 封装Runnable的带lock的启动器 * * @author zozoh(zozohtnt@gmail.com) * @author pw * @author wendal */ public abstract class NutRunner implements Runnable { protected Log log; /** * 所属的关联线程 */ protected Thread myThread; /** * 本运行器名称 */ protected String rnm; /** * 线程锁 */ protected NutLock lock; /** * 累积启动次数 */ protected int count; /** * <fim_suffix> protected long interval; /** * 报错以后睡眠时间 */ protected int sleepAfterError; /** * 启动于 */ protected Date upAt; /** * 睡眠于，如果本值不为 null，表示本线程正在睡眠，否则为运行中 */ protected Date downAt; protected boolean debug = true; /** * 新建一个启动器 * * @param rname * 本启动器的名称 */ public NutRunner(String rname) { this.rnm = rname; this.count = 0; this.sleepAfterError = 30; this.lock = new NutLock(); } /** * 设置报错以后睡眠时间（单位秒） * * @param sec * 秒 * @return 冷却时间 */ public NutRunner setSleepAfterError(int sec) { this.sleepAfterError = sec; return this; } /** * 主逻辑,用户代码不应该覆盖. */ public void run() { if (log == null) { log = Logs.get().setTag(rnm); } myThread = Thread.currentThread(); beforeStart(this); doIt(); afterStop(this); } /** * 具体的业务实现,返回一个sleep数 * * @return 本次运行后还需要等待多少个毫秒 */ public abstract long exec() throws Exception; /** * 注册本对象到线程管理器,已废弃 * * @param me * 本对象 */ @Deprecated public void reg(NutRunner me) {} /** * 从线程管理器反注册,已废弃 * * @param me * 本对象 */ @Deprecated public void unreg(NutRunner me) {} /** * 开始之前,一般做一些准备工作,比如资源初始化等 * * @param me * runner本身 */ public void beforeStart(NutRunner me) { reg(me); } /** * 停止之后,一般是做一些资源回收 * * @param me * runner本身 */ public void afterStop(NutRunner me) { unreg(me); } /** * 做一些需要定期执行的操作 */ protected void doIt() { while (!lock.isStop()) { synchronized (lock) { try { // 修改一下本线程的时间 upAt = Times.now(); downAt = null; if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : up", rnm, ++count); // 执行业务 interval = exec(); if (interval < 1) interval = 1; // 不能间隔0或者负数,会死线程的 // 等待一个周期 downAt = Times.now(); if (debug && log.isDebugEnabled()) log.debugf("%s [%d] : wait %ds(%dms)", rnm, count, interval / 1000, interval); lock.wait(interval); } catch (InterruptedException e) { log.warn(String.format("%s has been interrupted", rnm), e); break; } catch (Throwable e) { log.warn(String.format("%s has some error", rnm), e); try { lock.wait(sleepAfterError * 1000); } catch (Throwable e1) { log.warn(String.format("%s has some error again", rnm), e); break; } } } } } /** * 返回格式为 [名称:总启动次数] 最后启动时间:最后休眠时间 - 休眠间隔 */ public String toString() { return String.format("[%s:%d] %s/%s - %d", rnm, count, upAt == null ? "NONE" : Times.sDT(upAt), downAt == null ? "NONE" : Times.sDT(downAt), interval); } /** * 是否正在等待运行 * * @return true,如果正在等待 */ public boolean isWaiting() { return null != downAt; } /** * 是否正在执行用户代码 * * @return true,如果正在exec方法内部 */ public boolean isRunning() { return null == downAt; } /** * 获取执行间隔 * * @return 执行间隔 */ public long getInterval() { return interval; } /** * 获取最后启动时间 * * @return 最后启动时间 */ public Date getUpAt() { return upAt; } /** * 获取最后一次等待开始的时间 * * @return 最后一次等待开始的时间 */ public Date getDownAt() { return downAt; } /** * 获取本启动器的名称 * * @return 本启动器的名称 */ public String getName() { return rnm; } /** * 获取累计的启动次数 * * @return 总启动次数 */ public int getCount() { return count; } /** * 获取线程NutLock锁 * * @return 线程NutLock锁 */ public NutLock getLock() { return lock; } /** * 获取所属线程是否存活 * * @return 所属线程是否存活 */ public boolean isAlive() { if (myThread != null) { return myThread.isAlive(); } return false; } /** * 强行关闭所属线程 * * @param err * 传给Thread.stop方法的对象 */ @SuppressWarnings("deprecation") public void stop(Throwable err) { myThread.stop(err); } public void setDebug(boolean debug) { this.debug = debug; } public boolean isDebug() { return debug; } } <fim_middle>

266f77adaaa37b317394d52395cad417c05b2bfc

java

Java

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

2021-09-20T20:58:03.000Z

2021-09-20T20:58:03.000Z

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; }

/** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */

<fim_prefix>package com.yx.security.annotation; import java.lang.annotation.*; /** * 请<fim_suffix> @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; } <fim_middle>

266f77adaaa37b317394d52395cad417c05b2bfc

java

Java

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

2021-09-20T20:58:03.000Z

2021-09-20T20:58:03.000Z

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; }

/** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */

<fim_prefix>package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * <fim_suffix> boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; } <fim_middle>

266f77adaaa37b317394d52395cad417c05b2bfc

java

Java

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

2021-09-20T20:58:03.000Z

2021-09-20T20:58:03.000Z

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; }

/** * 是否只查询角色信息，true则通过rpc接口查询 */

<fim_prefix>package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * <fim_suffix> boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; } <fim_middle>

266f77adaaa37b317394d52395cad417c05b2bfc

java

Java

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

2021-09-20T20:58:03.000Z

2021-09-20T20:58:03.000Z

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; }

/** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */

<fim_prefix>package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * <fim_suffix> boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; } <fim_middle>

266f77adaaa37b317394d52395cad417c05b2bfc

java

Java

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

2021-09-20T20:58:03.000Z

2021-09-20T20:58:03.000Z

yx-security-starter/src/main/java/com/yx/security/annotation/LoginUser.java

gwj945/yx-commons

af7b24543d7f015291c828e8b934c0a7ef0ea610

package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * 是否只查询组织信息，true则通过rpc接口查询 */ boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; }

/** * 是否只查询组织信息，true则通过rpc接口查询 */

<fim_prefix>package com.yx.security.annotation; import java.lang.annotation.*; /** * 请求的方法参数SysUser上添加该注解，则注入当前登录人信息 * 例1：public void test(@LoginUser SysUser user) // 取BaseContextHandler中的 用户id、账号、姓名、组织id、岗位id等信息 * 例2：public void test(@LoginUser(isRoles = true) SysUser user) //能获取SysUser对象的实时的用户信息和角色信息 * 例3：public void test(@LoginUser(isOrg = true) SysUser user) //能获取SysUser对象的实时的用户信息和组织信息 * 例4：public void test(@LoginUser(isStation = true) SysUser user) //能获取SysUser对象的实时的用户信息和岗位信息 * 例5：public void test(@LoginUser(isFull = true) SysUser user) //能获取SysUser对象的所有信息 * 例5：public void test(@LoginUser(isResource = true) SysUser user) //能获取SysUser对象的实时的用户信息和资源信息 * * @author yx * @date 2018/7/24 16:44 */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface LoginUser { /** * 是否查询SysUser对象所有信息，true则通过rpc接口查询 */ boolean isFull() default false; /** * 是否只查询角色信息，true则通过rpc接口查询 */ boolean isRoles() default false; /** * 是否只查询 资源 信息，true则通过rpc接口查询 * * @return */ boolean isResource() default false; /** * <fim_suffix> boolean isOrg() default false; /** * 是否只查询岗位信息，true则通过rpc接口查询 */ boolean isStation() default false; } <fim_middle>

266f78a7059ab73ac0532280f6996344d8ffb2f4

java

Java

distribute/src/main/java/org/glamey/training/designmodel/observable/package-info.java

glameyzhou/training

7f3186ab18dafdd8f8f80c2090d15cf54b2c2af2

distribute/src/main/java/org/glamey/training/designmodel/observable/package-info.java

glameyzhou/training

7f3186ab18dafdd8f8f80c2090d15cf54b2c2af2

distribute/src/main/java/org/glamey/training/designmodel/observable/package-info.java

glameyzhou/training

7f3186ab18dafdd8f8f80c2090d15cf54b2c2af2

/** * https://zh.wikipedia.org/wiki/%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F * * 观察者模式是软件设计模式的一种。 * * 在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。 * 这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。 * * @author zhouyang.zhou. 2017.08.29.16. */ package org.glamey.training.designmodel.observable;

/** * https://zh.wikipedia.org/wiki/%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F * * 观察者模式是软件设计模式的一种。 * * 在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。 * 这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。 * * @author zhouyang.zhou. 2017.08.29.16. */

<fim_prefix>/** * https://<fim_suffix> package org.glamey.training.designmodel.observable;<fim_middle>

2671baee66aed0f542c133a243704a8f325fee0a

java

Java

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

public class Question152 { public int maxProduct(int[] nums) { int max = Integer.MIN_VALUE, imax = 1, imin = 1; //一个保存最大的，一个保存最小的。 for(int i=0; i<nums.length; i++){ if(nums[i] < 0){ int tmp = imax; imax = imin; imin = tmp;} //如果数组的数是负数，那么会导致最大的变最小的，最小的变最大的。因此交换两个的值。 imax = Math.max(imax*nums[i], nums[i]); imin = Math.min(imin*nums[i], nums[i]); max = Math.max(max, imax); } return max; } }

//一个保存最大的，一个保存最小的。

<fim_prefix>public class Question152 { public int maxProduct(int[] nums) { int max = Integer.MIN_VALUE, imax = 1, imin = 1; //一个保存<fim_suffix> for(int i=0; i<nums.length; i++){ if(nums[i] < 0){ int tmp = imax; imax = imin; imin = tmp;} //如果数组的数是负数，那么会导致最大的变最小的，最小的变最大的。因此交换两个的值。 imax = Math.max(imax*nums[i], nums[i]); imin = Math.min(imin*nums[i], nums[i]); max = Math.max(max, imax); } return max; } } <fim_middle>

2671baee66aed0f542c133a243704a8f325fee0a

java

Java

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

src/Question152.java

wanglong1008/LeetCode

180280ed83094aaaf148433562a6850f7141212a

public class Question152 { public int maxProduct(int[] nums) { int max = Integer.MIN_VALUE, imax = 1, imin = 1; //一个保存最大的，一个保存最小的。 for(int i=0; i<nums.length; i++){ if(nums[i] < 0){ int tmp = imax; imax = imin; imin = tmp;} //如果数组的数是负数，那么会导致最大的变最小的，最小的变最大的。因此交换两个的值。 imax = Math.max(imax*nums[i], nums[i]); imin = Math.min(imin*nums[i], nums[i]); max = Math.max(max, imax); } return max; } }

//如果数组的数是负数，那么会导致最大的变最小的，最小的变最大的。因此交换两个的值。

<fim_prefix>public class Question152 { public int maxProduct(int[] nums) { int max = Integer.MIN_VALUE, imax = 1, imin = 1; //一个保存最大的，一个保存最小的。 for(int i=0; i<nums.length; i++){ if(nums[i] < 0){ int tmp = imax; imax = imin; imin = tmp;} //如果数组<fim_suffix> imax = Math.max(imax*nums[i], nums[i]); imin = Math.min(imin*nums[i], nums[i]); max = Math.max(max, imax); } return max; } } <fim_middle>

26726161632ffe87ca5cc01aae173b508417a6cc

java

Java

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。

<fim_prefix>//给定<fim_suffix> // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }<fim_middle>

26726161632ffe87ca5cc01aae173b508417a6cc

java

Java

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }

// 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。

<fim_prefix>//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不<fim_suffix> // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }<fim_middle>

26726161632ffe87ca5cc01aae173b508417a6cc

java

Java

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }

// num1 和num2 都只包含数字 0-9

<fim_prefix>//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 <fim_suffix> // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }<fim_middle>

26726161632ffe87ca5cc01aae173b508417a6cc

java

Java

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }

// num1 和num2 都不包含任何前导零

<fim_prefix>//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 <fim_suffix> // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }<fim_middle>

26726161632ffe87ca5cc01aae173b508417a6cc

java

Java

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

src/main/java/com/tomster/leetcode/editor/cn/AddStrings.java

meiheW/leetcode-practice

755035c8e7c93a671e6da43ea4ad9b4842bb5d92

//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics 数学 字符串 模拟 // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }

// Related Topics 数学 字符串 模拟

<fim_prefix>//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 // // 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 // // // // 示例 1： // // //输入：num1 = "11", num2 = "123" //输出："134" // // // 示例 2： // // //输入：num1 = "456", num2 = "77" //输出："533" // // // 示例 3： // // //输入：num1 = "0", num2 = "0" //输出："0" // // // // // // // 提示： // // // 1 <= num1.length, num2.length <= 104 // num1 和num2 都只包含数字 0-9 // num1 和num2 都不包含任何前导零 // // Related Topics<fim_suffix> // 👍 454 👎 0 package com.tomster.leetcode.editor.cn; /** * @author: tomster * @data: 2021-10-24 12:30:03 */ public class AddStrings { public static void main(String[] args) { Solution solution = new AddStrings().new Solution(); } //leetcode submit region begin(Prohibit modification and deletion) class Solution { public String addStrings(String num1, String num2) { num1 = new StringBuilder(num1).reverse().toString(); num2 = new StringBuilder(num2).reverse().toString(); int n1 = num1.length(), n2 = num2.length(); int carry = 0; StringBuilder sb = new StringBuilder(); for (int i = 0; i < Math.max(n1, n2); i++) { int a1 = i < n1 ? num1.charAt(i) - '0' : 0; int a2 = i < n2 ? num2.charAt(i) - '0' : 0; int cur = a1 + a2 + carry; sb.append(cur % 10); carry = cur / 10; } if (carry != 0) { sb.append(carry); } return sb.reverse().toString(); } } //leetcode submit region end(Prohibit modification and deletion) }<fim_middle>

2673c3d23ba59f416fd76c4225ca959f4cc3a899

java

Java

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

/* * 反射模块 * * 抽象了JDK反射机制,提供简易的接口使用并可以缓存反射生成类信息提高反射效率 */ package org.apache.ibatis.reflection; /* * 此包涉及的设计模式 * * 抽象工厂模式 * * ReflectorFactory定义了基础的反射工厂需要的功能 * * DefaultReflectorFactory作为子工厂用于生成Reflector对象 */

/* * 反射模块 * * 抽象了JDK反射机制,提供简易的接口使用并可以缓存反射生成类信息提高反射效率 */

<fim_prefix>/* * <fim_suffix> package org.apache.ibatis.reflection; /* * 此包涉及的设计模式 * * 抽象工厂模式 * * ReflectorFactory定义了基础的反射工厂需要的功能 * * DefaultReflectorFactory作为子工厂用于生成Reflector对象 */ <fim_middle>

2673c3d23ba59f416fd76c4225ca959f4cc3a899

java

Java

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

src/main/java/org/apache/ibatis/reflection/package-info.java

xiaojieay/mybatis-study

0a0269cb470591669868c63ed103e2ea75a99d2e

/* * 反射模块 * * 抽象了JDK反射机制,提供简易的接口使用并可以缓存反射生成类信息提高反射效率 */ package org.apache.ibatis.reflection; /* * 此包涉及的设计模式 * * 抽象工厂模式 * * ReflectorFactory定义了基础的反射工厂需要的功能 * * DefaultReflectorFactory作为子工厂用于生成Reflector对象 */

/* * 此包涉及的设计模式 * * 抽象工厂模式 * * ReflectorFactory定义了基础的反射工厂需要的功能 * * DefaultReflectorFactory作为子工厂用于生成Reflector对象 */

<fim_prefix>/* * 反射模块 * * 抽象了JDK反射机制,提供简易的接口使用并可以缓存反射生成类信息提高反射效率 */ package org.apache.ibatis.reflection; /* * <fim_suffix> <fim_middle>

267494e393212d29a3e9fead82ef8a02e7a0ce62

java

Java

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; }

/** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */

<fim_prefix>package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * �<fim_suffix> @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; } <fim_middle>

267494e393212d29a3e9fead82ef8a02e7a0ce62

java

Java

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; }

/** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */

<fim_prefix>package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * �<fim_suffix> private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; } <fim_middle>

267494e393212d29a3e9fead82ef8a02e7a0ce62

java

Java

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; }

/** * 优惠券图片 */

<fim_prefix>package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * �<fim_suffix> private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; } <fim_middle>

267494e393212d29a3e9fead82ef8a02e7a0ce62

java

Java

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; }

/** * 优惠卷名字 */

<fim_prefix>package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * �<fim_suffix> private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; } <fim_middle>

267494e393212d29a3e9fead82ef8a02e7a0ce62

java

Java

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

mall-coupon/src/main/java/com/msb/mall/coupon/entity/CouponEntity.java

zhuyiyi1990/msb-mall

12deb06ee92aeab06a8d0bf03eb8cb533ddf4402

package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * 每人限领张数 */ private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; }

/** * 每人限领张数 */

<fim_prefix>package com.msb.mall.coupon.entity; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.math.BigDecimal; import java.io.Serializable; import java.util.Date; import lombok.Data; /** * 优惠券信息 * * @author Yiyi Zhu * @email zhuyiyi1990@outlook.com * @date 2022-02-24 15:09:18 */ @Data @TableName("sms_coupon") public class CouponEntity implements Serializable { private static final long serialVersionUID = 1L; /** * id */ @TableId private Long id; /** * 优惠卷类型[0->全场赠券；1->会员赠券；2->购物赠券；3->注册赠券] */ private Integer couponType; /** * 优惠券图片 */ private String couponImg; /** * 优惠卷名字 */ private String couponName; /** * 数量 */ private Integer num; /** * 金额 */ private BigDecimal amount; /** * �<fim_suffix> private Integer perLimit; /** * 使用门槛 */ private BigDecimal minPoint; /** * 开始时间 */ private Date startTime; /** * 结束时间 */ private Date endTime; /** * 使用类型[0->全场通用；1->指定分类；2->指定商品] */ private Integer useType; /** * 备注 */ private String note; /** * 发行数量 */ private Integer publishCount; /** * 已使用数量 */ private Integer useCount; /** * 领取数量 */ private Integer receiveCount; /** * 可以领取的开始日期 */ private Date enableStartTime; /** * 可以领取的结束日期 */ private Date enableEndTime; /** * 优惠码 */ private String code; /** * 可以领取的会员等级[0->不限等级，其他-对应等级] */ private Integer memberLevel; /** * 发布状态[0-未发布，1-已发布] */ private Integer publish; } <fim_middle>